Rust single binary

Author: rene-d

one/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "one"
+version = "0.1.0"
+edition = "2021"
+
+[features]
+ascii = []
+anim = ["image"]
+
+[dependencies]
+aoc = { path = "../aoc" }
+assembunny = { path = "../2016/assembunny/" }
+intcode = { path = "../2019/intcode-rs/" }
+
+rustc-hash = "*"
+colored = "*"
+pest = { version = "*", default-features = false }
+pest_derive = { version = "*", default-features = true }
+petgraph = "*"
+rand = "*"
+regex = "*"
+rustworkx-core = "*"
+scan_fmt = "*"
+serde_json = "*"
+strum = { version = "*", features = ["strum_macros", "derive"] }
+strum_macros = "*"
+text_io = "*"
+z3 = "*"
+nom = "*"
+num = "*"
+num-traits = "*"
+itertools = "*"
+lazy_static = "*"
+md5 = "*"
+image = { version = "*", optional = true }
+indicatif = "*"
+fraction = "*"
+geo = "*"
+geo-types = "*"
+bytecount = "*"
+divisors = "*"

one/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    // Buy a Mac 
+    println!(r"cargo:rustc-link-search=/opt/homebrew/lib");
+}

one/m.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+
+
+def gen(year):
+    for src_dir in Path(f"../{year}").glob("day*"):
+        if "_" in src_dir.name:
+            continue
+
+        src_file = src_dir / (src_dir.name + ".rs")
+        dest_dir = Path(f"src/year{year}") / src_dir.name
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        for txt in src_file.parent.glob("*.txt"):
+            (dest_dir / txt.name).write_bytes(txt.read_bytes())
+
+        dest_file = dest_dir / (src_dir.name + ".rs")
+        if src_file.is_file():
+
+            rs = src_file.read_text()
+            rs = rs.replace('#[grammar = "day8.pest"]', '#[grammar = "src/year2017/day8/day8.pest"]')
+            rs = rs.replace("\nfn main() {", "\npub fn main() {")
+            rs = rs.replace("\nfn solve(", "\n#[must_use]\npub fn solve(")
+
+            dest_file.write_text(rs)
+
+        for txt in src_file.parent.glob("*.rs"):
+            if txt.name != dest_file.name:
+                z = dest_dir / dest_file.stem
+                z.mkdir(parents=True, exist_ok=True)
+                (z / txt.name).write_bytes(txt.read_bytes())
+
+        for txt in src_file.parent.glob("*.txt"):
+            (dest_dir / txt.name).write_bytes(txt.read_bytes())
+
+        for txt in src_file.parent.glob("*.pest"):
+            (dest_dir / txt.name).write_bytes(txt.read_bytes())
+
+
+gen(2015)
+gen(2016)
+gen(2017)
+gen(2018)
+gen(2019)
+gen(2020)
+gen(2021)
+gen(2022)
+gen(2023)
+gen(2024)

one/src/lib.rs

@@ -0,0 +1,108 @@
+use std::iter::empty;
+
+/// Get the array of all available solutions.
+#[must_use]
+pub fn solutions() -> Vec<Solution> {
+    empty()
+        .chain(year2015())
+        .chain(year2016())
+        .chain(year2017())
+        .chain(year2018())
+        .chain(year2019())
+        .chain(year2020())
+        .chain(year2021())
+        .chain(year2022())
+        .chain(year2024())
+        .collect()
+}
+
+/// A solution for given year and day.
+/// Offer two callbacks:
+///  - `solve` that takes the puzzle input and returns part one and two
+///  - `main` that acts like a standalone program for the given day
+#[derive(Clone)]
+pub struct Solution {
+    pub year: u16,
+    pub day: u8,
+    pub solve: fn(&str) -> (String, String),
+    pub main: fn() -> (),
+}
+
+macro_rules! make_year {
+    ($year:tt $($day:tt),*) => {
+        mod $year {
+            $(pub mod $day { pub mod $day; })*
+        }
+
+        #[must_use]
+        pub fn $year() -> Vec<Solution> {
+            vec![$({
+                let year = stringify!($year)[4..].parse().unwrap();
+                let day = stringify!($day)[3..].parse().unwrap();
+
+                let solve = |data: &str| {
+                    use crate::$year::$day::$day::solve;
+                    let (part1, part2) = solve(data);
+                    (part1.to_string(), part2.to_string())
+                };
+
+                let main = || {
+                    use crate::$year::$day::$day::main;
+                    main();
+                };
+
+                Solution { year, day, solve, main }
+            },)*]
+        }
+    }
+}
+
+make_year!(year2015
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2016
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2017
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2018
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2019
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2020
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2021
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2022
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2023
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);
+
+make_year!(year2024
+    day1,day2,day3,day4,day5,day6,day7,day8,day9,day10,day11,day12,day13,
+    day14,day15,day16,day17,day18,day19,day20,day21,day22,day23,day24,day25
+);

one/src/main.rs

@@ -0,0 +1,173 @@
+use colored::Colorize;
+use one::{solutions, Solution};
+use std::path::Path;
+use std::time::{Duration, Instant};
+
+fn main() -> std::io::Result<()> {
+    // in a YEAR/dayDAY directory, we act as the standalone binary
+    if run_day()? {
+        return Ok(());
+    }
+
+    let args = aoc::parse_args_raw();
+
+    // get the year or year/day filter
+    let mut year: Option<u16> = None;
+    let mut day: Option<u8> = None;
+
+    if !args.params.is_empty() {
+        let re = regex::Regex::new(r"(\d+)").unwrap();
+
+        let mut m = re.find_iter(&args.params[0]);
+
+        if let Some(y) = m.next() {
+            year = y.as_str().parse().ok();
+        }
+        if let Some(d) = m.next() {
+            day = d.as_str().parse().ok();
+        }
+    }
+
+    // and apply it to the solution inventory
+    let sols = solutions()
+        .iter()
+        .filter(|sol| year.is_none_or(|x| x == sol.year))
+        .filter(|sol| day.is_none_or(|x| x == sol.day))
+        .cloned()
+        .collect::<Vec<_>>();
+
+    // in raw mode (for runall.py) we need a file input path
+    if args.has_option("-r") {
+        if sols.len() != 1 {
+            println!("-r requires a filter");
+            return Ok(());
+        }
+
+        if args.params.len() != 2 {
+            println!("-r requires a path");
+            return Ok(());
+        }
+
+        let path = &args.params[1];
+        let data = aoc::load_input_data(path);
+        let sol = &sols[0];
+
+        args.run_data(sol.solve, &data);
+    } else {
+        run_all(&sols);
+    }
+
+    Ok(())
+}
+
+fn run_day() -> std::io::Result<bool> {
+    let path = std::env::current_dir()?;
+
+    if let Some(day) = path.file_name() {
+        if let Some(day) = day.to_str().unwrap().strip_prefix("day") {
+            if let Some(year) = path.parent() {
+                if let Some(year) = year
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .strip_prefix("year")
+                {
+                    let year: u16 = year.parse().unwrap();
+                    let day: u8 = day.parse().unwrap();
+
+                    for sol in &solutions() {
+                        if sol.day == day && sol.year == year {
+                            (sol.main)();
+                            break;
+                        }
+                    }
+                }
+
+                return Ok(true);
+            }
+        }
+    }
+
+    Ok(false)
+}
+
+fn print_part_result(part: u8, answer: &str, ok: &str, day: u8) {
+    if part == 2 && day == 25 {
+        println!(
+            "  {}  : {}",
+            "Part 2".yellow(),
+            "n/a".dimmed() // "Merry Christmas".bright_blue()
+        );
+    } else {
+        print!("  {}  : ", format!("Part {part}").yellow());
+        if ok.is_empty() {
+            println!("{answer}");
+        } else if answer.trim_ascii() == ok.trim_ascii() {
+            println!("{}", answer.bright_green());
+        } else {
+            println!("{}", answer.bright_red());
+        };
+    }
+}
+
+fn run_all(sols: &[Solution]) {
+    println!("💫 {} 🎄✨ 💫", "Advent of Code".green());
+
+    let mut total_elapsed = Duration::ZERO;
+    let mut puzzles = 0;
+    let mut success = 0;
+    let mut failed = 0;
+
+    for sol in sols {
+        let path = Path::new("input")
+            .join(sol.year.to_string())
+            .join(sol.day.to_string())
+            .with_extension("in");
+
+        let ok = path.with_extension("ok");
+
+        println!();
+        println!("{} day {}:", sol.year, sol.day);
+
+        if path.is_file() {
+            if let Ok(data) = std::fs::read_to_string(&path) {
+                // run the solution
+                let instant = Instant::now();
+                let (part1, part2) = (sol.solve)(&data);
+                let elapsed = instant.elapsed();
+
+                total_elapsed += elapsed;
+                puzzles += 1;
+
+                #[allow(clippy::cast_possible_truncation)]
+                let micros = Duration::from_micros(elapsed.as_micros() as u64);
+
+                if let Ok(ok) = std::fs::read_to_string(ok) {
+                    let (ok1, ok2) = ok.trim_ascii().split_once('\n').unwrap_or((&ok, ""));
+
+                    print_part_result(1, &part1, ok1, sol.day);
+                    print_part_result(2, &part2, ok2, sol.day);
+
+                    if ok1.trim_ascii() == part1 && ok2.trim_ascii() == part2 {
+                        success += 1;
+                    } else {
+                        failed += 1;
+                    }
+                } else {
+                    print_part_result(1, &part1, "", sol.day);
+                    print_part_result(2, &part2, "", sol.day);
+                }
+
+                println!("{}", format!("  Elapsed : {micros:#?}").italic());
+            }
+        } else {
+            println!("  missing file: {}", path.to_str().unwrap().red());
+        }
+    }
+
+    if puzzles > 1 {
+        println!();
+        println!("Elapsed: {total_elapsed:#?} for {puzzles} puzzle(s) - success: {success}, failed: {failed}");
+    }
+}