146 lines
4.7 KiB
Python
146 lines
4.7 KiB
Python
import os
|
|
from typing import List, Any, Type, Union
|
|
from .tools import get_script_dir
|
|
|
|
BASE_PATH = get_script_dir()
|
|
INPUTS_PATH = os.path.join(BASE_PATH, 'inputs')
|
|
|
|
|
|
class AOCDay:
|
|
day: int
|
|
input: List # our input is always a list of str/lines
|
|
test_solutions_p1: List
|
|
test_solutions_p2: List
|
|
|
|
def __init__(self, day: int):
|
|
self.day = day
|
|
with open(os.path.join(INPUTS_PATH, "input%02d" % day)) as f:
|
|
self.input = f.read().splitlines()
|
|
|
|
def part1(self) -> Any:
|
|
pass
|
|
|
|
def part2(self) -> Any:
|
|
pass
|
|
|
|
def test_part1(self, silent: bool = False) -> bool:
|
|
live_input = self.input.copy()
|
|
for case, solution in enumerate(self.test_solutions_p1):
|
|
with open(os.path.join(INPUTS_PATH, "test_input%02d_1_%d" % (self.day, case))) as f:
|
|
self.input = f.read().splitlines()
|
|
|
|
check = self.part1()
|
|
if not silent:
|
|
printSolution(self.day, 1, check, solution, case)
|
|
|
|
if check != solution:
|
|
if silent:
|
|
printSolution(self.day, 1, check, solution, case)
|
|
return False
|
|
|
|
self.input = live_input
|
|
return True
|
|
|
|
def test_part2(self, silent: bool = False) -> bool:
|
|
live_input = self.input.copy()
|
|
for case, solution in enumerate(self.test_solutions_p2):
|
|
with open(os.path.join(INPUTS_PATH, "test_input%02d_2_%d" % (self.day, case))) as f:
|
|
self.input = f.read().splitlines()
|
|
|
|
check = self.part2()
|
|
if not silent:
|
|
printSolution(self.day, 2, check, solution, case)
|
|
|
|
if check != solution:
|
|
if silent:
|
|
printSolution(self.day, 2, check, solution, case)
|
|
return False
|
|
|
|
self.input = live_input
|
|
return True
|
|
|
|
def getInput(self) -> Union[str, List]:
|
|
if len(self.input) == 1:
|
|
return self.input[0]
|
|
else:
|
|
return self.input.copy()
|
|
|
|
def getInputListAsType(self, return_type: Type) -> List:
|
|
"""
|
|
get input as list casted to return_type, each line representing one list entry
|
|
"""
|
|
return [return_type(i) for i in self.input]
|
|
|
|
def getMultiLineInputAsArray(self, return_type: Type = None, join_char: str = None) -> List:
|
|
"""
|
|
get input for day x as 2d array, split by empty lines
|
|
"""
|
|
lines = self.input.copy()
|
|
lines.append('')
|
|
|
|
return_array = []
|
|
line_array = []
|
|
for line in lines:
|
|
if not line:
|
|
if join_char:
|
|
return_array.append(join_char.join(line_array))
|
|
else:
|
|
return_array.append(line_array)
|
|
line_array = []
|
|
continue
|
|
|
|
if return_type:
|
|
line_array.append(return_type(line))
|
|
else:
|
|
line_array.append(line)
|
|
|
|
return return_array
|
|
|
|
def getInputAsArraySplit(self, split_char: str = ',', return_type: Union[Type, List[Type]] = None) -> List:
|
|
"""
|
|
get input for day x with the lines split by split_char
|
|
if input has only one line, returns a 1d array with the values
|
|
if input has multiple lines, returns a 2d array (a[line][values])
|
|
"""
|
|
if len(self.input) == 1:
|
|
return splitLine(line=self.input[0], split_char=split_char, return_type=return_type)
|
|
else:
|
|
return_array = []
|
|
for line in self.input:
|
|
return_array.append(splitLine(line=line, split_char=split_char, return_type=return_type))
|
|
|
|
return return_array
|
|
|
|
|
|
def printSolution(day: int, part: int, solution: Any, test: bool = None, test_case: int = 0, exec_time: float = None):
|
|
if exec_time is None:
|
|
time_output = ""
|
|
else:
|
|
units = ['s', 'ms', 'μs', 'ns']
|
|
unit = 0
|
|
while exec_time < 1:
|
|
exec_time *= 1000
|
|
unit += 1
|
|
|
|
time_output = " (Average run time: %1.2f%s)" % (exec_time, units[unit])
|
|
|
|
if test is not None:
|
|
print(
|
|
"%s (TEST day%d/part%d/case%d) -- got '%s' -- expected '%s'"
|
|
% ("OK" if test == solution else "FAIL", day, part, test_case, solution, test)
|
|
)
|
|
else:
|
|
print("Solution to day %s, part %s: %s%s" % (day, part, solution, time_output))
|
|
|
|
|
|
def splitLine(line, split_char: str = ',', return_type: Union[Type, List[Type]] = None):
|
|
if split_char:
|
|
line = line.split(split_char)
|
|
|
|
if return_type is None:
|
|
return line
|
|
elif isinstance(return_type, list):
|
|
return [return_type[x](i) if len(return_type) > x else i for x, i in enumerate(line)]
|
|
else:
|
|
return [return_type(i) for i in line]
|