122 lines
3 KiB
Rust
122 lines
3 KiB
Rust
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]));
|
|
}
|
|
}
|