CQ problem 14

clechasseur · clechasseur · commit c832ca6e4922 · 2025-01-25T20:04:19.000-05:00
diff --git a/codingquest_clp_solutions/src/lib.rs b/codingquest_clp_solutions/src/lib.rs
@@ -6,10 +6,11 @@ use codingquest_clp::build_solvers;
 
 pub mod helpers;
 pub mod problem_13;
+pub mod problem_14;
 
 pub type Error = codingquest_clp::Error;
 pub type Result<T> = codingquest_clp::Result<T>;
 
 build_solvers! {
-    [13]
+    [13, 14]
 }
diff --git a/codingquest_clp_solutions/src/problem_13.rs b/codingquest_clp_solutions/src/problem_13.rs
@@ -1,3 +1,5 @@
+use std::ops::Deref;
+
 use codingquest_clp::solvers_impl::input::get_input;
 use itertools::Itertools;
 
@@ -6,22 +8,23 @@ use crate::helpers::get_problem_input_data;
 pub fn solve() -> usize {
     let (board, moves) = input();
 
+    let move_player = |p: &mut i32, p_move: i32| {
+        *p += p_move;
+        while (*p as usize) < board.len() && board[*p as usize] != 0 {
+            *p += board[*p as usize];
+        }
+    };
+
     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() {
+    for (count, &(p1_move, p2_move)) in moves.iter().enumerate() {
+        move_player(&mut p1, p1_move);
+        if (p1 as usize) >= board.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() {
+        move_player(&mut p2, p2_move);
+        if (p2 as usize) >= board.len() {
             return 2 * (count + 1);
         }
     }
@@ -35,13 +38,13 @@ fn input() -> (Board, Moves) {
 }
 
 struct Board {
-    pub tiles: Vec<i32>,
+    tiles: Vec<i32>,
 }
 
 const BOARD_SIZE: usize = 20;
 
 impl Board {
-    fn from_input_data<I>(input_data: I) -> Self
+    pub fn from_input_data<I>(input_data: I) -> Self
     where
         I: AsRef<str>,
     {
@@ -70,12 +73,20 @@ impl Board {
     }
 }
 
+impl Deref for Board {
+    type Target = [i32];
+
+    fn deref(&self) -> &Self::Target {
+        &self.tiles
+    }
+}
+
 struct Moves {
-    pub moves: Vec<(i32, i32)>,
+    moves: Vec<(i32, i32)>,
 }
 
 impl Moves {
-    fn from_input_data<I>(input_data: I) -> Self
+    pub fn from_input_data<I>(input_data: I) -> Self
     where
         I: AsRef<str>,
     {
@@ -93,3 +104,11 @@ impl Moves {
         }
     }
 }
+
+impl Deref for Moves {
+    type Target = [(i32, i32)];
+
+    fn deref(&self) -> &Self::Target {
+        &self.moves
+    }
+}
diff --git a/codingquest_clp_solutions/src/problem_14.rs b/codingquest_clp_solutions/src/problem_14.rs
@@ -0,0 +1,79 @@
+use std::collections::{HashMap, HashSet};
+
+use codingquest_clp::solvers_impl::input::get_input;
+use itertools::Itertools;
+
+use crate::helpers::get_problem_input_data;
+
+pub fn solve() -> String {
+    let word_list = word_list();
+    let rules: Rules = GUESSES.into();
+
+    word_list
+        .into_iter()
+        .filter(|word| rules.matches(word))
+        .exactly_one()
+        .unwrap()
+        .clone()
+}
+
+fn word_list() -> Vec<String> {
+    get_input(get_problem_input_data(14).unwrap())
+        .unwrap()
+        .safe_into_many()
+}
+
+const GUESSES: &[(&str, &str)] =
+    &[("keyless", "YYBBYYG"), ("society", "YGYYYBB"), ("phobias", "BBGBGBG")];
+
+#[derive(Debug, Default)]
+struct Rules {
+    green: HashMap<usize, char>,
+    yellow: HashSet<char>,
+    black: HashSet<char>,
+}
+
+impl Rules {
+    pub fn matches<S>(&self, word: S) -> bool
+    where
+        S: AsRef<str>,
+    {
+        let word = word.as_ref();
+
+        word.chars()
+            .enumerate()
+            .filter(|(i, c)| {
+                if let Some(green) = self.green.get(i) {
+                    green == c
+                } else {
+                    self.yellow.contains(c) && !self.black.contains(c)
+                }
+            })
+            .count()
+            == word.len()
+    }
+}
+
+impl From<&[(&str, &str)]> for Rules {
+    fn from(value: &[(&str, &str)]) -> Self {
+        let rules: HashMap<_, _> = value
+            .iter()
+            .flat_map(|&(guess, colored)| {
+                guess
+                    .chars()
+                    .enumerate()
+                    .zip_eq(colored.chars())
+                    .map(|((i, g), color)| (color, (i, g)))
+            })
+            .into_group_map();
+
+        let color_rule = |color| rules.get(&color).unwrap().clone();
+        let simple_color_rule = |color| color_rule(color).into_iter().map(|(_, g)| g).collect();
+        let indexed_color_rule = |color| color_rule(color).into_iter().collect();
+
+        let green = indexed_color_rule('G');
+        let yellow = simple_color_rule('Y');
+        let black = simple_color_rule('B');
+        Self { green, yellow, black }
+    }
+}
