d6pt2 working (#10)

Co-authored-by: James <james@Susans-MacBook-Air.local>

Author: jameslawlor

Makefile

@@ -14,4 +14,5 @@ solutions:
 	python3 src/aoc_2023/days/1.py --input_file inputs/1.txt --part 2
 	python3 src/aoc_2023/days/2.py --input_file inputs/2.txt
 	python3 src/aoc_2023/days/3.py --input_file inputs/3.txt
-	python3 src/aoc_2023/days/4.py --input_file inputs/4.txt
+	python3 src/aoc_2023/days/4.py --input_file inputs/4.txt
+	python3 src/aoc_2023/days/6.py --input_file inputs/6.txt

README.md

@@ -16,4 +16,5 @@ docker run aoc-2023-app
 | 03 | ⭐️ | ⭐️ |
 | 04 | ⭐️ | ⭐️ |
 | 05 | todo | todo |
-| 06 | ⭐️ | todo |
+| 06 | ⭐️ | ⭐️ |
+| 07 | todo | todo |

src/aoc_2023/days/4.py

@@ -8,9 +8,11 @@ def main():
     args = parse_args()
     input = read_input(args.input_file)
     result_part_1, result_part_2 = solve_day_4(input)
-    print(f"Day 4: "
-          f" Total points for part 1 is {result_part_1}. "
-          f" Total points for part 2 is {result_part_2}. ")
+    print(
+        f"Day 4: "
+        f" Total points for part 1 is {result_part_1}. "
+        f" Total points for part 2 is {result_part_2}. "
+    )
 
 
 if __name__ == "__main__":

src/aoc_2023/days/6.py

@@ -7,10 +7,12 @@
 def main():
     args = parse_args()
     input = read_input(args.input_file)
-    result_part_1 = solve_day_6(input)
-    print(f"Day 6: "
-          f" Result for part 1 is {result_part_1}. "
-          )
+    result_part_1, result_part_2 = solve_day_6(input)
+    print(
+        f"Day 6: "
+        f" Result for part 1 is {result_part_1}. "
+        f" Result for part 2 is {result_part_2}. "
+    )
 
 
 if __name__ == "__main__":

src/aoc_2023/solvers/day_4_solvers.py

@@ -64,7 +64,7 @@ def compute_copies(cards):
         n_matches_on_card = card.n_matches
         n_copies_of_card = card.n_copies
         copies_to_generate = n_copies_of_card
-        for next_card in cards[card_number+1 : card_number + n_matches_on_card + 1]:
+        for next_card in cards[card_number + 1 : card_number + n_matches_on_card + 1]:
             next_card.n_copies += copies_to_generate
     return cards
 

src/aoc_2023/solvers/day_6_solvers.py

@@ -1,58 +1,61 @@
 import math
 import re
 
+
 class Race:
     def __init__(self, time, distance_to_beat):
         self.time = int(time)
         self.distance_to_beat = int(distance_to_beat)
         self._compute_ways_to_win()
 
     def __str__(self):
-        return (
-            f"time: {self.time} | "
-            f"distance_to_beat: {self.distance_to_beat} | "
-        )
-    
+        return f"time: {self.time} | " f"distance_to_beat: {self.distance_to_beat} | "
+
     def _compute_ways_to_win(self):
-        possible_speeds = range(self.time+1)
+        possible_speeds = range(self.time + 1)
         self.ways_to_win = 0
         for possible_speed in possible_speeds:
             time_remaining = self.time - possible_speed
-            distance_travelled = possible_speed*time_remaining
+            distance_travelled = possible_speed * time_remaining
             if distance_travelled > self.distance_to_beat:
-                self.ways_to_win+=1
-    
+                self.ways_to_win += 1
+
+
 class Races:
     def __init__(self, *races):
         self.races = list(races)
 
     def __str__(self):
-        return ("".join([str(race) for race in self.races]))
-    
+        return "".join([str(race) for race in self.races])
+
     def n_races(self):
         return len(self.races)
 
     def add_race(self, race):
         self.races.append(race)
-    
+
     def solve(self):
         return math.prod([race.ways_to_win for race in self.races])
 
 
-def create_races(input):
-    
+def create_races(input, part=1):
     races = Races()
 
     times = re.findall(r"(\d+)", input[0])
     distances = re.findall(r"(\d+)", input[1])
 
-    for time, distance in zip(times,distances):
-        race = Race(time=time,distance_to_beat=distance)
+    if part == 2:
+        times = ["".join(times)]
+        distances = ["".join(distances)]
+
+    for time, distance in zip(times, distances):
+        race = Race(time=time, distance_to_beat=distance)
         races.add_race(race)
-    
+
     return races
 
 
 def solve_day_6(input):
-    races = create_races(input)
-    return races.solve()
+    races_part_1 = create_races(input, part=1)
+    races_part_2 = create_races(input, part=2)
+    return (races_part_1.solve(), races_part_2.solve())

tests/test_day_4_solvers.py

@@ -48,9 +48,10 @@ def test_solve_day_4(
         sum(day_4_expected_final_cards_count),
     )
 
-def test_compute_copies(day_4_test_input,day_4_expected_final_cards_count):
+
+def test_compute_copies(day_4_test_input, day_4_expected_final_cards_count):
     test_cards = create_cards(day_4_test_input)
     compute_total_score(test_cards)
     test_cards_with_copies = compute_copies(test_cards)
     test_n_scratchcards = [card.n_copies for card in test_cards_with_copies]
-    assert test_n_scratchcards == day_4_expected_final_cards_count
+    assert test_n_scratchcards == day_4_expected_final_cards_count

tests/test_day_6_solvers.py

@@ -7,58 +7,79 @@
     solve_day_6,
 )
 
+
 @pytest.fixture
 def day_6_test_input():
     return [
         "Time:      7  15   30",
         "Distance:  9  40  200",
     ]
 
+
 @pytest.fixture
 def sample_race():
     return Race(time=7, distance_to_beat=9)
 
 
+@pytest.fixture
+def sample_race_part_2():
+    return Race(time=71530, distance_to_beat=940200)
+
+
 @pytest.fixture
 def sample_races():
     return Races(
         Race(time=7, distance_to_beat=9),
         Race(time=15, distance_to_beat=40),
         Race(time=30, distance_to_beat=200),
     )
-        
+
 
 def test_race_initialization(sample_race):
     assert sample_race.time == 7
     assert sample_race.distance_to_beat == 9
     assert sample_race.ways_to_win == 4
 
+
 def test_race_compute_ways_to_win(sample_race):
     sample_race._compute_ways_to_win()
     assert sample_race.ways_to_win == 4
 
+
 def test_races_initialisation():
     races = Races()
     for race in races.races:
         print(race)
     assert races.races == []
 
+
 def test_races_add_race(sample_race):
     races = Races()
     races.add_race(sample_race)
     assert races.races == [sample_race]
 
+
 def test_races_solve(sample_races):
-    assert sample_races.solve() == math.prod([4,8,9])
+    assert sample_races.solve() == math.prod([4, 8, 9])
 
 
-def test_create_races(day_6_test_input, sample_races):
-    test_races = create_races(day_6_test_input)
+def test_create_races_part_1(day_6_test_input, sample_races):
+    test_races = create_races(day_6_test_input, part=1)
     assert test_races.n_races() == 3
-    for race, expected_race in zip(test_races.races,sample_races.races):
+    for race, expected_race in zip(test_races.races, sample_races.races):
         assert race.time == expected_race.time
         assert race.distance_to_beat == expected_race.distance_to_beat
         assert race.ways_to_win == expected_race.ways_to_win
 
+
+def test_create_races_part_2(day_6_test_input, sample_race_part_2):
+    test_races = create_races(day_6_test_input, part=2)
+    assert test_races.n_races() == 1
+    test_race = test_races.races[0]
+    assert test_race.time == sample_race_part_2.time
+    assert test_race.distance_to_beat == sample_race_part_2.distance_to_beat
+    assert test_race.ways_to_win == sample_race_part_2.ways_to_win
+
+
 def test_solve_day_6(day_6_test_input):
-    assert solve_day_6(day_6_test_input) == 288
+    assert solve_day_6(day_6_test_input) == (288, 71503)