1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
#+title: Day 01 - Sonar Sweep
#+setupfile: ~/.emacs.d/org-templates/level-3.org
#+html_link_up: ../../index.html#2021
#+options: toc:1
#+export_file_name: index
* Puzzle
- This puzzle is taken from: https://adventofcode.com/2021/day/1
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:
#+begin_src
199
200
208
210
200
207
240
269
260
263
#+end_src
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:
#+begin_src
199 (N/A - no previous measurement)
200 (increased)
208 (increased)
210 (increased)
200 (decreased)
207 (increased)
240 (increased)
269 (increased)
260 (decreased)
263 (increased)
#+end_src
In this example, there are 7 measurements that are larger than the
previous measurement.
How many measurements are larger than the previous measurement?
** Part 2
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:
#+begin_src
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
#+end_src
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:
#+begin_src
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)
#+end_src
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
Slurp all the input values by line and store them as integer:
#+begin_src raku
my Int @inputs = "input".IO.lines>>.Int;
#+end_src
Loop over the input elements and compare with previous value,
~$larger-than-previous~ stores the counter. It's pretty straightforward.
#+begin_src raku
my Int $larger-than-previous = 0;
for (^@inputs.elems).skip -> $idx {
$larger-than-previous++ if @inputs[$idx] > @inputs[$idx - 1];
}
put "Part 1: ", $larger-than-previous;
#+end_src
** Part 2
Here, we compare the sum of current set (previous 3 inputs) to the
previous set.
#+begin_src raku
my Int $larger-than-previous = 0;
for (^@inputs.elems).skip(3) -> $idx {
$larger-than-previous++ if @inputs[$idx - 2 .. $idx].sum > @inputs[$idx - 3 .. $idx - 1].sum;
}
put "Part 2: ", $larger-than-previous;
#+end_src
|