Advent of Code 2021 - Day 2

Here is my solution:

https://github.com/bjorng/advent-of-code-2021/blob/1f0f194a4474604341598025821e74c812f8d8fa/day02/lib/day02.ex

I used a similar approach

https://github.com/APB9785/AoC-2021-elixir/blob/master/lib/day_02.ex

This one wasn’t as fun as the day 1 one for me.

defmodule AdventOfCode.Y2021.Day02 do
  @moduledoc """
  --- Day 2: Dive! ---
  Problem Link: https://adventofcode.com/2021/day/2
  """
  use AdventOfCode.Helpers.InputReader, year: 2021, day: 2

  def run_1, do: input!() |> parse() |> track_positions() |> then(& &1.depth * &1.horizontal)
  def run_2, do: input!() |> parse() |> track_aims() |> then(& &1.depth * &1.horizontal)

  def parse(data) do
    data
    |> String.split("\n")
    |> Enum.map(fn line ->
      [direction, value] = String.split(line, " ")
      {String.to_existing_atom(direction), String.to_integer(value)}
    end)
  end

  defp track_positions(directions) do
    directions
    |> Enum.reduce(%{horizontal: 0, depth: 0}, fn
      {:forward, v}, %{horizontal: horizontal} = acc -> %{acc | horizontal: horizontal + v}
      {:backward, v}, %{horizontal: horizontal} = acc -> %{acc | horizontal: horizontal - v}
      {:up, v}, %{depth: depth} = acc -> %{acc | depth: depth - v}
      {:down, v}, %{depth: depth} = acc -> %{acc | depth: depth + v}
    end)
  end

  defp track_aims(directions) do
    directions
    |> Enum.reduce(%{horizontal: 0, depth: 0, aim: 0}, fn
      {:forward, v}, %{horizontal: horizontal, depth: depth, aim: aim} = acc ->
        %{acc | horizontal: horizontal + v, depth: depth + aim * v}

      {:backward, v}, %{horizontal: horizontal} = acc ->
        %{acc | horizontal: horizontal - v}

      {:up, v}, %{aim: aim} = acc ->
        %{acc | aim: aim - v}

      {:down, v}, %{aim: aim} = acc ->
        %{acc | aim: aim + v}
    end)
  end
end

As usual, my solution is extremely scripting style:

Part 1

#!/usr/bin/env elixir

File.stream!("input.txt")
|> Stream.map(&String.split(&1, ~r/\s+/, trim: true))
|> Stream.map(fn
  ["forward", amount] -> {String.to_integer(amount), 0}
  ["down", amount] -> {0, String.to_integer(amount)}
  ["up", amount] -> {0, -String.to_integer(amount)}
end)
|> Enum.reduce({0, 0}, fn {dx, dy}, {x, y} ->
  {x + dx, y + dy}
end)
|> then(fn {x, y} -> x * y end)
|> IO.inspect()

Part 2

#!/usr/bin/env elixir

File.stream!("input.txt")
|> Stream.map(&String.split(&1, ~r/\s+/, trim: true))
|> Stream.map(fn [command, steps] ->
  {command, String.to_integer(steps)}
end)
|> Enum.reduce({0, 0, 0}, fn
  {"down", amount}, {x, y, aim} -> {x, y, aim + amount}
  {"up", amount}, {x, y, aim} -> {x, y, aim - amount}
  {"forward", amount}, {x, y, aim} -> {x + amount, y + aim * amount, aim}
end)
|> then(fn {x, y, _} -> x * y end)
|> IO.inspect()

In Part 1, you could’ve used Tuple.product and get rid of that then ? I was contemplating on representing my data structure as tuple only so that I could use Tuple.product - one of my favourite functions but since I was in a noisy room, I made the representation more verbose so I don’t mentally keep track of the which position means what.

Clever way to represent the positions though!

Agree not as fun as Day 1 for some reason. My solution:
https://github.com/stevensonmt/advent_of_code/blob/63ca9e8b1d2c7a1d42ae8840b0fa36fb24391864/2021/day2/day2/lib/day2.ex

Exactly. But the first few days should be a warmup, right?

To make things a little bit more fun, I introduced some sort of sigil.

defmodule Point2D do
  defstruct x: 0, y: 0

  def new(x, y) when is_integer(x) and is_integer(y), do:
    %__MODULE__{x: x, y: y}

  def sigil_p(string, _) do
    ~r/-?\d+/
    |> Regex.scan(string)
    |> List.flatten
    |> Enum.map(&String.to_integer/1)
    |> then(&apply(__MODULE__, :new, &1))
  end

  def add(%__MODULE__{x: x1, y: y1}, %__MODULE__{x: x2, y: y2}) do
    new(x1 + x2, y1 + y2)
  end
end

and then rewrote Part 1:

#!/usr/bin/env elixir

import Point2D, only: [sigil_p: 2]

File.stream!("input.txt")
|> Stream.map(&String.split(&1, ~r/\s+/, trim: true))
|> Stream.map(fn
  ["forward", amount] -> ~p(#{amount} 0)
  ["down", amount] -> ~p(0 #{amount})
  ["up", amount] -> ~p(0 -#{amount})
end)
|> Enum.reduce(~p(0 0), &Point2D.add/2)
|> then(fn %{x: x, y: y} -> x * y end)
|> IO.inspect()

niiice. I will freeze my Elixir refactor attempts and get an F# solution out tomorrow. There is an opportunity of using a syntax gimmick there which I’d very much like to try out.

You planning on running Benchee for your two solutions?

Here’s mine:

defmodule Aoc.Y2021.Day02 do
  @moduledoc false
  import Aoc.Helper.IO

  def run_part1(), do: get_input() |> solve_part1()
  def run_part2(), do: get_input() |> solve_part2()

  def solve_part1(data), do: data |> plan_course(0, 0)
  def plan_course([], width, depth), do: width * depth
  def plan_course([["forward", value] | rest], width, depth), do: plan_course(rest, width + value, depth)
  def plan_course([["down", value] | rest], width, depth), do: plan_course(rest, width, depth + value)
  def plan_course([["up", value] | rest], width, depth), do: plan_course(rest, width, depth - value)

  def solve_part2(data), do: data |> process_aim(0, 0, 0)

  def process_aim([], width, depth, _aim), do: width * depth

  def process_aim([["forward", value] | rest], width, depth, aim),
    do: process_aim(rest, width + value, depth + aim * value, aim)

  def process_aim([["down", value] | rest], width, depth, aim), do: process_aim(rest, width, depth, aim + value)
  def process_aim([["up", value] | rest], width, depth, aim), do: process_aim(rest, width, depth, aim - value)

  defp get_input(),
    do:
      get_string_input("2021", "02")
      |> String.split("\n")
      |> Enum.map(&String.split(&1, " "))
      |> Enum.map(fn [ins, value] -> [ins, String.to_integer(value)] end)
end

No, but I guess the first solution should be faster since it doesn’t use regular expressions. However, I can make that sigil_p a macro (the interpolation part can be tricky to implement), and put some of the parsing jobs to the compile-time, but I feel it does not worth the effort because it’s an Elixir script anyway, not a never-should-die service.