I wonder why nearly all the solutions do String.split/2 when we can directly pattern-match strings
defp d2_destination_reducer("forward " <> value, acc),
do: %{acc | h: acc.h + String.to_integer(value)}
defp d2_destination_reducer("down " <> value, acc),
do: %{acc | v: acc.v + String.to_integer(value)}
defp d2_destination_reducer("up " <> value, acc),
do: %{acc | v: acc.v - String.to_integer(value)}
defp d2_destination_reducer(_, acc), do: acc
Yeah, I went for that as well which was really nice but ended up duplicating the move functions for step 2 to change the logic.
def process2(input) do
input
|> parse_input()
|> Enum.reduce(%{h: 0, d: 0, aim: 0}, fn val, acc -> move2(acc, val) end)
|> calc_position
end
def parse_input(input) do
input
|> String.split("\n", trim: true)
end
def calc_position(%{:h => h, :d => d}), do: h * d
def move2(%{:h => h, :d => d, :aim => aim} = p, "forward " <> steps) do
steps = String.to_integer(steps)
%{p | :h => h + steps, :d => d + aim * steps}
end
def move2(%{:aim => aim} = p, "up " <> steps) do
steps = String.to_integer(steps)
%{p | :aim => aim - steps}
end
def move2(%{:aim => aim} = p, "down " <> steps) do
steps = String.to_integer(steps)
%{p | aim: aim + steps}
end
And thought putting the accumulator in the first argument would make a nice API but made using it in Enum.reduce more cumbersome.
Here’s mine.
defmodule Day2 do
defmodule Part1 do
def run(input) do
{depth, distance} =
Enum.reduce(input, {_depth = 0, _distance = 0}, fn
{:forward, amount}, {depth, distance} ->
{depth, distance + amount}
{:up, amount}, {depth, distance} ->
{depth - amount, distance}
{:down, amount}, {depth, distance} ->
{depth + amount, distance}
end)
depth * distance
end
end
defmodule Part2 do
def run(input) do
{depth, distance, _aim} =
Enum.reduce(input, {_depth = 0, _distance = 0, _aim = 0}, fn
{:forward, amount}, {depth, distance, aim} ->
depth = depth + aim * amount
{depth, distance + amount, aim}
{:up, amount}, {depth, distance, aim} ->
{depth, distance, aim - amount}
{:down, amount}, {depth, distance, aim} ->
{depth, distance, aim + amount}
end)
depth * distance
end
end
def input do
"inputs/2.txt"
|> File.stream!()
|> Stream.map(fn line ->
{instruction_atom, amount_string} =
case line do
"up " <> amount -> {:up, amount}
"down " <> amount -> {:down, amount}
"forward " <> amount -> {:forward, amount}
end
{
instruction_atom,
amount_string
|> String.trim()
|> String.to_integer()
}
end)
end
def example_input do
[
{:forward, 5},
{:down, 5},
{:forward, 8},
{:up, 3},
{:down, 8},
{:forward, 2}
]
end
end
Here’s my take on day2:
defmodule Day02 do
def parse(path) do
{:ok, cont}=File.read(path)
cont |> String.split(["\n","\r"], trim: true) |> trim()
end
def trim([],c), do: c
def trim([h|t],c) do
[str,i]=String.split(h," ")
trim(t,c++[[str,String.to_integer(i)]])
end
def trim(l), do: trim(l,[])
def reg([],n,m), do: n*m
def reg([["forward",i]|t],n,m), do: reg(t,i+n,m)
def reg([["down",i]|t],n,m), do: reg(t,n,i+m)
def reg([["up",i]|t],n,m), do: reg(t,n,m-i)
def reg2([],n,m,_), do: n*m
def reg2([["forward",i]|t],n,m,a), do: reg2(t,n+i,m+(a*i),a)
def reg2([["down",i]|t],n,m,a), do: reg2(t,n,m,i+a)
def reg2([["up",i]|t],n,m,a), do: reg2(t,n,m,a-i)
def part1(input), do: reg(parse(input),0,0)
def part2(input), do: reg2(parse(input),0,0,0)
end
Hi, @hadar_sm, a small suggestion, avoid using ++.
def trim([],c), do: c
def trim([h|t],c) do
[str,i]=String.split(h," ")
trim(t,c++[[str,String.to_integer(i)]]) # <-- here
end
def trim(l), do: trim(l,[])
can be optimized as
def trim([],c), do: Enum.reverse(c) # <-- do a reverse when everything is done
def trim([h|t],c) do
[str,i]=String.split(h," ")
trim(t, [[str,String.to_integer(i)] | c]) # <-- prepending instead of appending
end
def trim(l), do: trim(l,[])
This is a very common trick.
Here are my solutions. I don’t like Part 1 and i know that it’s not DRY.
instructions =
File.stream!("data/day_2.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(fn str -> String.split(str, " ") end)
|> Enum.group_by(fn x -> hd(x) end, fn x -> tl(x) end)
down =
instructions
|> Map.get("down")
|> List.flatten()
|> Enum.map(&String.to_integer/1)
|> Enum.sum()
up =
instructions
|> Map.get("up")
|> List.flatten()
|> Enum.map(&String.to_integer/1)
|> Enum.sum()
forward =
instructions
|> Map.get("forward")
|> List.flatten()
|> Enum.map(&String.to_integer/1)
|> Enum.sum()
position = (down - up) * forward
instructions =
File.stream!("data/day_2.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(fn str -> String.split(str, " ") end)
|> Stream.map(fn [cmd, x] -> [cmd, String.to_integer(x)] end)
|> Enum.reduce({0, 0, 0}, fn instruction, {depth, aim, horizontal_pos} ->
case instruction do
["forward", x] ->
{aim * x + depth, aim, horizontal_pos + x}
["up", x] ->
{depth, aim - x, horizontal_pos}
["down", x] ->
{depth, aim + x, horizontal_pos}
end
end)
|> then(fn {depth, _aim, hor_pos} -> depth * hor_pos end)
I made it with some internal states.
defmodule Day2 do
defmodule State do
defstruct [x: 0, depth: 0]
def apply_command({:forward, x}, %__MODULE__{} = state),
do: %{state | x: state.x + x}
def apply_command({:up, depth}, %__MODULE__{} = state),
do: %{state | depth: state.depth - depth}
def apply_command({:down, depth}, %__MODULE__{} = state),
do: %{state | depth: state.depth + depth}
end
defmodule State2 do
defstruct [x: 0, depth: 0, aim: 0]
def apply_command({:forward, x}, %__MODULE__{} = state),
do: %{state | x: state.x + x, depth: state.depth + state.aim * x}
def apply_command({:up, aim}, %__MODULE__{} = state),
do: %{state | aim: state.aim - aim}
def apply_command({:down, aim}, %__MODULE__{} = state),
do: %{state | aim: state.aim + aim}
end
def part1 do
state = load_commands()
|> Enum.reduce(%State{}, &State.apply_command/2)
|> IO.inspect(label: "FINAL STATE")
state.x * state.depth
end
def part2 do
state = load_commands()
|> Enum.reduce(%State2{}, &State2.apply_command/2)
|> IO.inspect(label: "FINAL STATE")
state.x * state.depth
end
defp load_commands do
"input.txt"
|> File.read!()
|> String.split("\n", trim: true)
|> Enum.map(& to_command(&1))
end
defp to_command(binary) when is_binary(binary),
do: to_command(String.split(binary))
defp to_command([key, value]) when key in ~w(forward up down),
do: {String.to_atom(key), String.to_integer(value)}
end
Here’s mine:
defmodule Submarine do
def input_stream(file) do
file
|> File.stream!()
|> Stream.map(&String.trim/1)
|> Stream.map(&String.split/1)
|> Stream.map(fn [direction, count] -> [direction, String.to_integer(count)] end)
end
# Rules for Part1
def update_position(["forward", count], {horizontal, depth}), do: {horizontal+count, depth}
def update_position(["up", count], {horizontal, depth}), do: {horizontal, depth-count}
def update_position(["down", count], {horizontal, depth}), do: {horizontal, depth+count}
# Rules for Part2
def update_position(["forward", count], {horizontal, depth, aim}), do: {horizontal+count, depth+count*aim, aim}
def update_position(["up", count], {horizontal, depth, aim}), do: {horizontal, depth, aim-count}
def update_position(["down", count], {horizontal, depth, aim}), do: {horizontal, depth, aim+count}
end
[{0, 0}, {0, 0, 0}]
|> Enum.map(fn start_pos ->
System.argv()
|> hd()
|> Submarine.input_stream()
|> Enum.reduce(start_pos, &Submarine.update_position/2)
end)
|> Enum.with_index(1)
|> Enum.map(fn {tuple, part_number} ->
result = elem(tuple, 0) * elem(tuple, 1)
"Part #{part_number}: #{result}"
end)
|> Enum.map(&IO.puts/1)
My solution, simple but honest:
Part 1:
defmodule Submarine do
def calc_position(list) do
forward_sum = sum_movement(list, "forward")
up_sum = sum_movement(list, "up")
down_sum = sum_movement(list, "down")
depth = down_sum - up_sum
forward_sum * depth
end
defp sum_movement(movs, type) do
movs
|> Enum.filter(fn [k,_v] -> k == type end)
|> Enum.map(fn [_k,v] -> String.to_integer(v) end)
|> Enum.reduce(fn x, acc -> x + acc end)
end
end
input
|> String.split(" ")
|> Enum.chunk_every(2)
|> Submarine.calc_position
Part 2:
defmodule Submarine2 do
def calc_position(list) do
_calc(list, 0, 0, 0)
end
defp _calc([head | tail], aim, horizontal, depth) do
[key, value] = head
cond do
key == "forward" ->
new_horizontal = horizontal + String.to_integer(value)
_calc(tail, aim, new_horizontal, calc_depth(depth, aim, String.to_integer(value)) )
key == "down" ->
_calc(tail, aim + String.to_integer(value), horizontal, depth)
key == "up" ->
_calc(tail, aim - String.to_integer(value), horizontal, depth)
end
end
defp _calc([], _, horizontal, depth) do
horizontal * depth
end
defp calc_depth(depth, aim, forward_value) do
depth + (aim * forward_value)
end
end
input
|> String.split(" ")
|> Enum.chunk_every(2)
|> Submarine2.calc_position