WIP on master: 2c5ab37 fixup

Author: dcoles

2022/day12/src/main.rs

@@ -6,6 +6,7 @@ use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::Write;
+use std::ops::{Add, Sub};
 use std::path::Path;
 
 fn main() {
@@ -22,6 +23,7 @@ fn main() {
 }
 
 fn part1(input: &Input) -> usize {
+    let mut prev: HashMap<(usize, usize), (usize, usize)> = HashMap::new();
     let mut best: HashMap<(usize, usize), usize> = [(input.start, 0)].into_iter().collect();
     let mut edge = vec![input.start];
 
@@ -34,6 +36,7 @@ fn part1(input: &Input) -> usize {
         for neighbour in input.neighbour(pos) {
             let steps = best[&pos] + 1;
             if best.get(&neighbour).map(|best| steps < *best).unwrap_or(true) {
+                prev.insert(neighbour, pos);
                 best.insert(neighbour, steps);
                 edge.push(neighbour);
             }
@@ -42,6 +45,16 @@ fn part1(input: &Input) -> usize {
         edge.sort_by(|a, b| best[b].cmp(&best[a]));
     }
 
+    // Walk path
+    let mut pos = input.end;
+    println!("[");
+    println!("  ({}, {}, {}),", pos.0, pos.1, input.map[&pos]);
+    while let Some(&p) = prev.get(&pos) {
+        println!("  ({}, {}, {}),", p.0, p.1, input.map[&p]);
+        pos = p;
+    }
+    println!("]");
+
     // What is the fewest steps required to move from your current position
     // to the location that should get the best signal?
     best[&input.end]

2023/Cargo.lock

@@ -24,7 +24,7 @@ members = [
     "day22",
     "day23",
     "day24",
-    # "day25",
+    "day25",
 ]
 exclude = []
 resolver = "2"

2023/Cargo.toml

@@ -1,3 +1,4 @@
+?###???????? 3,2,1
 ???.### 1,1,3
 .??..??...?##. 1,1,3
 ?#?#?#?#?#?#?#? 1,3,1,6

2023/day12/example1.txt

@@ -6,7 +6,7 @@ use std::path::Path;
 
 fn main() {
     let input = Input::from_file(format!("{}/input.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
-    //let input = Input::from_file(format!("{}/example1.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
+    let input = Input::from_file(format!("{}/example1.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
 
     // Part 1
     println!("Part 1: {}", part1(&input));
@@ -36,7 +36,7 @@ fn part1(input: &Input) -> usize {
         combinations.push(count);
     }
 
-    println!("{:?}", combinations);
+    //println!("{:?}", combinations);
     combinations.into_iter().sum()
 }
 
@@ -69,6 +69,105 @@ fn is_match(state: &[State], groups: &[usize]) -> bool {
 }
 
 fn part2(input: &Input) -> usize {
+    for (records, groups) in &input.values {
+        let mut records = records.clone();
+        println!("{records:?} {groups:?}");
+
+        let total = records.len();
+        let n_damaged: usize = groups.iter().sum();
+        let n_ok = total - n_damaged;
+
+        println!("total: {total}, damaged: {n_damaged}, ok: {n_ok}");
+
+        // We can split these up into groups of ok/broken/ok/.../broken/ok
+        // N0 + A + (1 + N1) + B + (1 + N2) + ... + Z + Nn = total
+        // We know that N0 .. Nn must be in the range 0..a
+        let mut a = n_ok - (groups.len() - 1);
+        println!("a: {a}");
+
+        // There's always at least one OK spring between broken sets
+        let mut ns = vec![[0, a]; groups.len() + 1];
+        for n in 1..groups.len() {
+            ns[n][0] += 1;
+            ns[n][1] += 1;
+        }
+
+        let mut ok_known = records.iter().filter(|r| matches!(r, State::Operational)).count();
+        let mut damaged_known = records.iter().filter(|r| matches!(r, State::Damaged)).count();
+        let mut unknown = records.iter().filter(|r| matches!(r, State::Unknown)).count();
+        assert_eq!(ok_known + damaged_known + unknown, records.len());
+
+        let mut n = 0;
+        let mut ok_seen = 0;
+        let mut damaged_seen = 0;
+        let mut unknown_seen = 0;
+        for i in 0..records.len() {
+            println!("{i:02}: OK={ok_seen:2}, NG={damaged_seen:2}, UNK={unknown_seen:2} {ns:?}");
+            match records[i] {
+                State::Damaged => {
+                    damaged_seen += 1;
+
+                    ns[n][1] = ns[n][1].min(i); // This can probably be more agressive
+
+                    if damaged_seen == groups[0] {
+                        if (i + 1) > groups[n] {
+                            // This set must be preceeded by an undamaged mirror
+                            assert!(!matches!(records[i - groups[n]], State::Damaged));
+
+                            if matches!(records[i - groups[n]], State::Unknown) {
+                                records[i - groups[n]] = State::Operational;
+                                ok_known += 1;
+                                unknown -= 1;
+                            }
+
+                            ns[n][0] += 1;
+                            a = a.saturating_sub(1);
+                            for m in (0..ns.len()).filter(|&m| m != n) {
+                                ns[m][1] = ns[m][1].min(a);
+                            }
+                        }
+
+                        if (i + 1) < records.len() {
+                            // This set must be followed by an undamaged mirror
+                            assert!(!matches!(records[i + 1], State::Damaged));
+
+                            if matches!(records[i + 1], State::Unknown) {
+                                records[i + 1] = State::Operational;
+                                ok_known += 1;
+                                unknown -= 1;
+                            }
+
+                            assert_eq!(ns[n + 1][0], 1);  // already accounted for there being at least 1
+                        }
+
+                        ok_seen = 0;
+                        damaged_seen = 0;
+                        unknown_seen = 0;
+
+                        n += 1;
+                    }
+                },
+                State::Operational => {
+                    ok_seen += 1;
+                },
+                State::Unknown => {
+                    unknown_seen += 1;
+                },
+            }
+
+            // We have to always maintain these invariants
+            assert!(ok_seen <= n_ok);
+            assert!(damaged_seen <= n_damaged);
+            assert_eq!(ok_known + damaged_known + unknown, records.len());
+            assert!(ns.iter().map(|[lower, _]| lower).sum::<usize>() <= n_ok, "violated lower-bounds: {ns:?}");
+            assert!(ns.iter().map(|[_, upper]| upper).sum::<usize>() >= n_ok, "violated upper-bounds: {ns:?}");
+            assert!(ns.iter().all(|[lower, upper]| lower <= upper));
+        }
+
+        // We've done all we can
+        println!();
+    }
+
     0
 }
 

2023/day12/src/main.rs

@@ -52,9 +52,96 @@ fn part1(input: &Input) -> usize {
 }
 
 fn part2(input: &Input) -> usize {
+    let mut x = 0;
+    let mut y = 0;
+    let mut coords = vec![(x, y)];
+
+
+    /*
+    for (_, _, color) in &input.values {
+        let distance = i64::from_str_radix(&color[1..6], 16).unwrap();
+        match &color[6..7] {
+            "0" => x += distance, // Right,
+            "1" => y += distance, // Down
+            "2" => x -= distance, // Left
+            "3" => y -= distance, // Up
+            s => panic!("unknown directional ordinal: {s:?}"),
+        }
+
+        coords.push((x, y));
+    }
+    */
+    for (direction, distance, _) in &input.values {
+        match direction {
+            Direction::Up => y -= distance,
+            Direction::Down => y += distance,
+            Direction::Left => x -= distance,
+            Direction::Right => x += distance,
+        }
+
+        coords.push((x, y));
+    }
+
+    assert_eq!(coords.first().unwrap(), coords.last().unwrap());
+
+    let forward: Vec<(i64, i64)> = coords.iter().copied().collect();
+    let backwards: Vec<(i64, i64)> = coords.iter().rev().copied().collect();
+
+    let mut i = 0;
+    let mut j = 0;
+
+    let mut begin: Pos = (0, 0);
+    let mut a: Pos = (0, 0);
+    let mut b: Pos = (0, 0);
+    let mut total_area = 0;
+
+
+    loop {
+        while a.0 - begin.0 == 0 || a.1 - begin.1 == 0 {
+            i += 1;
+            a = forward[i];
+        }
+
+        while b.0 - begin.0 == 0 || b.1 - begin.1 == 0 {
+            j += 1;
+            b = backwards[j];
+        }
+
+        let dx_a = a.0 - begin.0;
+        let dx_b = b.0 - begin.0;
+        let dy_a = a.1 - begin.1;
+        let dy_b = b.1 - begin.1;
+
+        let dx = dx_a;
+        let dy = if dy_a.abs() < dy_b.abs() { dy_a } else { dy_b };
+
+        println!("dx {dx}, dy {dy}");
+
+        total_area += (dx.abs() + 1) * (dy.abs() + 1);
+
+        begin = (begin.0 + dx_b + dx_b.signum(), begin.1 + dy + dy.signum());
+
+        println!("{}", total_area);
+
+        if total_area > 10 {
+            break;
+        }
+    }
+
     0
 }
 
+type Pos = (i64, i64);
+
+fn delta(x1: (i64, i64), x0: (i64, i64)) -> (i64, i64) {
+    (x1.0 - x0.0, x1.1 - x0.1)
+}
+
+fn area(x0: Pos, x1: Pos) -> i64 {
+    (x1.0 - x0.0).abs() * (x1.1 - x0.1).abs()
+}
+
+
 #[derive(Debug, Clone)]
 struct Input {
     /// `(direction, distance, color)`

2023/day18/src/main.rs

@@ -9,8 +9,8 @@ const T_MIN: f64 = 0.0;
 const RANGE: RangeInclusive<f64> = 200000000000000.0..=400000000000000.0;
 
 fn main() {
-    let input = Input::from_file(format!("{}/input.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
-    //let input = Input::from_file(format!("{}/example1.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
+    //let input = Input::from_file(format!("{}/input.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
+    let input = Input::from_file(format!("{}/example1.txt", env!("CARGO_MANIFEST_DIR"))).expect("failed to read input");
     //println!("{input:?}");
 
     // Part 1
@@ -37,7 +37,7 @@ fn intersections_within_area(input: &Input, range: RangeInclusive<f64>) -> usize
             let b = input.values[j];
             let (intersect, (t_a, t_b)) = solve_xy_intersection(a, b);
 
-            //println!("{a:?} {b:?}: {intersect:?} @ {t_a}/{t_b} ns");
+            println!("{a:?} {b:?}: {intersect:?} @ {t_a}/{t_b} ns");
             if range.contains(&intersect.x) && range.contains(&intersect.y) && t_a > T_MIN && t_b > T_MIN {
                 n += 1;
             }