aoc

commit 7e4982be44b980ccbe00c88a66abd773dba62f1a
parent b5d2f5d1958923f9645b242037d9b3c6682e0430
Author: Sebastiano Tronto <sebastiano@tronto.net>
Date:   Tue,  1 Jul 2025 14:35:03 +0200

Day 13 2022

Diffstat:
A
2022/13/a.rs
 | 
21
+++++++++++++++++++++
A
2022/13/b.rs
 | 
26
++++++++++++++++++++++++++
A
2022/13/common.rs
 | 
75
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3 files changed, 122 insertions(+), 0 deletions(-)
diff --git a/2022/13/a.rs b/2022/13/a.rs
@@ -0,0 +1,21 @@
+use std::cmp::Ordering;
+mod common;
+use common::*;
+
+fn main() {
+    let mut line = String::new();
+    let mut sum = 0;
+    let mut i = 0;
+    loop {
+        i += 1;
+        let _ = std::io::stdin().read_line(&mut line).unwrap();
+        let p = parse(line.as_bytes());
+        line.clear();
+        let _ = std::io::stdin().read_line(&mut line).unwrap();
+        let q = parse(line.as_bytes());
+        if compare(&p, &q) != Ordering::Greater { sum += i; }
+        if std::io::stdin().read_line(&mut line).unwrap() == 0 { break; }
+        line.clear();
+    }
+    println!("{sum}");
+}
diff --git a/2022/13/b.rs b/2022/13/b.rs
@@ -0,0 +1,26 @@
+use std::cmp::Ordering;
+mod common;
+use common::*;
+
+fn driver(n: i64) -> Packet {
+    Packet::List(vec![Packet::List(vec![Packet::Number(n)])])
+}
+
+fn find_driver(v: &Vec<Packet>, n: i64) -> usize {
+    v.iter()
+     .position(|p| compare(p, &driver(n)) == Ordering::Equal)
+     .unwrap() + 1
+}
+
+fn main() {
+    let mut v = vec![driver(2), driver(6)];
+    let mut line = String::new();
+    while std::io::stdin().read_line(&mut line).unwrap() > 0 {
+        if line.len() > 1 { v.push(parse(line.as_bytes())); }
+        line.clear();
+    }
+
+    v.sort_by(compare);
+
+    println!("{}", find_driver(&v, 2) * find_driver(&v, 6));
+}
diff --git a/2022/13/common.rs b/2022/13/common.rs
@@ -0,0 +1,75 @@
+use std::cmp::Ordering;
+
+#[derive(Debug)]
+pub enum Packet {
+    Number(i64),
+    List(Vec<Packet>)
+}
+
+fn compare_lists(l: &Vec<Packet>, k: &Vec<Packet>) -> Ordering {
+    for i in 0..std::cmp::min(l.len(), k.len()) {
+        let ord = compare(&l[i], &k[i]);
+        if ord != Ordering::Equal { return ord; }
+    }
+    l.len().cmp(&k.len())
+}
+
+fn compare_list_single(l: &Vec<Packet>, p: &Packet) -> Ordering {
+    if l.len() == 0 { return Ordering::Less; }
+    let ord = compare(&l[0], p);
+    if ord != Ordering::Equal { return ord; }
+    l.len().cmp(&1)
+}
+
+pub fn compare(p: &Packet, q: &Packet) -> Ordering {
+    match p {
+        Packet::Number(n) => {
+            match q {
+                Packet::Number(m) => n.cmp(&m),
+                Packet::List(k) => compare_list_single(k, p).reverse()
+            } 
+        },
+        Packet::List(l) => {
+            match q {
+                Packet::Number(_) => compare_list_single(l, q),
+                Packet::List(k) => compare_lists(l, k)
+            }
+        }
+    }
+}
+
+fn parse_int(line: &[u8], i: &mut usize) -> i64 {
+    let mut r: i64 = 0;
+    loop {
+        match line[*i] {
+            b'0'..=b'9' => r = r * 10 + (line[*i] as i64) - ('0' as i64),
+            b',' | b']' => return r,
+            x => panic!("Error: unexpected '{}' at position {} in parse_int",
+                        x as char, *i)
+        }
+        *i += 1;
+    }
+}
+
+fn parse_list(line: &[u8], i: &mut usize) -> Packet {
+    if line[*i] != b'[' {
+        panic!("Error: sub-list at {} does not start with '['", *i);
+    }
+    *i += 1;
+    let mut v = Vec::<Packet>::new();
+    while *i < line.len() && line[*i] != b'\n' {
+        match line[*i] {
+            b']' => { *i += 1; return Packet::List(v); },
+            b'[' => v.push(parse_list(line, i)),
+            b'0'..=b'9' => v.push(Packet::Number(parse_int(line, i))),
+            b' ' | b',' => *i += 1,
+            x => panic!("Error: unexpected '{}' at position {}", x as char, *i)
+        }
+    }
+    panic!("Error: finished parsing at {}, but ']' not found", *i);
+}
+
+pub fn parse(line: &[u8]) -> Packet {
+    let mut i = 0;
+    parse_list(line, &mut i)
+}