Advent Of Code 2021 Using C#: Day 02 - Dive!
Tags: adventofcode, csharp
Published: 2021-12-17 14:16:44

A new day dawns, a new challenger approaches. It is time for [Advent of Code](https://adventofcode.com/) Day 2!

Today's problem is pretty straightforward. The puzzle comes with a set of instructions, and we need to calculate the position of our submarine after we follow these instructions.

The input, as always, is provided in a string file, where each line is formatted as: `command units`.

The interpretation of input differs between parts one and two.

## Part 1

In Part 1 we are given a set of instructions, and we need to calculate the final position of our submarine if we follow these instructions. There are three instruction "tokens", `forward`, `up`, `down`.

- forward: Increases the horizontal position
- up: Decreases the vertical position
- down: Increases the vertical position

Each token is followed by a number, the units of movement to a given direction.

Let's start building our solution. First, we are going to design an algorithm to solve the puzzle, and then convert it to C# code.

We have a string array **Instructions** containing all movement instructions. Our goal is to calculate the product of the final X position times the final Y position.

We will iterate through the Instructions sequence and retrieve each instruction. Since the instruction format is `command units`, we need to tokenize it to `command` and `units`.

If the command token is `forward`, we will increase the XPosition by `units`. If the command token is `up`, we will decrease the YPosition by `units`. Finally, if the command token is `down`, we will increase the YPosition by `units`.

The last step is to calculate the product of XPosition times YPosition.

```
SUBMARINE_MOVEMENT(Instructions)
INPUT: A list of string instructions
OUTPUT: The product of the final horizontal position times the final vertical position

XPosition = 0
YPosition = 0

FOREACH(Instruction in Instructions)
    (instruction, units) = TOKENIZE(instruction)
    
    SWITCH instruction
        CASE "forward"
            XPosition = XPosition + units
        CASE "up"
            YPosition = YPosition - units
        CASE "down"
            YPosition = YPosition + units
    END SWITCH
END FOREACH

RETURN XPosition * YPosition
```

With the algorithm figured out, let's begin the C# implementation.

```csharp
int xPosition = 0;
int yPosition = 0;
foreach(string instruction in data)
{
    string[] commands = instruction.Split(" ");
    switch(commands[0])
    {
        case "forward":
	    xPosition += int.Parse(commands[1]);
	    break;
	case "up":
	    yPosition -= int.Parse(commands[1]);
	    break;
	case "down":
	    yPosition += int.Parse(commands[1]);
	    break;
	}
}

return xPosition * yPosition;
```

### How it Works

The solution is pretty clear-cut. First, the instruction is split on whitespace, creating a `[command, unit]` array. Then, a switch statement parses the `command` argument and performs the appropriate position calculations. 

## Part 2

Part 2 introduces a twist in the calculations. Instead of changing the vertical position, `up` and `down` commands change the [pitch angle](https://en.wikipedia.org/wiki/Ship_motions) of the submarine. Since only the pitch angle is affected, the `forward` command changes the vertical and horizontal positioning. Now `forward` adds X units on the horizontal position and `pitch_angle` * X units on the vertical.

To address that, we need to perform some minor adjustments to our calculating function:

```csharp
int xPosition = 0;
int yPosition = 0;

int aim = 0;

foreach (string instruction in data)
{
    string[] commands = instruction.Split(" ");
    switch (commands[0])
    {
        case "forward":
	    xPosition += int.Parse(commands[1]);
	    yPosition += int.Parse(commands[1]) * aim;
	    break;
	case "up":
	    aim -= int.Parse(commands[1]);
	    break;
	case "down":
	    aim += int.Parse(commands[1]);
	    break;
    }
}

return xPosition * yPosition
```

### How it works

Only some minor adjustments are needed to calculate the answer to Part2. 

First, I've introduced a new integer variable `aim` to store the pitch angle of the submarine.

The `up` and `down` commands, no longer affect the ship's vertical position,  adjusting the pitch angle instead.

Finally, the `forward` command, calculates the horizontal movement of the ship by adding X units to the horizontal position, as well as calculating the vertical position. The vertical position is the product of the traversal angle times X units of movement.

## That's all folks!

Day02 puzzle, is a nice and clear cut introductory puzzle for AoC, without any difficult part requiring attention to details.

I hope I could provide y'all with a more in-depth explanation of how my solutions work.

You can find this solution and others in my [Github Repo](https://github.com/Kalkwst/Advent-Of-Code-2021).

Hope you had fun and see you around for the next episode of Advent of Code 2021!