day18 package

Subpackages

• day18.lib package
  • Submodules
  • day18.lib.tile module
    • EdgeTile
      • EdgeTile.TEXT_WHITE
      • EdgeTile.color
      • EdgeTile.contents
      • EdgeTile.text_color()
    • HoleTile
      • HoleTile.contents
    • Tile
      • Tile.contents
  • Module contents
• day18.tests package
  • Submodules
  • day18.tests.test_day18a module
    • test_day18a()
  • day18.tests.test_day18b module
    • test_command()
    • test_day18b()
  • Module contents

Submodules

day18.day18a module

day18 solution.

class day18.day18a.Command(direction: Direction, steps: int, color: str)

Bases: object

Well defined command dataclass.

color: str

direction: Direction

steps: int

class day18.day18a.Direction(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: StrEnum

Cardinal direction in UDLR.

Down = 'D'

Left = 'L'

Right = 'R'

Up = 'U'

class day18.day18a.Matrix(min_pos: Position, max_pos: Position)

Bases: object

2d array representing world.

contents: list[list[Tile]]

dig_out() → None

Dig out non-perimeter tiles using flood-fill.

dug_tiles = 0

is_oob(position: Position) → bool

Returns if a position is out of bounds.

Parameters:

position (Position) – position to check.

Returns:

True if out of bounds.

Return type:

bool

max_pos: Position

min_pos: Position

num_cols: int

num_rows: int

process_command(miner_pos: Position, command: Command) → Position

Process command.

This moves the miner around.

Parameters:

• miner_pos (Position) – miner’s current position

• command (Command) – command to process

Returns:

miner’s new position.

Return type:

Position

wall_tiles = 0

class day18.day18a.Position(row: int = 0, col: int = 0)

Bases: object

Simple 2d point.

col: int = 0

row: int = 0

day18.day18a.generate_offsets(position: Position, direction: Direction, steps: int) → list[Position]

Generate position offsets.

Parameters:

• position (Position) – base position

• direction (Direction) – direction of travel

• steps (int) – number of steps to generate

Raises:

AssertionError – If direciton is invalid.

Returns:

list of new positions.

Return type:

list[Position]

day18.day18a.get_input(path: str) → list[Command]

Reads input from file into well-formed list of commands.

day18.day18a.get_matrix_range(commands: list[Command]) → tuple[Position, Position]

Calculate minimum and maximum position in matrix.

Since we start in the middle somewhere, we get negative positions. This can be useds to offset the matrix when we construct it.

Parameters:

commands (list[Command]) – list of commands that will be run.

Returns:

[min,max] positions.

Return type:

tuple[Position, Position]

day18.day18a.get_solution(commands: list[Command]) → int

Calculates solution.

1. Pre-calculates the range

2. Creates edge tiles

3. Flood fill centre.

4. Count tiles.

day18.day18a.main() → None

Load data and then find solution to part1.

day18.day18b module

Day18b solution.

class day18.day18b.Command(hexcode: str)

Bases: object

Command from hexstring.

direction: Direction

steps: int

class day18.day18b.Direction(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: IntEnum

Direction as an integer enum.

Down = 1

Left = 2

Right = 0

Up = 3

class day18.day18b.Position(row: int = 0, col: int = 0)

Bases: object

Simple 2d vector.

col: int = 0

row: int = 0

day18.day18b.calculate_area(positions: list[Position], perimeter: int) → int

Calculate area using shoelace area.

day18.day18b.get_input(path: str) → list[Command]

Grabs input from file, parsing into well-formed commands.

day18.day18b.get_solution(commands: list[Command]) → int

Get solution via processing commands then running shoelace area.

day18.day18b.main() → None

Grab input and then pass it into solver.

day18.day18b.process_command(command: Command, position: Position) → Position

Process a command and return new position.

Module contents

Day18 solution.