Day 6 part 1 (#9)

* day 6 part 1 solution

* update readme

---------

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

Author: jameslawlor

README.md

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

src/aoc_2023/days/6.py

@@ -0,0 +1,17 @@
+from aoc_2023.solvers.day_6_solvers import (
+    solve_day_6,
+)
+from aoc_2023.utils.input_handling import read_input, parse_args
+
+
+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}. "
+          )
+
+
+if __name__ == "__main__":
+    main()

src/aoc_2023/solvers/day_6_solvers.py

@@ -0,0 +1,58 @@
+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} | "
+        )
+    
+    def _compute_ways_to_win(self):
+        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
+            if distance_travelled > self.distance_to_beat:
+                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]))
+    
+    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):
+    
+    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)
+        races.add_race(race)
+    
+    return races
+
+
+def solve_day_6(input):
+    races = create_races(input)
+    return races.solve()

tests/test_day_6_solvers.py

@@ -0,0 +1,64 @@
+import pytest
+import math
+from aoc_2023.solvers.day_6_solvers import (
+    Race,
+    Races,
+    create_races,
+    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_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])
+
+
+def test_create_races(day_6_test_input, sample_races):
+    test_races = create_races(day_6_test_input)
+    assert test_races.n_races() == 3
+    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_solve_day_6(day_6_test_input):
+    assert solve_day_6(day_6_test_input) == 288