Merge pull request #4 from marcelblijleven/feature/add-2015-day-15-to-18

Feature/add 2015 day 15 to 18

Author: marcelblijleven

README.md

@@ -1,5 +1,8 @@
 # Advent of Code ⭐️
 [![Stars collected](https://shields.io/static/v1?label=stars%20collected&message=50&color=yellow)]()
+[![codecov](https://codecov.io/gh/marcelblijleven/adventofcode/branch/master/graph/badge.svg?token=jZ2TgfyltM)](https://codecov.io/gh/marcelblijleven/adventofcode)
+[![tests](https://github.com/marcelblijleven/adventofcode/actions/workflows/tests.yaml/badge.svg)](https://github.com/marcelblijleven/adventofcode)
+[![version](https://img.shields.io/github/v/release/marcelblijleven/adventofcode.svg)](https://github.com/marcelblijleven/adventofcode/releases)
 
 Collection of my Advent of Code solutions in an overkill project setup 👻🎄.
 

codecov.yml

@@ -0,0 +1,2 @@
+ignore:
+  - setup.py

src/adventofcode/util/helpers.py

@@ -2,7 +2,7 @@
 import os
 import pstats
 import time
-from typing import Callable, Literal
+from typing import Callable, Literal, Dict, Any
 
 from adventofcode.config import RUNNING_ALL
 from adventofcode.util.console import console
@@ -93,3 +93,17 @@ def wrapper(*args, **kwargs):
         return wrapper
 
     return decorator
+
+
+def memoize(func: Callable):  # type: ignore
+    cache: Dict[Any, Any] = dict()
+
+    def memoized_func(*args):
+        if args in cache:
+            return cache[args]
+
+        result = func(*args)
+        cache[args] = result
+        return result
+
+    return memoized_func

src/adventofcode/year_2015/day_15_2015.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import re
+from typing import List
+
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer
+from adventofcode.util.input_helpers import get_input_for_day
+
+PATTERN = re.compile(r'(-?\d)')
+
+
+class Ingredient:
+    def __init__(self, name: str, capacity: int, durability: int, flavor: int, texture: int, calories: int):
+        self.name = name
+        self.capacity = capacity
+        self.durability = durability
+        self.flavor = flavor
+        self.texture = texture
+        self.calories = calories
+        self._quantity = 0
+
+    def __repr__(self):
+        return str(self)
+
+    def __str__(self):
+        return f'{self.name}: capacity: {self.capacity}, durability: {self.durability}, flavor: {self.flavor}, texture: {self.texture}'
+
+    @property
+    def quantity(self) -> int:
+        return self._quantity
+
+    def set_quantity(self, quantity: int) -> Ingredient:
+        self._quantity = quantity
+        return self
+
+    def get_capacity(self) -> int:
+        return self.capacity * self.quantity
+
+    def get_durability(self) -> int:
+        return self.durability * self.quantity
+
+    def get_flavor(self) -> int:
+        return self.flavor * self.quantity
+
+    def get_texture(self) -> int:
+        return self.texture * self.quantity
+
+    def get_calories(self) -> int:
+        return self.calories * self.quantity
+
+
+class Cookie:
+    def __init__(self, ingredients: List[Ingredient]):
+        self.ingredients = ingredients
+
+    @property
+    def calories(self) -> int:
+        return sum([ingredient.get_calories() for ingredient in self.ingredients])
+
+    @property
+    def score(self) -> int:
+        capacity = sum([ingredient.get_capacity() for ingredient in self.ingredients])
+        durability = sum([ingredient.get_durability() for ingredient in self.ingredients])
+        flavor = sum([ingredient.get_flavor() for ingredient in self.ingredients])
+        texture = sum([ingredient.get_texture() for ingredient in self.ingredients])
+
+        if capacity < 0:
+            capacity = 0
+        if durability < 0:
+            durability = 0
+        if flavor < 0:
+            flavor = 0
+        if texture < 0:
+            texture = 0
+
+        return capacity * durability * flavor * texture
+
+
+def parse_ingredients(input_data: List[str]) -> List[Ingredient]:
+    ingredients: List[Ingredient] = []
+
+    for line in input_data:
+        name, content = line.split(': ')
+        capacity, durability, flavor, texture, calories = map(int, PATTERN.findall(content))
+        ingredient = Ingredient(name, capacity, durability, flavor, texture, calories)
+        ingredients.append(ingredient)
+
+    return ingredients
+
+
+def find_highest_scoring_cookie(input_data: List[str], match_calories: bool = False) -> int:  # noqa: C901
+    highest_score = 0
+    ingredients = parse_ingredients(input_data)
+    max_ingredients = 100
+
+    if len(ingredients) == 2:
+        for a in range(max_ingredients):
+            for b in range(max_ingredients - a):
+                b = 100 - a
+                ingredients[0].set_quantity(a)
+                ingredients[1].set_quantity(b)
+
+                cookie = Cookie(ingredients)
+
+                if match_calories and cookie.calories != 500:
+                    continue
+
+                if cookie.score > highest_score:
+                    highest_score = cookie.score
+    else:
+        for a in range(max_ingredients):
+            for b in range(max_ingredients - a):
+                for c in range(max_ingredients - a - b):
+                    d = max_ingredients - a - b - c
+                    ingredients[0].set_quantity(a)
+                    ingredients[1].set_quantity(b)
+                    ingredients[2].set_quantity(c)
+                    ingredients[3].set_quantity(d)
+                    cookie = Cookie(ingredients)
+
+                    if match_calories and cookie.calories != 500:
+                        continue
+
+                    if cookie.score > highest_score:
+                        highest_score = cookie.score
+
+    return highest_score
+
+
+@solution_timer(2015, 15, 1)
+def part_one(input_data: List[str]):
+    answer = find_highest_scoring_cookie(input_data)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 15, 1)
+
+    return answer
+
+
+@solution_timer(2015, 15, 2)
+def part_two(input_data: List[str]):
+    answer = find_highest_scoring_cookie(input_data, match_calories=True)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 15, 2)
+
+    return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2015, 15)
+    part_one(data)
+    part_two(data)

src/adventofcode/year_2015/day_16_2015.py

@@ -0,0 +1,116 @@
+from typing import List, Dict, Optional
+
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer
+from adventofcode.util.input_helpers import get_input_for_day
+
+mfcsam = {
+    'children': 3,
+    'cats': 7,
+    'samoyeds': 2,
+    'pomeranians': 3,
+    'akitas': 0,
+    'vizslas': 0,
+    'goldfish': 5,
+    'trees': 3,
+    'cars': 2,
+    'perfumes': 1,
+}
+
+
+class Aunt:
+    def __init__(self, name: str, **kwargs):
+        self.name = name
+        self.kwargs = kwargs
+
+    @property
+    def number(self):
+        return int(self.name.split('Sue ')[1])
+
+
+def parse_lines(input_data: List[str]) -> List[Aunt]:
+    aunts: List[Aunt] = []
+
+    for line in input_data:
+        name, property_content = line.split(': ', 1)
+        properties: Dict[str, int] = {}
+
+        for prop in property_content.split(', '):
+            key, value = prop.split(': ')
+            properties[key] = int(value)
+
+        aunts.append(Aunt(name, **properties))
+
+    return aunts
+
+
+def find_aunt_sue(aunts: List[Aunt]) -> Optional[Aunt]:
+    for aunt in aunts:
+        if all_properties_match(aunt):
+            return aunt
+
+    return None
+
+
+def find_aunt_sue_part_two(aunts: List[Aunt]) -> Aunt:
+    aunts = [aunt for aunt in aunts if matches_part_two(aunt)]
+
+    if len(aunts) != 1:
+        raise ValueError('could not locate Aunt Sue')
+
+    return aunts[0]
+
+
+def all_properties_match(aunt: Aunt) -> bool:
+    for key, value in aunt.kwargs.items():
+        if mfcsam[key] != value:
+            return False
+
+    return True
+
+
+def matches_part_two(aunt: Aunt) -> bool:
+    for key, value in aunt.kwargs.items():
+        if key in ['cats', 'trees']:
+            if mfcsam[key] >= value:
+                return False
+        elif key in ['pomeranians', 'goldfish']:
+            if mfcsam[key] <= value:
+                return False
+        else:
+            if mfcsam[key] != value:
+                return False
+    return True
+
+
+@solution_timer(2015, 16, 1)
+def part_one(input_data: List[str]):
+    aunts = parse_lines(input_data)
+    aunt = find_aunt_sue(aunts)
+
+    if not aunt:
+        raise SolutionNotFoundException(2015, 16, 1)
+
+    answer = aunt.number
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 16, 1)
+
+    return answer
+
+
+@solution_timer(2015, 16, 2)
+def part_two(input_data: List[str]):
+    aunts = parse_lines(input_data)
+    answer = find_aunt_sue_part_two(aunts).number
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 16, 2)
+
+    return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2015, 16)
+    part_one(data)
+    part_two(data)

src/adventofcode/year_2015/day_17_2015.py

@@ -0,0 +1,73 @@
+import itertools
+from typing import List
+
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer
+from adventofcode.util.input_helpers import get_input_for_day
+
+
+def get_containers(input_data: List[str]) -> List[int]:
+    return list(map(int, input_data))
+
+
+def find_combinations(input_data: List[str], liters: int = 150) -> int:
+    # Only have one container of each size, so we can get all combinations of all containers
+    # with varying lengths and calculate which combination equals 150 liters
+    total_combinations = 0
+    containers = get_containers(input_data)
+
+    for container in range(len(containers)):
+        container_total = 0
+        for combination in itertools.combinations(containers, container):
+            if sum(combination) == liters:
+                container_total += 1
+
+        total_combinations += container_total
+
+    return total_combinations
+
+
+def find_different_ways(input_data: List[str], liters: int = 150) -> int:
+    possible_combinations = []
+    minimum_containers = 0
+    containers = get_containers(input_data)
+
+    for container in range(len(containers)):
+        for combination in itertools.combinations(containers, container):
+            if len(combination) > minimum_containers != 0:
+                continue
+
+            if sum(combination) == liters:
+                minimum_containers = (
+                    len(combination) if minimum_containers == 0 or
+                    len(combination) < minimum_containers else minimum_containers
+                )
+                possible_combinations.append(combination)
+
+    return len([container for container in possible_combinations if len(container) == minimum_containers])
+
+
+@solution_timer(2015, 17, 1)
+def part_one(input_data: List[str]):
+    answer = find_combinations(input_data)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 17, 1)
+
+    return answer
+
+
+@solution_timer(2015, 17, 2)
+def part_two(input_data: List[str]):
+    answer = find_different_ways(input_data)
+
+    if not answer:
+        raise SolutionNotFoundException(2015, 17, 2)
+
+    return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2015, 17)
+    part_one(data)
+    part_two(data)