Okay a little late to this one. My part 1 halts as soon as we see an error.
Part two is a little more complex but it does not use List.delete_at or anything. It stops as soon as there are more errors than is legal to correct. To satisfy the edge cases you have to attempt each starting sequence if any fail before you can rule the report unsafe.
Could probably make it shorter. But you definitely don’t have to try deleting each element in the list in turn you can be a bit more surgical so I think we avoid the combinatorial explosion.
Part 1
def day_2_1() do
"./day_2_1_input.txt"
|> File.read!()
|> String.split(@new_line, trim: true)
|> Enum.reduce(0, fn line, count ->
[one, two | rest] = line |> String.split(" ")
one = String.to_integer(one)
two = String.to_integer(two)
diff = abs(one - two)
if diff > 0 && diff < 4 do
sum_safe_reports([two | rest], one < two, count)
else
count
end
end)
end
defp sum_safe_reports([_final], _, count), do: count + 1
defp sum_safe_reports([current, next | rest], incrementing?, count) do
next = String.to_integer(next)
diff = if incrementing?, do: next - current, else: current - next
if diff > 0 && diff < 4 do
sum_safe_reports([next | rest], incrementing?, count)
else
count
end
end
Part 2
def day_2_2() do
"./day_2_1_input.txt"
|> File.read!()
|> String.split(@new_line, trim: true)
|> Enum.reduce(0, fn line, count ->
[one, two, three | rest] =
line |> String.split(" ") |> Enum.map(&String.to_integer/1)
possible_starting_combos = [
{one, two, [two, three | rest], 0},
{one, three, [three | rest], 1},
{two, three, [three | rest], 1}
]
start_with_pair(possible_starting_combos, count)
end)
end
defp start_with_pair([], count), do: count
defp start_with_pair([{left, right, rest, errors} | next_iteration], count) do
new_count =
if is_safe?(left, right, left < right) do
sum_safe_reports(rest, left < right, errors, count)
else
count
end
if count == new_count do
start_with_pair(next_iteration, count)
else
new_count
end
end
defp is_safe?(first, next, incrementing?) do
diff = if incrementing?, do: next - first, else: first - next
diff > 0 && diff < 4
end
defp sum_safe_reports([_final], _, _, count), do: count + 1
defp sum_safe_reports([penultimate, final], incrementing?, errors, count) do
# If we have 0 errors then we can always fix when there are 2 numbers left.
if errors < 1 || is_safe?(penultimate, final, incrementing?) do
count + 1
else
count
end
end
defp sum_safe_reports([one, two, three | rest], incrementing?, errors, count) do
if is_safe?(one, two, incrementing?) do
sum_safe_reports([two, three | rest], incrementing?, errors, count)
else
errors = errors + 1
if is_safe?(one, three, incrementing?) && errors < 2 do
sum_safe_reports([three | rest], incrementing?, errors, count)
else
count
end
end
end
