Now, you need to figure out how to pilot this thing.
It seems like the submarine can take a series of commands like forward 1, down 2, or up 3:
forward X increases the horizontal position by X units.
down X increases the depth by X units.
up X decreases the depth by X units.
Note that since you're on a submarine, down and up affect your depth, and so they have the opposite result of what you might expect.
The submarine seems to already have a planned course (your puzzle input). You should probably figure out where it's going. For example:
forward 5
down 5
forward 8
up 3
down 8
forward 2
Your horizontal position and depth both start at 0. The steps above would then modify them as follows:
forward 5 adds 5 to your horizontal position, a total of 5.
down 5 adds 5 to your depth, resulting in a value of 5.
forward 8 adds 8 to your horizontal position, a total of 13.
up 3 decreases your depth by 3, resulting in a value of 2.
down 8 adds 8 to your depth, resulting in a value of 10.
forward 2 adds 2 to your horizontal position, a total of 15.
After following these instructions, you would have a horizontal position of 15 and a depth of 10. (Multiplying these together produces 150.)
Calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
# Python imports
from pathlib import Path
from typing import Iterable, List
# Paths to data
testpath = Path("day02_test.txt")
datapath = Path("day02_data.txt")
def load_input(fpath: Path) -> List[str]:
"""Return puzzle data as list of strings
:param fpath: Path to data file
"""
with fpath.open("r") as ifh:
return ifh.readlines()
As in previous years, we take an object-oriented approach to the puzzle, creating a class that represents the submarine, having depth and position attributes, and being able to move when instructed.
class Submarine1:
"""Represents a submarine for AOC2021 day 2, puzzle 1"""
depth:int = 0
pos:int = 0
def __init__(self, depth:int=0, pos:int=0) -> None:
"""Instantiate submarine with initial depth and position
:param depth: submarine depth
:param pos: submarine position
"""
self.depth = depth
self.pos = pos
def move(self, instr:str) -> None:
"""Given an instruction string, move the submarine
:param instr: movement instruction
"""
drn, val = instr.strip().split()
if drn == "forward":
self.pos += int(val)
elif drn == "up":
self.depth -= int(val)
elif drn == "down":
self.depth += int(val)
def parse(self, instrs: Iterable[str]) -> None:
"""Given a list of instruction strings, move the submarine
:param instrs: iterable of instruction strings
"""
for line in (_ for _ in instrs if len(_)):
self.move(line)
@property
def location(self) -> int:
"""Return location of submarine for puzzle solution"""
return sub.pos * sub.depth
Solving the test puzzle.
# load data
data = load_input(Path("day02_test.txt"))
# move submarine
sub = Submarine1()
sub.parse(data)
# report location
print(sub.location)
150
And the full puzzle.
# load data
data = load_input(Path("day02_data.txt"))
# move submarine
sub = Submarine1()
sub.parse(data)
# report location
print(sub.location)
1670340
Based on your calculations, the planned course doesn't seem to make any sense. You find the submarine manual and discover that the process is actually slightly more complicated.
In addition to horizontal position and depth, you'll also need to track a third value, aim, which also starts at 0. The commands also mean something entirely different than you first thought:
down X increases your aim by X units.
up X decreases your aim by X units.
forward X does two things:
It increases your horizontal position by X units.
It increases your depth by your aim multiplied by X.
Again note that since you're on a submarine, down and up do the opposite of what you might expect: "down" means aiming in the positive direction.
Now, the above example does something different:
forward 5 adds 5 to your horizontal position, a total of 5. Because your aim is 0, your depth does not change.
down 5 adds 5 to your aim, resulting in a value of 5.
forward 8 adds 8 to your horizontal position, a total of 13. Because your aim is 5, your depth increases by 8*5=40.
up 3 decreases your aim by 3, resulting in a value of 2.
down 8 adds 8 to your aim, resulting in a value of 10.
forward 2 adds 2 to your horizontal position, a total of 15. Because your aim is 10, your depth increases by 2*10=20 to a total of 60.
After following these new instructions, you would have a horizontal position of 15 and a depth of 60. (Multiplying these produces 900.)
Using this new interpretation of the commands, calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
As is often the case, we need to make a critical change to our solution class - for convenience we create a new class.
class Submarine2:
"""Represents a submarine for AOC2021 day 2, puzzle 2"""
depth:int = 0
pos:int = 0
aim:int = 0
def __init__(self, depth:int=0, pos:int=0, aim:int=0) -> None:
"""Instantiate submarine with initial depth and position
:param depth: submarine depth
:param pos: submarine position
:param aim: submarine aim
"""
self.depth = depth
self.pos = pos
self.aim = aim
def move(self, instr:str) -> None:
"""Given an instruction string, move the submarine
:param instr: movement instruction
"""
drn, val = instr.strip().split()
if drn == "forward":
self.pos += int(val)
self.depth += self.aim * int(val)
elif drn == "up":
self.aim -= int(val)
elif drn == "down":
self.aim += int(val)
def parse(self, instrs: Iterable[str]) -> None:
"""Given a list of instruction strings, move the submarine
:param instrs: iterable of instruction strings
"""
for line in (_ for _ in instrs if len(_)):
self.move(line)
@property
def location(self) -> int:
"""Return location of submarine for puzzle solution"""
return sub.pos * sub.depth
With the test data.
# load data
data = load_input(Path("day02_test.txt"))
# move submarine
sub = Submarine2()
sub.parse(data)
# report location
print(sub.location)
900
And with the full data.
# load data
data = load_input(Path("day02_data.txt"))
# move submarine
sub = Submarine2()
sub.parse(data)
# report location
print(sub.location)
1954293920