# Advent of Code 2021, Day 2

Andrew Fontaine <andrew@afontaine.ca>

Now that I know where I am going, I get to figure out how to pilot the submarine! The first puzzle is perfect for `List.fold_left`:

``````let follow_instruction (x, y) (dir, num)   match dir with
| "up" -> (x, y - num)
| "down" -> (x, y + num)
| "forward" -> (x + num, y)
| direction -> raise (Direction direction)

let p1_sol input   let x, y = List.fold_left follow_instruction (0, 0) input in
x * y``````

I just match on the direction I am going and increment the correct direction. All that’s left is to compute the answer (multiply the coordinates together).

If I just match on the four directions, `up`, `down`, `forward`, then ocaml complains that the match is not fully matched. Its type system does not allow for uncaught matches, which are dependent on the type of the variable. Here, the uncaught matches are literally every string of characters that isn’t one of the directions. The correct answer is to parse these directions into a variant, a plain symbol-thing that is a specific set of options: `Up | Down | Forward`, and lift this error up to where I parse the line. I didn’t do that though, so I have to check it here and throw if it is incorrect. As I feel very confident here that it would not be, I think I am pretty safe.

☆ one done!

## Part 2

Ah! Turns out I was interpreting the instructions wrong. It isn’t exactly up or down, but changing the aim of the submarine up or down. This is a pretty simple adjustment, all I have to do is add the aim to the result tuple to keep track of it:

``````let follow_instruction_2 (x, y, a) (dir, num)   match dir with
| "up" -> (x, y, a - num)
| "down" -> (x, y, a + num)
| "forward" -> (x + num, y + (a * num), a)
| direction -> raise (Direction direction)

let p2_sol input   let x, y, _ = List.fold_left follow_instruction_2 (0, 0, 0) input in
x * y``````

The same problem as above, I should be using variants. We can see though that just adjusting the aim to handle the new up and down (adjust the nose by the number) and forward (now including the submarine’s current aim multiplied by how far forward). When I compute the value, because I don’t use the aim, I use the `_` variable to note that the variable is not used.

Hopefully now the submarine is on the way to find those keys!

#### Want to discuss this post?

Reach out via email to ~afontaine/blog-discuss@lists.sr.ht, and be sure to follow the mailing list etiquette.

Other posts