optimizations

Author: rene-d

.gitignore

@@ -22,4 +22,9 @@ answer.txt
 
 resolve_error.sh
 resolve_unknown.sh
-.run.db
+.run.db
+
+src/year*/day*/Cargo.toml
+src/year*/day*/Cargo.lock
+src/year*/day*/target/
+crates/**/Cargo.lock

README.md

@@ -27,7 +27,7 @@ Puzzle                                                                 | Stars |
 [Day 11: Plutonian Pebbles](https://adventofcode.com/2024/day/11)      | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day11/day11.rs) [![Go](./scripts/assets/go.png)](src/year2024/day11/day11.go)
 [Day 12: Garden Groups](https://adventofcode.com/2024/day/12)          | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day12/day12.rs) [![Go](./scripts/assets/go.png)](src/year2024/day12/day12.go)
 [Day 13: Claw Contraption](https://adventofcode.com/2024/day/13)       | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day13/day13.rs) [![Rust](./scripts/assets/rust.png)](src/year2024/day13_z3/day13_z3.rs) [![Python](./scripts/assets/python.png)](src/year2024/day13_z3/day13.py) [![Go](./scripts/assets/go.png)](src/year2024/day13/day13.go)
-[Day 14: Restroom Redoubt](https://adventofcode.com/2024/day/14)       | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day14/day14.rs) [![Python](./scripts/assets/python.png)](src/year2024/day14/day14.py) [🎁](src/year2024/day14/README.md)
+[Day 14: Restroom Redoubt](https://adventofcode.com/2024/day/14)       | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day14/day14.rs) [![Python](./scripts/assets/python.png)](src/year2024/day14/day14.py) [![Go](./scripts/assets/go.png)](src/year2024/day14/day14.go) [🎁](src/year2024/day14/README.md)
 [Day 15: Warehouse Woes](https://adventofcode.com/2024/day/15)         | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day15/day15.rs) [![Go](./scripts/assets/go.png)](src/year2024/day15/day15.go) [🎁](src/year2024/day15/README.md)
 [Day 16: Reindeer Maze](https://adventofcode.com/2024/day/16)          | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day16/day16.rs) [🎁](src/year2024/day16/README.md)
 [Day 17: Chronospatial Computer](https://adventofcode.com/2024/day/17) | ⭐⭐  | [![Rust](./scripts/assets/rust.png)](src/year2024/day17/day17.rs)

src/main.rs

@@ -58,7 +58,10 @@ fn run_day_single(args: &aoc::Args) {
     let sols = solutions(year, day, &alt);
 
     if sols.len() != 1 {
-        println!("-r requires exactly one solution ({} found with year={year:?} day={day:?} alt={alt:?})", sols.len());
+        println!(
+            "-r requires exactly one solution ({} found with year={year:?} day={day:?} alt={alt:?})",
+            sols.len()
+        );
         std::process::exit(1);
     }
 
@@ -227,7 +230,9 @@ fn run_all(args: &aoc::Args) {
 
     if puzzles > 1 {
         println!();
-        println!("Elapsed: {total_elapsed:#?} for {puzzles} puzzle(s) - success: {success}, failed: {failed}");
+        println!(
+            "Elapsed: {total_elapsed:#?} for {puzzles} puzzle(s) - success: {success}, failed: {failed}"
+        );
     }
 }
 

src/year2015/day16/day16.rs

@@ -8,21 +8,70 @@ struct Puzzle<'a> {
 }
 
 impl<'a> Puzzle<'a> {
+    /// Parse the input data using manual string parsing (faster than regex).
+    /// Parses lines in the format: "Sue 1: goldfish: 6, trees: 9, akitas: 0"
     fn new(data: &'a str) -> Self {
         let mut aunts: FxHashMap<u32, FxHashMap<&'a str, u32>> = FxHashMap::default();
 
+        for line in data.lines() {
+            let Some(rest) = line.strip_prefix("Sue ") else {
+                continue;
+            };
+
+            let Some(colon_pos) = rest.find(':') else {
+                continue;
+            };
+
+            let sue = rest[..colon_pos].parse::<u32>().unwrap();
+            let mut props = rest[colon_pos + 1..].trim_start();
+
+            let mut aunt = FxHashMap::default();
+
+            while !props.is_empty() {
+                // read the pair "<key>: <value>"
+                let Some(key_end) = props.find(':') else {
+                    break;
+                };
+                let key = props[..key_end].trim_end();
+
+                props = &props[key_end + 1..];
+
+                let value_end = props.find(',').unwrap_or(props.len());
+                let value = props[..value_end].trim_start().parse::<u32>().unwrap();
+
+                aunt.insert(key, value);
+
+                // go to next pair
+                props = props[value_end..].trim_start_matches(',').trim_start();
+            }
+
+            aunts.insert(sue, aunt);
+        }
+        Self { aunts }
+    }
+
+    /// Parse the input data using regex (slower but more readable).
+    /// Parses lines in the format: "Sue 1: goldfish: 6, trees: 9, akitas: 0"
+    fn new_regex(data: &'a str) -> Self {
+        let mut aunts: FxHashMap<u32, FxHashMap<&'a str, u32>> = FxHashMap::default();
+
         let re = Regex::new(r"Sue (\d+): (\w+): (\d+), (\w+): (\d+), (\w+): (\d+)").unwrap();
 
         for line in data.lines() {
             let m = re.captures(line).unwrap();
             let sue = m.get(1).unwrap().as_str().parse::<u32>().unwrap();
 
+            let mut aunt = FxHashMap::default();
+
             for i in (2..=6).step_by(2) {
                 let key = m.get(i).unwrap().as_str();
                 let value = m.get(i + 1).unwrap().as_str().parse::<u32>().unwrap();
-                aunts.entry(sue).or_default().insert(key, value);
+                aunt.insert(key, value);
             }
+
+            aunts.insert(sue, aunt);
         }
+
         Self { aunts }
     }
 
@@ -72,7 +121,17 @@ pub fn solve(data: &str) -> (u32, u32) {
     (puzzle.part1(), puzzle.part2())
 }
 
+#[must_use]
+pub fn solve_regex(data: &str) -> (u32, u32) {
+    let puzzle = Puzzle::new_regex(data);
+    (puzzle.part1(), puzzle.part2())
+}
+
 pub fn main() {
     let args = aoc::parse_args();
-    args.run(solve);
+    if args.has_option("--use-regex") {
+        args.run(solve_regex);
+    } else {
+        args.run(solve);
+    }
 }

src/year2022/day19/day19.rs

@@ -106,7 +106,7 @@ struct Blueprint {
 
 impl Blueprint {
     fn new(input: &str) -> Self {
-        let re= Regex::new(r"Blueprint (\d+): Each ore robot costs (\d+) ore. Each clay robot costs (\d+) ore. Each obsidian robot costs (\d+) ore and (\d+) clay. Each geode robot costs (\d+) ore and (\d+) obsidian.").unwrap();
+        let re = Regex::new(r"Blueprint (\d+): Each ore robot costs (\d+) ore. Each clay robot costs (\d+) ore. Each obsidian robot costs (\d+) ore and (\d+) clay. Each geode robot costs (\d+) ore and (\d+) obsidian.").unwrap();
 
         let m = re.captures(input).unwrap();
 

src/year2024/README.md

@@ -22,7 +22,7 @@ Puzzle                                                                 | Stars |
 [Day 11: Plutonian Pebbles](https://adventofcode.com/2024/day/11)      | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day11/day11.rs) [![Go](../../scripts/assets/go.png)](day11/day11.go)
 [Day 12: Garden Groups](https://adventofcode.com/2024/day/12)          | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day12/day12.rs) [![Go](../../scripts/assets/go.png)](day12/day12.go)
 [Day 13: Claw Contraption](https://adventofcode.com/2024/day/13)       | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day13/day13.rs) [![Rust](../../scripts/assets/rust.png)](day13_z3/day13_z3.rs) [![Python](../../scripts/assets/python.png)](day13_z3/day13.py) [![Go](../../scripts/assets/go.png)](day13/day13.go)
-[Day 14: Restroom Redoubt](https://adventofcode.com/2024/day/14)       | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day14/day14.rs) [![Python](../../scripts/assets/python.png)](day14/day14.py) [🎁](day14/README.md)
+[Day 14: Restroom Redoubt](https://adventofcode.com/2024/day/14)       | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day14/day14.rs) [![Python](../../scripts/assets/python.png)](day14/day14.py) [![Go](../../scripts/assets/go.png)](day14/day14.go) [🎁](day14/README.md)
 [Day 15: Warehouse Woes](https://adventofcode.com/2024/day/15)         | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day15/day15.rs) [![Go](../../scripts/assets/go.png)](day15/day15.go) [🎁](day15/README.md)
 [Day 16: Reindeer Maze](https://adventofcode.com/2024/day/16)          | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day16/day16.rs) [🎁](day16/README.md)
 [Day 17: Chronospatial Computer](https://adventofcode.com/2024/day/17) | ⭐⭐  | [![Rust](../../scripts/assets/rust.png)](day17/day17.rs)

src/year2024/day13/day13.rs

@@ -1,6 +1,5 @@
 //! [Day 13: Claw Contraption](https://adventofcode.com/2024/day/13)
 
-use regex::Regex;
 type F = fraction::GenericFraction<i64>;
 
 struct ClawMachine {
@@ -14,12 +13,23 @@ struct ClawMachine {
 
 impl ClawMachine {
     fn parse(s: &str) -> Self {
-        let re = Regex::new(r"\d+").unwrap();
-
-        let values = re
-            .find_iter(s)
-            .map(|m| m.as_str().parse::<i64>().unwrap())
-            .collect::<Vec<_>>();
+        let mut values = Vec::new();
+        let mut chars = s.chars().peekable();
+
+        // find positive integers into chars
+        while let Some(ch) = chars.next() {
+            if let Some(mut num) = ch.to_digit(10).map(i64::from) {
+                while let Some(next_ch) = chars.peek().copied() {
+                    if let Some(digit) = next_ch.to_digit(10) {
+                        num = num * 10 + i64::from(digit);
+                        chars.next();
+                    } else {
+                        break;
+                    }
+                }
+                values.push(num);
+            }
+        }
 
         Self {
             a_x: F::from(values[0]),

src/year2024/day14/day14.go

@@ -0,0 +1,151 @@
+// [Day 14: Restroom Redoubt](https://adventofcode.com/2024/day/14)
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+type Robot struct {
+	px, py int
+	vx, vy int
+}
+
+type Puzzle struct {
+	robots []Robot
+	width  int
+	height int
+}
+
+func newPuzzle(data []byte) Puzzle {
+	lines := strings.Split(strings.TrimSpace(string(data)), "\n")
+
+	var robots []Robot
+	for _, line := range lines {
+		if line == "" {
+			continue
+		}
+
+		var robot Robot
+		fmt.Sscanf(line, "p=%d,%d v=%d,%d", &robot.px, &robot.py, &robot.vx, &robot.vy)
+		robots = append(robots, robot)
+	}
+
+	return Puzzle{
+		robots: robots,
+		width:  101,
+		height: 103,
+	}
+}
+
+func mod(a, b int) int {
+	r := a % b
+	if r < 0 {
+		r += b
+	}
+	return r
+}
+
+func (p Puzzle) part1() int {
+	quadrants := make(map[[2]int]int)
+
+	for _, robot := range p.robots {
+		px := mod(robot.px+robot.vx*100, p.width)
+		py := mod(robot.py+robot.vy*100, p.height)
+
+		if px == p.width/2 || py == p.height/2 {
+			continue
+		}
+
+		q := [2]int{(px * 2) / p.width, (py * 2) / p.height}
+		quadrants[q]++
+	}
+
+	product := 1
+	for _, count := range quadrants {
+		product *= count
+	}
+	return product
+}
+
+func (p Puzzle) part2() int {
+outer:
+	for seconds := 0; seconds < 100_000; seconds++ {
+		grid := make(map[[2]int]struct{})
+
+		for _, robot := range p.robots {
+			px := mod(robot.px+robot.vx*seconds, p.width)
+			py := mod(robot.py+robot.vy*seconds, p.height)
+
+			key := [2]int{px, py}
+			if _, exists := grid[key]; exists {
+				continue outer
+			}
+			grid[key] = struct{}{}
+		}
+
+		horizontalLines := 0
+		for y := 0; y < p.height; y++ {
+			for x := 0; x < p.width-10; x++ {
+				line := true
+				for i := x; i < x+5; i++ {
+					if _, ok := grid[[2]int{i, y}]; !ok {
+						line = false
+						break
+					}
+				}
+				if line {
+					horizontalLines++
+				}
+			}
+		}
+
+		if horizontalLines > 5 {
+			return seconds
+		}
+	}
+
+	return 0
+}
+
+func solve(data []byte) (int, int) {
+	puzzle := newPuzzle(data)
+	return puzzle.part1(), puzzle.part2()
+}
+
+func main() {
+	filename := "input.txt"
+	elapsed := false
+
+	for i := 1; i < len(os.Args); i++ {
+		arg := os.Args[i]
+		if arg == "--elapsed" {
+			elapsed = true
+		} else if !strings.HasPrefix(arg, "-") {
+			filename = arg
+		}
+	}
+
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if elapsed {
+		start := time.Now()
+		result1, result2 := solve(data)
+		duration := time.Since(start)
+
+		fmt.Println(result1)
+		fmt.Println(result2)
+		fmt.Printf("elapsed: %f ms\n", duration.Seconds()*1000.0)
+	} else {
+		result1, result2 := solve(data)
+
+		fmt.Println(result1)
+		fmt.Println(result2)
+	}
+}