day16

src/day16/main.rs

@@ -0,0 +1,122 @@
+use std::fs::File;
+use std::io::prelude::*;
+use std::iter;
+
+fn main() {
+    /*
+    let pattern = EnumeratedCycle::new(vec![0, 1, 0, -1], 1);
+    let pattern = pattern
+        .map(|(iteration, item)| iter::repeat(item).take(iteration))
+        .flatten();
+    */
+
+    // part 1
+    let f = File::open("input16").expect("unable to load \"input16\"");
+    let transmission: Vec<_> = f.bytes().map(|b| (b.unwrap() - b'0') as i64).collect();
+    print!("output: ");
+    phase_n(transmission, 100)
+        .iter()
+        .take(8)
+        .for_each(|i| print!("{}", i));
+    println!();
+}
+
+fn phase_n(input: Vec<i64>, phases: usize) -> Vec<i64> {
+    let mut output = input;
+    for _ in 0..phases {
+        output = phase(output)
+    }
+    output
+}
+
+fn phase(input: Vec<i64>) -> Vec<i64> {
+    let mut output: Vec<i64> = Vec::with_capacity(input.len());
+    for (pos, _) in input.iter().enumerate() {
+        let mut pattern = repeated_cycle(vec![0, 1, 0, -1], pos + 1);
+        pattern.next();
+        let mut value =
+            input
+                .iter()
+                .zip(pattern)
+                .map(|(a, b)| (a * b) % 10)
+                .fold(0, |i, mut acc| {
+                    acc += i;
+                    acc
+                });
+        if value < 0 {
+            value *= -1
+        }
+        output.push(value % 10);
+    }
+    output
+}
+
+fn repeated_cycle(input: Vec<i64>, repeats: usize) -> impl Iterator<Item = i64> {
+    input
+        .clone()
+        .into_iter()
+        .map(move |item| iter::repeat(item).take(repeats))
+        .flatten()
+        .cycle()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn example1() {
+        assert_eq!(
+            phase(vec![1, 2, 3, 4, 5, 6, 7, 8]),
+            vec![4, 8, 2, 2, 6, 1, 5, 8]
+        );
+        assert_eq!(
+            phase(vec![4, 8, 2, 2, 6, 1, 5, 8]),
+            vec![3, 4, 0, 4, 0, 4, 3, 8]
+        );
+        assert_eq!(
+            phase(vec![3, 4, 0, 4, 0, 4, 3, 8]),
+            vec![0, 3, 4, 1, 5, 5, 1, 8]
+        );
+        assert_eq!(
+            phase(vec![0, 3, 4, 1, 5, 5, 1, 8]),
+            vec![0, 1, 0, 2, 9, 4, 9, 8]
+        );
+    }
+
+    #[test]
+    fn example2() {
+        let data: Vec<_> = "80871224585914546619083218645595"
+            .bytes()
+            .map(|i| (i - b'0') as i64)
+            .collect();
+        assert!(phase_n(data, 100)
+            .into_iter()
+            .take(8)
+            .eq(vec![2, 4, 1, 7, 6, 1, 7, 6]));
+    }
+
+    #[test]
+    fn example3() {
+        let data: Vec<_> = "19617804207202209144916044189917"
+            .bytes()
+            .map(|i| (i - b'0') as i64)
+            .collect();
+        assert!(phase_n(data, 100)
+            .into_iter()
+            .take(8)
+            .eq(vec![7, 3, 7, 4, 5, 4, 1, 8]));
+    }
+
+    #[test]
+    fn example4() {
+        let data: Vec<_> = "69317163492948606335995924319873"
+            .bytes()
+            .map(|i| (i - b'0') as i64)
+            .collect();
+        assert!(phase_n(data, 100)
+            .into_iter()
+            .take(8)
+            .eq(vec![5, 2, 4, 3, 2, 1, 3, 3]));
+    }
+}