DEV Community

Cover image for Advent Of Code 2021 Using C#: Day 02 - Dive!
Kostas Kalafatis
Kostas Kalafatis

Posted on

Advent Of Code 2021 Using C#: Day 02 - Dive!

A new day dawns, a new challenger approaches. It is time for Advent of Code 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
Enter fullscreen mode Exit fullscreen mode

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

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;
Enter fullscreen mode Exit fullscreen mode

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 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:

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
Enter fullscreen mode Exit fullscreen mode

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.

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

Discussion (0)