d08 bcs grialion didnt do it yet this morning but he just did >:(

2024/08/p1/main.rs

@@ -0,0 +1,95 @@
+#![feature(vec_pop_if)]
+
+use std::{
+    cmp,
+    collections::{HashMap, HashSet},
+    fs::File,
+    io::Read,
+    time::{Duration, Instant},
+};
+
+fn main() {
+    let args: Vec<_> = std::env::args().collect();
+    let filename = &args[1];
+    let runs = args[2]
+        .parse()
+        .expect("expected a number on second argument");
+
+    let mut contents = vec![];
+    File::open(filename)
+        .expect("Couldn't open file")
+        .read_to_end(&mut contents)
+        .expect("Error reading file");
+    contents.pop_if(|b| *b == b'\n');
+    let lines: Vec<_> = contents.split(|&b| b == b'\n').collect();
+
+    let mut max = Duration::ZERO;
+    let mut avg = Duration::ZERO;
+    let mut min = Duration::MAX;
+    let result = run(&lines);
+    for i in 0..runs {
+        let a = Instant::now();
+        let run_result = run(&lines);
+        let b = Instant::now();
+        if result != run_result {
+            panic!(
+                "supposed result is {} but this run got {} after {} runs",
+                result, run_result, i
+            );
+        }
+
+        let d = b - a;
+        max = cmp::max(d, max);
+        min = cmp::min(d, min);
+        avg += d / runs;
+    }
+
+    println!("\x1b[0;34mtotal \x1b[1;33m{result}\x1b[0;34m\n  runs  \x1b[1;33m{runs:?}\x1b[0;34m\n  avg.  \x1b[1;35m{avg:?}\x1b[0;34m\n  max.  \x1b[1;31m{max:?}\x1b[0;34m\n  min.  \x1b[1;32m{min:?}\x1b[0m");
+}
+
+fn run(lines: &[&[u8]]) -> usize {
+    // let mut t = 0;
+    let height = lines.len() as isize - 1;
+    let width = lines[0].len() as isize - 1;
+    // println!("bounds: {:?}", (width, height));
+
+    let mut antinodes: HashSet<(isize, isize)> = HashSet::new();
+    let mut hashmap: HashMap<u8, HashSet<(isize, isize)>> = HashMap::new();
+    for (y, ln) in lines.iter().enumerate() {
+        let y = y as isize;
+        for (x, &ch) in ln.iter().enumerate() {
+            let x = x as isize;
+            if ch.is_ascii_alphanumeric() {
+                let freq_set = hashmap.entry(ch).or_default();
+
+                // Calculate antinodes with previous points
+                // println!(
+                //     "ascii alphanum at {};{} ({}) || {:?}",
+                //     x,
+                //     y,
+                //     (char::from_u32(ch as u32)).unwrap(),
+                //     freq_set
+                // );
+                for point in freq_set.iter() {
+                    let dr = (x - point.0, y - point.1);
+                    let t1 = (point.0 - dr.0, point.1 - dr.1);
+                    let t2 = (x + dr.0, y + dr.1);
+
+                    // println!(" calc relative to {:?} | {:?} and {:?}", point, t1, t2);
+
+                    for tgt in [t1, t2] {
+                        if tgt.0 < 0 || tgt.0 > width || tgt.1 < 0 || tgt.1 > height {
+                            // println!("   target {:?} overshoots", tgt);
+                            continue;
+                        }
+                        if antinodes.insert(tgt) { /* t += 1; */ }
+                    }
+                }
+
+                freq_set.insert((x, y));
+            }
+        }
+    }
+
+    antinodes.len()
+}

2024/08/realshortdemo.txt

@@ -0,0 +1 @@
+.....0....0.....