Restructure: split rust projects

Seperates each days into a seperate crate again.

2021/Cargo.toml

@@ -1,19 +0,0 @@
-[package]
-name = "aoc-2021"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-itertools = "0.10.1"
-
-[lib]
-name = "util"
-path = "util/main.rs"
-
-[[bin]]
-name = "day-01-part-1"
-path = "01/part1.rs"
-
-[[bin]]
-name = "day-01-part-2"
-path = "01/part2.rs"

2021/day01/Cargo.lock

@@ -3,7 +3,7 @@
 version = 3
 
 [[package]]
-name = "aoc-2021"
+name = "day01"
 version = "0.1.0"
 dependencies = [
  "itertools",

2021/day01/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "day01"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+itertools = "0.10.1"
+
+[[bin]]
+name = "part1"
+path = "src/part1.rs"
+
+[[bin]]
+name = "part2"
+path = "src/part2.rs"

2021/day01/README.md

@@ -0,0 +1,131 @@
+https://adventofcode.com/2021/day/1
+
+## \--- Day 1: Sonar Sweep ---
+
+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:
+
+[code]
+
+    199
+    200
+    208
+    210
+    200
+    207
+    240
+    269
+    260
+    263
+    
+[/code]
+
+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:
+
+[code]
+
+    199 (N/A - no previous measurement)
+    200 ( _increased_ )
+    208 ( _increased_ )
+    210 ( _increased_ )
+    200 (decreased)
+    207 ( _increased_ )
+    240 ( _increased_ )
+    269 ( _increased_ )
+    260 (decreased)
+    263 ( _increased_ )
+    
+[/code]
+
+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 `1754`.
+
+## \--- 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:
+
+[code]
+
+    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
+    
+[/code]
+
+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:
+
+[code]
+
+    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_ )
+    
+[/code]
+
+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?_
+

2021/day01/input/example1

@@ -0,0 +1,10 @@
+199 (N/A - no previous measurement)
+200 ( _increased_ )
+208 ( _increased_ )
+210 ( _increased_ )
+200 (decreased)
+207 ( _increased_ )
+240 ( _increased_ )
+269 ( _increased_ )
+260 (decreased)
+263 ( _increased_ )

2021/day01/input/example2

@@ -0,0 +1,10 @@
+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

2021/day01/input/example3

@@ -0,0 +1,8 @@
+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_ )

2021/day01/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}

2021/util/main.rs

@@ -1,11 +0,0 @@
-use std::fs::File;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Lines;
-
-pub mod math;
-
-pub fn file_lines(path: String) -> Lines<BufReader<File>> {
-    let input = File::open(path).unwrap();
-    return BufReader::new(input).lines();
-}

2021/util/math.rs

@@ -1,7 +0,0 @@
-pub fn sum(x: i32, y: i32) -> i32 {
-    x + y
-}
-
-pub fn sub(x: i32, y: i32) -> i32 {
-    x - y
-}