# Day 1: Sonar Sweep

## Challenge

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?*

## 🔗 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?*## 🔗 Part A

This year I finally decided to make a
Utilities module, which contains a function to get all the

`numbers`

(one per line) from stdin.
To compute differences between lines, I used a for loop instead of being clever:

```
import { numbers } from "./util";
const depths = numbers();
let increases = 0;
for (let i = 1; i < depths.length; i++) {
if (depths[i] > depths[i - 1]) {
increases++;
}
}
console.log(increases);
```

## 🔗 Part B

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`

This is just a fancy way of saying that instead of comparing

`i-1`

to `i`

, we want to compare `[i-3..i-1]`

to `[i-2..i]`

. Yet again we'll use a for loop.
```
import { numbers } from "./util";
const depths = numbers();
let increases = 0;
for (let i = 3; i < depths.length; i++) {
const prev =
depths[i - 3] +
depths[i - 2] +
depths[i - 1];
const curr =
depths[i - 2] +
depths[i - 1] +
depths[i];
if (curr > prev) {
increases++;
}
}
console.log(increases);
```

You'll quickly notice, however, that

`prev`

and `curr`

share some items as we compare them. Our if-statement looks like the following after some careful rearranging:
```
depths[i-2] + depths[i-1] + depths[i]
>
depths[i-2] + depths[i-1] + depths[i-3]
```

And thanks to algebra, we can subtract

`depths[i-2]`

and `depths[i-1]`

from both sides, leaving us with:
`depths[i] > depths[i-3]`

Which simplifies our code quite a bit.

```
import { numbers } from "./util";
const depths = numbers();
let increases = 0;
for (let i = 3; i < depths.length; i++) {
if (depths[i] > depths[i - 3]) {
increases++;
}
}
console.log(increases);
```