Like every year, also this year the advent of code challenge will take place as usual. This time I decided to participate as well and not only by looking after twitch streamers but also doing the challenge myself. I'm not yet sure how far I will be able to go with this challenges but I want to try them out.

The rules are pretty simple: every day a new challenge will be made available and solving both part of the challenge itself will grant you 2 stars and to finish the advent of cord that you need to have 50 stars. During this period of course the challenges will become more and more difficult and solving them we require more complicated solutions and also time.

Let's start with the first challenge

Problem — Part 1

...as the submarine drops below the surface of the ocean, it automatically performs a sonar sweep of the nearby sea floor. On a small screen, the sonar sweep report (your puzzle input) appears: each line is a measurement of the sea floor depth as the sweep looks further and further away from the submarine.

For example, suppose you had the following report:

199
200
208
210
200
207
240
269
260
263

This report indicates that, scanning outward from the submarine, the sonar sweep found depths of 199, 200, 208, 210, and so on.

The first order of business is to figure out how quickly the depth increases, just so you know what you're dealing with - you never know if the keys will get carried into deeper water by an ocean current or a fish or something.

To do this, count the number of times a depth measurement increases from the previous measurement. (There is no measurement before the first measurement.) In the example above, the changes are as follows:

199 (N/A - no previous measurement)
200 (increased)
208 (increased)
210 (increased)
200 (decreased)
207 (increased)
240 (increased)
269 (increased)
260 (decreased)
263 (increased)

In this example, there are 7 measurements that are larger than the previous measurement.

How many measurements are larger than the previous measurement?

Your puzzle answer was 1228.

Solution — Part 1

In order to solve this problem it is actually required to read a file with the given input, so logically the first thing will be coding the part that will perform such operation.

const fs = require("fs");

// Read the file
const fileContent = fs.readFileSync("./input.txt", "utf8");
const lines = fileContent.split("\n");

Now we need to read every line and check if the current line's value is progressively increasing and how many times it happens:

let maxIncrease = 0;
let currentIncrease = 0;
// Looping through each line, starting from the second
for (let i = 1; i < lines.length; i++) {
  const currentLine = lines[i];
  const previousLine = lines[i - 1];
  // Check if there is an incrase w.r.t. the line before
  if (parseInt(currentLine) > parseInt(previousLine)) {
    currentIncrease++;
    if (currentIncrease > maxIncrease) {
      maxIncrease = currentIncrease;
    }
  }
}
console.log(maxIncrease)
// 1228

In this case is it I prefer looping through every line of the document starting from the counter set at 1. I am also aware of the fact that probably there is someone out there who solved to the same problem we have a single line of code, but actually I prefer readability over one-liners solution. 😉

Problem — Part Two

Considering every single measurement isn't as useful as you expected: there's just too much noise in the data.

Instead, consider sums of a three-measurement sliding window. Again considering the above example:

199  A
200  A B
208  A B C
210    B C D
200  E   C D
207  E F   D
240  E F G
269    F G H
260      G H
263        H

Start by comparing the first and second three-measurement windows. The measurements in the first window are marked A (199, 200, 208); their sum is 199 + 200 + 208 = 607. The second window is marked B (200, 208, 210); its sum is 618. The sum of measurements in the second window is larger than the sum of the first, so this first comparison increased.

Your goal now is to count the number of times the sum of measurements in this sliding window increases from the previous sum. So, compare A with B, then compare B with C, then C with D, and so on. Stop when there aren't enough measurements left to create a new three-measurement sum.

In the above example, the sum of each three-measurement window is as follows:

A: 607 (N/A - no previous sum)
B: 618 (increased)
C: 618 (no change)
D: 617 (decreased)
E: 647 (increased)
F: 716 (increased)
G: 769 (increased)
H: 792 (increased)

In this example, there are 5 sums that are larger than the previous sum.

Consider sums of a three-measurement sliding window. How many sums are larger than the previous sum?

Solution — Part 2

The second part of the problem adds a little difficulty to it with the concept of sliding windows: now, instead of checking every single difference in lines, we need to check are triplets of them added together.

The code is almost identical, it's changes just in the part of the valuation of the increase is between the sliding windows.

const fs = require("fs");

const fileContent = fs.readFileSync("./input2.txt", "utf8");
const lines = fileContent.split("\n");
let maxIncrease = 0;
let currentIncrease = 0;
for (let i = 1; i < lines.length - 2; i++) {
  const currentSW = +lines[i] + +lines[i + 1] + +lines[i + 2];
  const previousSW = +lines[i - 1] + +lines[i] + +lines[i + 1];
  if (currentSW > previousSW) {
    currentIncrease++;
    if (currentIncrease > maxIncrease) {
      maxIncrease = currentIncrease;
    }
  }
}
console.log(maxIncrease);

As you can see in the code instead of having the current line value we have the current Sliding Window value.