Skip to content

Solutions

Result

Bases: Generic[T, U]

Represents the result of the problem solution.

Source code in aoc/solutions.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
@final
@frozen()
class Result(Generic[T, U]):
    """Represents the result of the problem solution."""

    answer_one: T
    """The answer to the part one of the problem."""

    answer_two: U
    """The answer to the part two of the problem."""

    parse_time: Elapsed
    """The time it took to parse the data."""

    solve_one_time: Elapsed
    """The time it took to solve part one."""

    solve_two_time: Elapsed
    """The time it took to solve part two."""

answer_one: T instance-attribute

The answer to the part one of the problem.

answer_two: U instance-attribute

The answer to the part two of the problem.

parse_time: Elapsed instance-attribute

The time it took to parse the data.

solve_one_time: Elapsed instance-attribute

The time it took to solve part one.

solve_two_time: Elapsed instance-attribute

The time it took to solve part two.

Solution

Bases: Protocol[I, T, U]

Represents problem solutions.

Source code in aoc/solutions.py 
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
class Solution(Protocol[I, T, U]):
    """Represents problem solutions."""

    def __init_subclass__(cls, **keywords: Any) -> None:
        super().__init_subclass__(**keywords)

        SOLUTIONS[get_key_by_name(get_name(cls))] = cls

    @required
    def parse(self, data: str) -> I:
        """Parses the data into the input type.

        Arguments:
            data: The data to parse.

        Returns:
            The input of the problem.
        """
        raise NotImplementedError(MUST_IMPLEMENT_PARSE)

    @required
    def solve_one(self, input: I) -> T:
        """Solves part one of the problem.

        Arguments:
            input: The input of the problem, as returned by [`parse`][aoc.solutions.Solution.parse].

        Returns:
            The answer to part one of the problem.
        """
        raise NotImplementedError(MUST_IMPLEMENT_SOLVE_ONE)

    @required
    def solve_two(self, input: I) -> U:
        """Solves part two of the problem.

        Arguments:
            input: The input of the problem, as returned by [`parse`][aoc.solutions.Solution.parse].

        Returns:
            The answer to part two of the problem.
        """
        raise NotImplementedError(MUST_IMPLEMENT_SOLVE_TWO)

    def execute(self, data: str) -> Result[T, U]:
        """Executes the problem solution on the given data.

        Arguments:
            data: The data to parse and solve the problem for.

        Returns:
            The result of the solution.
        """
        parse = self.parse
        solve_one = self.solve_one
        solve_two = self.solve_two

        timer = now()

        input = parse(data)

        parse_time = timer.elapsed()

        timer = timer.reset()

        answer_one = solve_one(input)

        solve_one_time = timer.elapsed()

        timer = timer.reset()

        answer_two = solve_two(input)

        solve_two_time = timer.elapsed()

        return Result(answer_one, answer_two, parse_time, solve_one_time, solve_two_time)

parse(data: str) -> I abstractmethod

Parses the data into the input type.

Parameters:

Name Type Description Default
data str

The data to parse.

 required

Returns:

Type Description
I

The input of the problem.
Source code in aoc/solutions.py 
68
69
70
71
72
73
74
75
76
77
78
@required
def parse(self, data: str) -> I:
    """Parses the data into the input type.

    Arguments:
        data: The data to parse.

    Returns:
        The input of the problem.
    """
    raise NotImplementedError(MUST_IMPLEMENT_PARSE)

solve_one(input: I) -> T abstractmethod

Solves part one of the problem.

Parameters:

Name Type Description Default
input I

The input of the problem, as returned by parse.

 required

Returns:

Type Description
T

The answer to part one of the problem.
Source code in aoc/solutions.py 
80
81
82
83
84
85
86
87
88
89
90
@required
def solve_one(self, input: I) -> T:
    """Solves part one of the problem.

    Arguments:
        input: The input of the problem, as returned by [`parse`][aoc.solutions.Solution.parse].

    Returns:
        The answer to part one of the problem.
    """
    raise NotImplementedError(MUST_IMPLEMENT_SOLVE_ONE)

solve_two(input: I) -> U abstractmethod

Solves part two of the problem.

Parameters:

Name Type Description Default
input I

The input of the problem, as returned by parse.

 required

Returns:

Type Description
U

The answer to part two of the problem.
Source code in aoc/solutions.py 
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
@required
def solve_two(self, input: I) -> U:
    """Solves part two of the problem.

    Arguments:
        input: The input of the problem, as returned by [`parse`][aoc.solutions.Solution.parse].

    Returns:
        The answer to part two of the problem.
    """
    raise NotImplementedError(MUST_IMPLEMENT_SOLVE_TWO)

execute(data: str) -> Result[T, U]

Executes the problem solution on the given data.

Parameters:

Name Type Description Default
data str

The data to parse and solve the problem for.

 required

Returns:

Type Description
Result[T, U]

The result of the solution.
Source code in aoc/solutions.py 
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def execute(self, data: str) -> Result[T, U]:
    """Executes the problem solution on the given data.

    Arguments:
        data: The data to parse and solve the problem for.

    Returns:
        The result of the solution.
    """
    parse = self.parse
    solve_one = self.solve_one
    solve_two = self.solve_two

    timer = now()

    input = parse(data)

    parse_time = timer.elapsed()

    timer = timer.reset()

    answer_one = solve_one(input)

    solve_one_time = timer.elapsed()

    timer = timer.reset()

    answer_two = solve_two(input)

    solve_two_time = timer.elapsed()

    return Result(answer_one, answer_two, parse_time, solve_one_time, solve_two_time)

FinalResult

Bases: Generic[T]

Represents the result of the final problem solution.

Source code in aoc/solutions.py 
142
143
144
145
146
147
148
149
150
151
152
153
154
@final
@frozen()
class FinalResult(Generic[T]):
    """Represents the result of the final problem solution."""

    answer: T
    """The answer to the problem."""

    parse_time: Elapsed
    """The time it took to parse the data."""

    solve_time: Elapsed
    """The time it took to solve the problem."""

answer: T instance-attribute

The answer to the problem.

parse_time: Elapsed instance-attribute

The time it took to parse the data.

solve_time: Elapsed instance-attribute

The time it took to solve the problem.

FinalSolution

Bases: Protocol[I, T]

Represents final problem solutions.

Source code in aoc/solutions.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
class FinalSolution(Protocol[I, T]):
    """Represents final problem solutions."""

    def __init_subclass__(cls, **keywords: Any) -> None:
        super().__init_subclass__(**keywords)

        FINAL_SOLUTIONS[get_key_by_name(get_name(cls))] = cls

    @required
    def parse(self, data: str) -> I:
        """Parses the data into the input type.

        Arguments:
            data: The data to parse.

        Returns:
            The input of the problem.
        """
        raise NotImplementedError(MUST_IMPLEMENT_PARSE)

    @required
    def solve(self, input: I) -> T:
        """Solves the problem.

        Arguments:
            input: The input of the problem, as returned by
                [`parse`][aoc.solutions.FinalSolution.parse].

        Returns:
            The answer to the problem.
        """
        raise NotImplementedError(MUST_IMPLEMENT_SOLVE)

    def execute(self, data: str) -> FinalResult[T]:
        """Executes the problem solution on the given data.

        Arguments:
            data: The data to parse and solve the problem for.

        Returns:
            The result of the solution.
        """
        parse = self.parse
        solve = self.solve

        timer = now()

        input = parse(data)

        parse_time = timer.elapsed()

        timer = timer.reset()

        answer = solve(input)

        solve_time = timer.elapsed()

        return FinalResult(answer, parse_time, solve_time)

parse(data: str) -> I abstractmethod

Parses the data into the input type.

Parameters:

Name Type Description Default
data str

The data to parse.

 required

Returns:

Type Description
I

The input of the problem.
Source code in aoc/solutions.py 
170
171
172
173
174
175
176
177
178
179
180
@required
def parse(self, data: str) -> I:
    """Parses the data into the input type.

    Arguments:
        data: The data to parse.

    Returns:
        The input of the problem.
    """
    raise NotImplementedError(MUST_IMPLEMENT_PARSE)

solve(input: I) -> T abstractmethod

Solves the problem.

Parameters:

Name Type Description Default
input I

The input of the problem, as returned by parse.

 required

Returns:

Type Description
T

The answer to the problem.
Source code in aoc/solutions.py 
182
183
184
185
186
187
188
189
190
191
192
193
@required
def solve(self, input: I) -> T:
    """Solves the problem.

    Arguments:
        input: The input of the problem, as returned by
            [`parse`][aoc.solutions.FinalSolution.parse].

    Returns:
        The answer to the problem.
    """
    raise NotImplementedError(MUST_IMPLEMENT_SOLVE)

execute(data: str) -> FinalResult[T]

Executes the problem solution on the given data.

Parameters:

Name Type Description Default
data str

The data to parse and solve the problem for.

 required

Returns:

Type Description
FinalResult[T]

The result of the solution.
Source code in aoc/solutions.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
def execute(self, data: str) -> FinalResult[T]:
    """Executes the problem solution on the given data.

    Arguments:
        data: The data to parse and solve the problem for.

    Returns:
        The result of the solution.
    """
    parse = self.parse
    solve = self.solve

    timer = now()

    input = parse(data)

    parse_time = timer.elapsed()

    timer = timer.reset()

    answer = solve(input)

    solve_time = timer.elapsed()

    return FinalResult(answer, parse_time, solve_time)