save state

Author: jameslawlor

src/advent_of_code/year_2025/day_01.py

@@ -3,6 +3,7 @@
 DIAL_STARTING_POSITION = 50
 DIAL_START = 0
 DIAL_END = 99
+DIAL_SIZE = DIAL_END - DIAL_START + 1
 
 def parse_instruction(instruction):
     turn_direction = instruction[0]
@@ -17,25 +18,48 @@ def parse_instruction(instruction):
     return (turn_direction, distance)
 
 def turn_dial(current_position, turn_direction, distance):
-    return (current_position + turn_direction * distance) % (DIAL_END + 1)
+    return (current_position + turn_direction * distance) % DIAL_SIZE
 
-def position_counter(current_position, target_position=0, ):
+def target_position_counter(current_position, target_position=0, ):
     if current_position == target_position:
         return 1
     return 0
 
+def points_at_zero_counter(current_position, turn_direction, distance):
+    full_loops = distance // DIAL_SIZE
+    
+    partial_loops = 0
+    
+    # Check if we passed zero in the remaining distance after full loops
+    new_position = turn_dial(current_position, turn_direction, distance)
+    if new_position > current_position and turn_direction == -1 and current_position != 0 and new_position != 0:
+        partial_loops += 1
+    elif new_position < current_position and turn_direction == 1 and current_position != 0 and new_position != 0:
+        partial_loops += 1
+
+    # check if we landed on zero
+    if new_position == 0:
+        partial_loops += 1
+        
+    return full_loops + partial_loops
+
 def solve(parsed_input):
 
     current_position = DIAL_STARTING_POSITION
     target_position_count = 0
+    points_at_zero_count = 0
 
     for instruction in parsed_input:
         turn_direction, distance = parse_instruction(instruction)
-        current_position = turn_dial(current_position, turn_direction, distance)
-        target_position_count += position_counter(current_position)
+        new_position = turn_dial(current_position, turn_direction, distance)
+
+        target_position_count += target_position_counter(new_position)
+        points_at_zero_count += points_at_zero_counter(current_position, turn_direction, distance)
+        # update start position
+        current_position = new_position
 
     part_1_solution = target_position_count
-    part_2_solution = None
+    part_2_solution = points_at_zero_count
     return (part_1_solution, part_2_solution)
 
 

tests/year_2025/test_day_01.py

@@ -2,7 +2,8 @@
 from advent_of_code.year_2025.day_01 import (
     solve,
     turn_dial,
-    position_counter,
+    target_position_counter,
+    points_at_zero_counter,
 )
 
 
@@ -32,16 +33,16 @@ def test_solver(day_01_test_input, day_01_expected_output):
     assert result == day_01_expected_output
 
 @pytest.fixture(params=[
-        (50 ,    -1    , 68 , 82    , 0 , 1 ),
-        (82 ,    -1    , 30 , 52    , 0 , 0 ),
-        (52 ,    1     , 48 , 0     , 1 , 1 ), 
-        (0  ,    -1    , 5  , 95    , 0 , 0 ),
-        (95 ,    1     , 60 , 55    , 0 , 1 ),
-        (55 ,    -1    , 55 , 0     , 1 , 1 ),
-        (0  ,    -1    , 1  , 99    , 0 , 0 ),
-        (99 ,    -1    , 99 , 0     , 1 , 1 ),
-        (0  ,    1     , 14 , 14    , 0 , 0 ),
-        (14 ,    -1    , 82 , 32    , 0 , 1 ),
+        (50 ,    -1    , 68 , 82    , 0 , 1 ), # case 0
+        (82 ,    -1    , 30 , 52    , 0 , 0 ), # case 1
+        (52 ,    1     , 48 , 0     , 1 , 1 ), # case 2 
+        (0  ,    -1    , 5  , 95    , 0 , 0 ), # case 3
+        (95 ,    1     , 60 , 55    , 0 , 1 ), # case 4
+        (55 ,    -1    , 55 , 0     , 1 , 1 ), # case 5
+        (0  ,    -1    , 1  , 99    , 0 , 0 ), # case 6
+        (99 ,    -1    , 99 , 0     , 1 , 1 ), # case 7
+        (0  ,    1     , 14 , 14    , 0 , 0 ), # case 8
+        (14 ,    -1    , 82 , 32    , 0 , 1 ), # case 9
     ],
 )
 def turn_case(request):
@@ -57,25 +58,27 @@ def test_turn_dial(turn_case):
     assert new_position == expected_new_position
 
 
-def test_position_counter(turn_case):
+def test_target_position_counter(turn_case):
     _, _, _, expected_new_position, expected_count, _ = turn_case
-    actual_count = position_counter(expected_new_position)
+    actual_count = target_position_counter(expected_new_position)
     assert actual_count == expected_count
 
+def test_points_at_zero_counter(turn_case):
+    current_position, turn_direction, distance, _, _, expected_count = turn_case
+    actual_count = points_at_zero_counter(current_position, turn_direction, distance)
+    assert actual_count == expected_count
 
-# @pytest.mark.parametrize(
-#     "start_position, turn_direction, distance, expected_count",
-#     [
-#         (50, 1, 1000, 10),
-#         # (50, 1, 49, 0),
-#         # (50, -1, 49, 0),
-#         # (50, -1, 50, 1),
-#         # (50, -1, 51, 1),
-#         # (99, 1, 1, 1),
-#         # (99, -1, 1, 0),
-#         # (0, 1, 100, 1),
-#     ]
-# )
-# def test_passing_zero_counter(start_position, turn_direction, distance, expected_count):
-#     count = passing_zero_counter(start_position, turn_direction, distance)
-#     assert count == expected_count
+@pytest.mark.parametrize(
+    "start_position, turn_direction, distance, expected_count",
+    [
+        (50, 1, 1000, 10),
+        (50, 1, 1050, 11),
+        (0, 1, 100, 1),
+        (0, 1, 1, 0),
+        (50 , -1, 68, 1),
+        (50 , 1, 68, 1),
+    ]
+)
+def test_points_at_zero_counter_extra_test_cases(start_position, turn_direction, distance, expected_count):
+    count = points_at_zero_counter(start_position, turn_direction, distance)
+    assert count == expected_count