chore: add CodingQuest.io (with problem 13)

clechasseur · clechasseur · commit 2476a98960fb · 2025-01-25T19:27:53.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["aoclp", "aoclp_solutions"]
+members = ["aoclp", "aoclp_solutions", "codingquest_clp", "codingquest_clp_solutions"]
 default-members = ["aoclp_solutions"]
 
 [workspace.dependencies]
diff --git a/README.md b/README.md
@@ -1,3 +1,5 @@
 # adventofcode.rs
 
-My solutions to some of the [Advent of Code](https://adventofcode.com/) puzzles, using [Rust](https://www.rust-lang.org/).
+My solutions to some of the [Advent of Code](https://adventofcode.com/) and [Coding Quest](https://codingquest.io/) puzzles, using [Rust](https://www.rust-lang.org/).
+
+(_Note to `Self`: The Coding Quest code should be moved to another repo_)
diff --git a/aoclp/src/positioning/pt_3d.rs b/aoclp/src/positioning/pt_3d.rs
@@ -27,7 +27,7 @@ where
     V: Into<T>,
     W: Into<T>,
 {
-    /// Converts form a 3-number tuple to a [`Pt3D`].
+    /// Converts form a 3-number tuple to a [`Pt3d`].
     fn from(value: (U, V, W)) -> Self {
         Self::new(value.0.into(), value.1.into(), value.2.into())
     }
@@ -37,7 +37,7 @@ impl<T, U, V, W> From<Pt3d<T>> for (U, V, W)
 where
     T: Into<U> + Into<V> + Into<W>,
 {
-    /// Converts from a [`Pt3D`] to a 3-number tuple.
+    /// Converts from a [`Pt3d`] to a 3-number tuple.
     fn from(value: Pt3d<T>) -> Self {
         (value.x.into(), value.y.into(), value.z.into())
     }
@@ -49,7 +49,7 @@ where
 {
     type Err = ();
 
-    /// Parses a [`Pt3D`] from a string in the form `(x, y, z)`.
+    /// Parses a [`Pt3d`] from a string in the form `(x, y, z)`.
     /// Parentheses and whitespace are optional.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         static REGEX: OnceLock<Regex> = OnceLock::new();
diff --git a/aoclp_solutions/README.md b/aoclp_solutions/README.md
@@ -1,6 +1,6 @@
 # aoclp_solutions
 
-My solutions to Advent of Code puzzles in Rust 🦀
+My solutions to [Advent of Code](https://adventofcode.com/) puzzles in Rust 🦀
 
 ## Requirements
 
diff --git a/aoclp_solutions/src/lib.rs b/aoclp_solutions/src/lib.rs
@@ -1,4 +1,4 @@
-//! Solutions to Advent of Code puzzles in Rust 🦀
+//! Solutions to [Advent of Code](https://adventofcode.com/) puzzles in Rust 🦀
 
 #![allow(dead_code)]
 
diff --git a/codingquest_clp/Cargo.toml b/codingquest_clp/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "codingquest_clp"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aoclp = { path = "../aoclp" }
+itertools = { workspace = true }
diff --git a/codingquest_clp/src/lib.rs b/codingquest_clp/src/lib.rs
@@ -0,0 +1,8 @@
+//! Helper library for Coding Quest.
+
+pub mod solvers_impl;
+
+pub type Error = aoclp::Error;
+pub type Result<T> = aoclp::Result<T>;
+
+pub use aoclp;
diff --git a/codingquest_clp/src/solvers_impl.rs b/codingquest_clp/src/solvers_impl.rs
@@ -0,0 +1,2 @@
+pub mod input;
+pub mod solvers;
diff --git a/codingquest_clp/src/solvers_impl/input.rs b/codingquest_clp/src/solvers_impl/input.rs
@@ -0,0 +1,18 @@
+use std::fs;
+use std::path::Path;
+
+use aoclp::solvers_impl::input::Input;
+
+pub fn get_input<S>(input: S) -> crate::Result<Input<'static>>
+where
+    S: Into<String>,
+{
+    Ok(Input::for_example(input))
+}
+
+pub fn get_input_from_file<P>(path: P) -> crate::Result<Input<'static>>
+where
+    P: AsRef<Path>,
+{
+    get_input(fs::read_to_string(&path)?)
+}
diff --git a/codingquest_clp/src/solvers_impl/solvers.rs b/codingquest_clp/src/solvers_impl/solvers.rs
@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+use std::fmt::Display;
+
+use aoclp::solvers_impl::solvers::{Solver, SolverWrapper};
+use itertools::Itertools;
+
+#[macro_export]
+macro_rules! build_solvers {
+    ( [$($problem:literal),+] ) => {
+        build_solvers! {
+            solvers, [$($problem),+]
+        }
+    };
+    ( $fn_name:ident, [$($problem:literal),+] ) => {
+        $crate::aoclp::paste::paste! {
+            pub fn $fn_name() -> $crate::solvers_impl::solvers::Solvers {
+                let mut solvers = $crate::solvers_impl::solvers::Solvers::default();
+                $(
+                    solvers.push_problem($problem, [<problem_ $problem>]::solve);
+                )+
+                solvers
+            }
+        }
+    };
+}
+
+#[derive(Default)]
+pub struct Solvers {
+    solvers: HashMap<u32, Box<dyn Solver>>,
+}
+
+impl Solvers {
+    pub fn push_problem<S, T>(&mut self, problem: u32, solver: S)
+    where
+        S: Fn() -> T + 'static,
+        T: Display + 'static,
+    {
+        self.solvers
+            .insert(problem, Box::new(SolverWrapper::new(solver)));
+    }
+
+    pub fn problems(&self) -> impl Iterator<Item = u32> + '_ {
+        self.solvers.keys().copied().sorted_unstable()
+    }
+
+    pub fn solve(&self, problem: u32) -> String {
+        self.solvers[&problem].solve()
+    }
+}
diff --git a/codingquest_clp_solutions/.gitignore b/codingquest_clp_solutions/.gitignore
@@ -0,0 +1 @@
+input_data/problem_*
diff --git a/codingquest_clp_solutions/Cargo.toml b/codingquest_clp_solutions/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "codingquest_clp_solutions"
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.75.0"
+
+[dependencies]
+clap = { workspace = true, features = ["derive"] }
+codingquest_clp = { path = "../codingquest_clp" }
+itertools = { workspace = true }
diff --git a/codingquest_clp_solutions/README.md b/codingquest_clp_solutions/README.md
@@ -0,0 +1,26 @@
+# codingquest_clp_solutions
+
+My solutions to [Coding Quest](https://codingquest.io/) puzzles in Rust 🦀
+
+## Requirements
+
+* [Rust](https://www.rust-lang.org/) 1.75.0 or later
+
+## Saving problem input data
+
+Problem input data must be saved in the [`input_data`](./input_data) directory.
+Name each input data file `problem_N.txt` where N is the problem number.
+
+## Finding solutions
+
+### All solutions
+
+```shell
+cargo run
+```
+
+### Only a specific problem
+
+```shell
+cargo run -- --problem 13
+```
diff --git a/codingquest_clp_solutions/input_data/.keep b/codingquest_clp_solutions/input_data/.keep
diff --git a/codingquest_clp_solutions/src/helpers.rs b/codingquest_clp_solutions/src/helpers.rs
@@ -0,0 +1,10 @@
+use std::fs;
+use std::path::PathBuf;
+
+pub fn get_problem_input_data(problem: u32) -> crate::Result<String> {
+    Ok(fs::read_to_string(
+        [env!("CARGO_MANIFEST_DIR"), "input_data", &format!("problem_{problem}.txt")]
+            .iter()
+            .collect::<PathBuf>(),
+    )?)
+}
diff --git a/codingquest_clp_solutions/src/lib.rs b/codingquest_clp_solutions/src/lib.rs
@@ -0,0 +1,15 @@
+//! Solutions to [Coding Quest](https://codingquest.io/) puzzles in Rust 🦀
+
+#![allow(dead_code)]
+
+use codingquest_clp::build_solvers;
+
+pub mod helpers;
+pub mod problem_13;
+
+pub type Error = codingquest_clp::Error;
+pub type Result<T> = codingquest_clp::Result<T>;
+
+build_solvers! {
+    [13]
+}
diff --git a/codingquest_clp_solutions/src/main.rs b/codingquest_clp_solutions/src/main.rs
@@ -0,0 +1,36 @@
+use std::time::Instant;
+
+use clap::Parser;
+use codingquest_clp::solvers_impl::solvers::Solvers;
+use codingquest_clp_solutions::solvers;
+
+fn main() {
+    let solvers = solvers();
+    let args = Cli::parse();
+
+    println!();
+
+    if let Some(problem) = args.problem {
+        run_problem(&solvers, problem);
+    } else {
+        for problem in solvers.problems() {
+            run_problem(&solvers, problem);
+        }
+    }
+}
+
+fn run_problem(solvers: &Solvers, problem: u32) {
+    let start = Instant::now();
+    let solution = solvers.solve(problem);
+    let elapsed = start.elapsed();
+    println!("  Problem {problem}: {solution} ({elapsed:.2?})");
+}
+
+/// Find solution(s) to CodingQuest.io problems
+#[derive(Debug, Parser)]
+#[command(version, long_about = None)]
+struct Cli {
+    /// Find solution for this problem only
+    #[arg(short, long, value_parser = clap::value_parser!(u32).range(1..=25))]
+    problem: Option<u32>,
+}
diff --git a/codingquest_clp_solutions/src/problem_13.rs b/codingquest_clp_solutions/src/problem_13.rs
@@ -0,0 +1,95 @@
+use codingquest_clp::solvers_impl::input::get_input;
+use itertools::Itertools;
+
+use crate::helpers::get_problem_input_data;
+
+pub fn solve() -> usize {
+    let (board, moves) = input();
+
+    let mut p1 = 0;
+    let mut p2 = 0;
+    for (count, &(p1_move, p2_move)) in moves.moves.iter().enumerate() {
+        p1 += p1_move;
+        while (p1 as usize) < board.tiles.len() && board.tiles[p1 as usize] != 0 {
+            p1 += board.tiles[p1 as usize];
+        }
+        if (p1 as usize) >= board.tiles.len() {
+            return count + 1;
+        }
+
+        p2 += p2_move;
+        while (p2 as usize) < board.tiles.len() && board.tiles[p2 as usize] != 0 {
+            p2 += board.tiles[p2 as usize];
+        }
+        if (p2 as usize) >= board.tiles.len() {
+            return 2 * (count + 1);
+        }
+    }
+
+    panic!("No solution found");
+}
+
+fn input() -> (Board, Moves) {
+    let input_data = get_problem_input_data(13).unwrap();
+    (Board::from_input_data(&input_data), Moves::from_input_data(&input_data))
+}
+
+struct Board {
+    pub tiles: Vec<i32>,
+}
+
+const BOARD_SIZE: usize = 20;
+
+impl Board {
+    fn from_input_data<I>(input_data: I) -> Self
+    where
+        I: AsRef<str>,
+    {
+        Self {
+            tiles: get_input(
+                input_data
+                    .as_ref()
+                    .lines()
+                    .take(BOARD_SIZE)
+                    .collect_vec()
+                    .join("\n"),
+            )
+            .unwrap()
+            .safe_into_many_vecs()
+            .into_iter()
+            .rev()
+            .enumerate()
+            .flat_map(|(i, mut row)| {
+                if i % 2 != 0 {
+                    row.reverse();
+                }
+                row
+            })
+            .collect(),
+        }
+    }
+}
+
+struct Moves {
+    pub moves: Vec<(i32, i32)>,
+}
+
+impl Moves {
+    fn from_input_data<I>(input_data: I) -> Self
+    where
+        I: AsRef<str>,
+    {
+        Self {
+            moves: get_input(
+                input_data
+                    .as_ref()
+                    .lines()
+                    .skip(BOARD_SIZE)
+                    .collect_vec()
+                    .join("\n"),
+            )
+            .unwrap()
+            .safe_into_many_pairs(),
+        }
+    }
+}
diff --git a/justfile b/justfile
@@ -30,6 +30,17 @@ default:
 run *extra_args:
     {{cargo}} run {{all_features_flag}} {{target_tuple_flag}} {{release_flag}} {{ if extra_args != '' { '-- ' + extra_args } else { '' } }}
 
+_run_solutions bin_name *extra_args:
+    {{cargo}} run --package {{bin_name}} {{all_features_flag}} {{target_tuple_flag}} {{release_flag}} {{ if extra_args != '' { '-- ' + extra_args } else { '' } }}
+
+# Run AoC solutions executable
+@aoc *extra_args:
+    just _run_solutions aoclp_solutions {{extra_args}}
+
+# Run CodingQuest.io solutions executable
+@cq *extra_args:
+    just _run_solutions codingquest_clp_solutions {{extra_args}}
+
 # Run clippy and rustfmt on workspace files
 tidy: clippy fmt
 

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ where`
`27`	`27`	`V: Into<T>,`
`28`	`28`	`W: Into<T>,`
`29`	`29`	`{`
`30`		- /// Converts form a 3-number tuple to a [`Pt3D`].
	`30`	+ /// Converts form a 3-number tuple to a [`Pt3d`].
`31`	`31`	`fn from(value: (U, V, W)) -> Self {`
`32`	`32`	`Self::new(value.0.into(), value.1.into(), value.2.into())`
`33`	`33`	`}`
`@@ -37,7 +37,7 @@ impl<T, U, V, W> From<Pt3d<T>> for (U, V, W)`
`37`	`37`	`where`
`38`	`38`	`T: Into<U> + Into<V> + Into<W>,`
`39`	`39`	`{`
`40`		- /// Converts from a [`Pt3D`] to a 3-number tuple.
	`40`	+ /// Converts from a [`Pt3d`] to a 3-number tuple.
`41`	`41`	`fn from(value: Pt3d<T>) -> Self {`
`42`	`42`	`(value.x.into(), value.y.into(), value.z.into())`
`43`	`43`	`}`
`@@ -49,7 +49,7 @@ where`
`49`	`49`	`{`
`50`	`50`	`type Err = ();`
`51`	`51`
`52`		- /// Parses a [`Pt3D`] from a string in the form `(x, y, z)`.
	`52`	+ /// Parses a [`Pt3d`] from a string in the form `(x, y, z)`.
`53`	`53`	`/// Parentheses and whitespace are optional.`
`54`	`54`	`fn from_str(s: &str) -> Result<Self, Self::Err> {`
`55`	`55`	`static REGEX: OnceLock<Regex> = OnceLock::new();`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-//! Solutions to Advent of Code puzzles in Rust 🦀`
	`1`	`+//! Solutions to [Advent of Code](https://adventofcode.com/) puzzles in Rust 🦀`
`2`	`2`
`3`	`3`	`#![allow(dead_code)]`
`4`	`4`