day 2 (first make it work)

Author: maco

elixir/2024/lib/advent_of_code/day_02.ex

@@ -1,7 +1,52 @@
 defmodule AdventOfCode.Day02 do
-  def part1(_args) do
+  import AdventOfCode.Parsing
+
+  def part1(input) do
+    input
+    |> parse_rows_ints
+    |> Enum.count(fn row -> safe_increasing(row) or safe_decreasing(row) end)
+  end
+
+  def part2(input) do
+    parse_rows_ints(input)
+    |> Enum.count(fn row ->
+      safe_ish_increasing(row, []) or safe_ish_decreasing(row, [])
+    end)
+  end
+
+  defp safe_increasing([_]), do: true
+  defp safe_increasing([a, b | _tail]) when a >= b, do: false
+  defp safe_increasing([a, b | _tail]) when b - a > 3, do: false
+  defp safe_increasing([_a, b | tail]), do: safe_increasing([b | tail])
+
+  defp safe_decreasing([_]), do: true
+  defp safe_decreasing([a, b | _tail]) when a <= b, do: false
+  defp safe_decreasing([a, b | _tail]) when a - b > 3, do: false
+  defp safe_decreasing([_a, b | tail]), do: safe_decreasing([b | tail])
+
+  defp safe_ish_increasing([_], _), do: true
+
+  defp safe_ish_increasing([a, b | tail], popped) when a < b and b - a <= 3,
+    do: safe_ish_increasing([b | tail], [a | popped])
+
+  defp safe_ish_increasing([a, b | tail] = _list, []) do
+    safe_increasing([a | tail]) or safe_increasing([b | tail])
+  end
+
+  defp safe_ish_increasing([a, b | tail] = _list, [last | _]) do
+    safe_increasing([last, a | tail]) or safe_increasing([last, b | tail])
+  end
+
+  defp safe_ish_decreasing([_], _), do: true
+
+  defp safe_ish_decreasing([a, b | tail], popped) when a > b and a - b <= 3,
+    do: safe_ish_decreasing([b | tail], [a | popped])
+
+  defp safe_ish_decreasing([a, b | tail], []) do
+    safe_decreasing([a | tail]) or safe_decreasing([b | tail])
   end
 
-  def part2(_args) do
+  defp safe_ish_decreasing([a, b | tail], [last | _]) do
+    safe_decreasing([last, a | tail]) or safe_decreasing([last, b | tail])
   end
 end

elixir/2024/test/advent_of_code/day_02_test.exs

@@ -3,19 +3,42 @@ defmodule AdventOfCode.Day02Test do
 
   import AdventOfCode.Day02
 
-  @tag :skip
   test "part1" do
-    input = nil
-    result = part1(input)
+    input = """
+    7 6 4 2 1
+    1 2 7 8 9
+    9 7 6 2 1
+    1 3 2 4 5
+    8 6 4 4 1
+    1 3 6 7 9
+    """
 
-    assert result
+    2 = part1(input)
   end
 
-  @tag :skip
   test "part2" do
-    input = nil
-    result = part2(input)
+    input1 = """
+    7 6 4 2 1
+    1 2 7 8 9
+    9 7 6 2 1
+    1 3 2 4 5
+    8 6 4 4 1
+    1 3 6 7 9
+    """
 
-    assert result
+    4 =
+      part2(input1)
+
+    input2 = """
+    1 6 7 8 9
+    4 5 6 7 1
+    1 7 2 8 3
+    1 3 2 6 7
+    1 7 4 6 7
+    5 3 4 3 2
+    """
+
+    5 =
+      part2(input2)
   end
 end

python/solutions/2024/day_02/input.test.txt

@@ -0,0 +1,6 @@
+7 6 4 2 1
+1 2 7 8 9
+9 7 6 2 1
+1 3 2 4 5
+8 6 4 4 1
+1 3 6 7 9

python/solutions/2024/day_02/solution.py

@@ -0,0 +1,100 @@
+# Generated using @xavdid's AoC Python Template: https://github.com/xavdid/advent-of-code-python-template
+
+# puzzle prompt: https://adventofcode.com/2024/day/2
+
+from ...base import StrSplitSolution, answer
+from collections import deque
+
+
+class Solution(StrSplitSolution):
+    _year = 2024
+    _day = 2
+
+    # @answer(1234)
+    def part_1(self) -> int:
+        levels: list[deque[int]] = []
+        for row in self.input:
+            levels.append(deque(map(int, row.split())))
+
+        safe_levels = list(filter(lambda row:
+                             self.__safe_decreasing(row) or self.__safe_increasing(row),
+                             levels))
+        return len(safe_levels)
+
+
+    # @answer(1234)
+    def part_2(self) -> int:
+        levels: list[deque[int]] = []
+        for row in self.input:
+            levels.append(deque(map(int, row.split())))
+
+        print(levels)
+        safe_levels = list(filter(lambda row:
+                             self.__safe_ish_decreasing(row.copy(), []) or self.__safe_ish_increasing(row.copy(), []),
+                             levels))
+        return len(safe_levels)
+
+
+
+    def __safe_ish_decreasing(self, values: deque[int], seen: list[int]) -> bool:
+        try:
+            a = values.popleft()
+            b = values.popleft()
+            if b < a and a - b <= 3:
+                seen.append(a)
+                values.appendleft(b)
+                return self.__safe_ish_decreasing(values, seen)
+            elif seen == []:
+                return self.__safe_decreasing(self.__append_head(values, a)) \
+                    or self.__safe_decreasing(self.__append_head(values, b))
+            else:
+                last = seen.pop()
+                return self.__safe_decreasing(self.__append_head(self.__append_head(values, a), last)) \
+                    or self.__safe_decreasing(self.__append_head(self.__append_head(values, b), last))
+
+        except IndexError:
+            return True
+
+    def __safe_ish_increasing(self, values: deque[int], seen: list[int]) -> bool:
+        try:
+            a = values.popleft()
+            b = values.popleft()
+            if b > a and b - a <= 3:
+                seen.append(a)
+                values.appendleft(b)
+                return self.__safe_ish_increasing(values, seen)
+            elif seen == []:
+                return self.__safe_increasing(self.__append_head(values, a)) \
+                    or self.__safe_increasing(self.__append_head(values, b))
+            else:
+                last = seen.pop()
+                return self.__safe_increasing(self.__append_head(self.__append_head(values, a), last)) \
+                    or self.__safe_increasing(self.__append_head(self.__append_head(values, b), last))
+
+        except IndexError:
+            return True
+
+    def __append_head(self, values: deque[int], head: int) -> deque[int]:
+        my_copy = values.copy()
+        my_copy.appendleft(head)
+        return my_copy
+
+    def __safe_decreasing(self, values: deque[int]) -> bool:
+        last = values.popleft()
+        for val in values:
+            if last <= val:
+                return False
+            elif last - val > 3:
+                return False
+            last = val
+        return True
+
+    def __safe_increasing(self, values: deque[int]) -> bool:
+        last = values.popleft()
+        for val in values:
+            if last >= val:
+                return False
+            elif  val - last > 3:
+                return False
+            last = val
+        return True