Add day 1

This commit is contained in:
Tristan 2021-12-01 22:46:34 +01:00
parent 17e575d38b
commit 3a8db5f0c6
Signed by: trizz
GPG Key ID: 0A93DEC67165EB47
6 changed files with 2190 additions and 0 deletions

1
aoc21
View File

@ -9,5 +9,6 @@ use Symfony\Component\Console\Application;
$application = new Application();
$application->add(new Puzzle());
$application->add(new Day1());
$application->run();

2000
data/day1/data.txt Normal file

File diff suppressed because it is too large Load Diff

10
data/day1/example.txt Normal file
View File

@ -0,0 +1,10 @@
199
200
208
210
200
207
240
269
260
263

91
data/day1/puzzle.md Normal file
View File

@ -0,0 +1,91 @@
# Day 1: Sonar Sweep
[https://adventofcode.com/2021/day/1](https://adventofcode.com/2021/day/1)
## Description
### Part One
You're minding your own business on a ship at sea when the overboard alarm goes off! You rush to see if you can help. Apparently, one of the Elves tripped and accidentally sent the sleigh keys flying into the ocean!
Before you know it, you're inside a submarine the Elves keep ready for situations like this. It's covered in Christmas lights (because of course it is), and it even has an experimental antenna that should be able to track the keys if you can boost its signal strength high enough; there's a little meter that indicates the antenna's signal strength by displaying 0-50 _stars_.
Your instincts tell you that in order to save Christmas, you'll need to get all _fifty stars_ by December 25th.
Collect stars by solving puzzles. Two puzzles will be made available on each day in the Advent calendar; the second puzzle is unlocked when you complete the first. Each puzzle grants _one star_. Good luck!
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 <span title="Does this premise seem fishy to you?">carried into deeper water</span> 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?_

64
src/Day1.php Normal file
View File

@ -0,0 +1,64 @@
<?php
namespace AdventOfCode21;
use JetBrains\PhpStorm\ArrayShape;
class Day1 extends AbstractCommand
{
/**
* {@inheritdoc}
*/
protected static int $day = 1;
/**
* {@inheritdoc}
*/
protected function part1(array $data): int
{
$previous = null;
$increases = 0;
/** @var int $current */
foreach ($data as $current) {
if ($previous !== null && $previous < $current) {
++$increases;
}
$previous = $current;
}
return $increases;
}
/**
* {@inheritdoc}
*/
protected function part2(array $data): int
{
$previousSum = null;
$increases = 0;
/**
* @var int $index
* @var int $indexValue
*/
foreach ($data as $index => $indexValue) {
// If no 'next' indexes are available, skip.
if (!isset($data[$index + 1], $data[$index + 2])) {
continue;
}
// Calculate the sum of the current value and the next two.
$newSum = $indexValue + (int) $data[$index + 1] + (int) $data[$index + 2];
if ($previousSum !== null && $previousSum < $newSum) {
++$increases;
}
$previousSum = $newSum;
}
return $increases;
}
}

24
tests/Day1Test.php Normal file
View File

@ -0,0 +1,24 @@
<?php
namespace Tests;
use AdventOfCode21\Day1;
/**
* @internal
*/
class Day1Test extends AbstractTestCase
{
public static int $part1ExampleResult = 7;
public static int $part1Result = 1688;
public static int $part2ExampleResult = 5;
public static int $part2Result = 1728;
public function setupDay(): Day1
{
return new class() extends Day1 {
use ReturnTestableResults;
};
}
}