Solutions for 2022, as well as 2015-2018 and 2019 up to day 11

2017/day03-spiral_memory/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "day03-spiral_memory"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

2017/day03-spiral_memory/challenge.txt

@@ -0,0 +1,62 @@
+\--- Day 3: Spiral Memory ---
+----------
+
+You come across an experimental new kind of memory stored on an infinite two-dimensional grid.
+
+Each square on the grid is allocated in a spiral pattern starting at a location marked `1` and then counting up while spiraling outward. For example, the first few squares are allocated like this:
+
+```
+17  16  15  14  13
+18   5   4   3  12
+19   6   1   2  11
+20   7   8   9  10
+21  22  23---> ...
+
+```
+
+While this is very space-efficient (no squares are skipped), requested data must be carried back to square `1` (the location of the only access port for this memory system) by programs that can only move up, down, left, or right. They always take the shortest path: the [Manhattan Distance](https://en.wikipedia.org/wiki/Taxicab_geometry) between the location of the data and square `1`.
+
+For example:
+
+* Data from square `1` is carried `0` steps, since it's at the access port.
+* Data from square `12` is carried `3` steps, such as: down, left, left.
+* Data from square `23` is carried only `2` steps: up twice.
+* Data from square `1024` must be carried `31` steps.
+
+*How many steps* are required to carry the data from the square identified in your puzzle input all the way to the access port?
+
+Your puzzle answer was `552`.
+
+\--- Part Two ---
+----------
+
+As a stress test on the system, the programs here clear the grid and then store the value `1` in square `1`. Then, in the same allocation order as shown above, they store the sum of the values in all adjacent squares, including diagonals.
+
+So, the first few squares' values are chosen as follows:
+
+* Square `1` starts with the value `1`.
+* Square `2` has only one adjacent filled square (with value `1`), so it also stores `1`.
+* Square `3` has both of the above squares as neighbors and stores the sum of their values, `2`.
+* Square `4` has all three of the aforementioned squares as neighbors and stores the sum of their values, `4`.
+* Square `5` only has the first and fourth squares as neighbors, so it gets the value `5`.
+
+Once a square is written, its value does not change. Therefore, the first few squares would receive the following values:
+
+```
+147  142  133  122   59
+304    5    4    2   57
+330   10    1    1   54
+351   11   23   25   26
+362  747  806--->   ...
+
+```
+
+What is the *first value written* that is *larger* than your puzzle input?
+
+Your puzzle answer was `330785`.
+
+Both parts of this puzzle are complete! They provide two gold stars: \*\*
+
+At this point, all that is left is for you to [admire your Advent calendar](/2017).
+
+Your puzzle input was `325489`.

2017/day03-spiral_memory/src/lib.rs

@@ -0,0 +1,60 @@
+use std::{f64::consts::PI, collections::HashMap};
+
+pub fn run(input: usize) -> (usize, usize) {
+    let coords = spiral_location(input);
+    let first = coords.0.unsigned_abs() + coords.1.unsigned_abs();
+    let mut second_data = HashMap::from([((0, 0), 1)]);
+    let mut old_coords = (0, 0);
+    for index in 2.. {
+        let mut to_coords = (old_coords.0 +(((((4*index-7) as f64).sqrt()-0.5).round() * PI/2.0).sin().round() as isize), old_coords.1 + ((((4*index-7) as f64).sqrt() - 0.5).round() * PI/2.0).cos().round() as isize);
+        let sum = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)].iter()
+            .map(|direction| second_data.get(&(to_coords.0 + direction.0, to_coords.1 + direction.1)).unwrap_or(&0))
+            .sum();
+        if sum > input {
+            return (first, sum);
+        }
+        second_data.insert(to_coords, sum);
+        std::mem::swap(&mut old_coords, &mut to_coords);
+    }
+    unreachable!("The loop always executes");
+}
+
+fn spiral_location(number: usize) -> (isize, isize) {
+    (get_x_coord(number), get_y_coord(number))
+}
+
+fn get_x_coord(number: usize) -> isize {
+    (2..=number).map(|i| (((4.0 * i as f64 - 7.0).sqrt() - 0.5).round() * PI/2.0).sin())
+        .sum::<f64>()
+        .round() as isize
+}
+
+fn get_y_coord(number: usize) -> isize {
+    (2..=number).map(|i| (((4.0 * i as f64 - 7.0).sqrt() - 0.5).round() * PI/2.0).cos())
+        .sum::<f64>()
+        .round() as isize
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sample() {
+        let sample = [
+            (1,(0, 2)),
+            (12,(3, 23)),
+            (23,(2, 25)),
+            (1024,(31, 1968)),
+        ];
+        for (sample_input, sample_result) in sample {
+           assert_eq!(run(sample_input), sample_result);
+        }
+    }
+
+    #[test]
+    fn test_challenge() {
+        let challenge_input = 325489;
+        assert_eq!(run(challenge_input), (552, 330785));
+    }
+}