Impl: Calculate Box Size

src/playfield.rs

@@ -3,6 +3,7 @@ use std::fmt;
 #[derive(PartialEq, Debug, Clone)]
 pub struct Playfield {
     pub size: usize,
+    pub box_size: usize,
     pub fields: Vec<Vec<Field>>,
     pub open_fields: Vec<usize>,
 }
@@ -11,6 +12,7 @@ impl Playfield {
     pub fn default(size: usize) -> Playfield {
         Self {
             size,
+            box_size: Playfield::calculate_box_size(size),
             fields: vec![vec![Field::default(); size]; size],
             open_fields: Vec::new(),
         }
@@ -55,14 +57,14 @@ impl Playfield {
     pub fn get_column(&self, index: usize) -> Vec<Field> {
         self.fields.iter().map(|row| row[index].clone()).collect()
     }
-    pub fn get_field(&self, row: usize, col: usize) -> &Field {
-        &self.fields[row][col]
-    }
     pub fn convert_index(&self, index: usize) -> (usize, usize) {
         let row = index / self.size;
         let col = index % self.size;
         (row, col)
     }
+    fn calculate_box_size(size: usize) -> usize {
+        f64::sqrt(size as f64) as usize
+    }
 }
 
 impl fmt::Display for Playfield {
@@ -125,7 +127,21 @@ mod tests {
             assert_eq!(column_3, expected_3);
         }
     }
+    mod calculate_box_size {
+        use super::*;
+        #[test]
+        fn simple() {
+            let size_1 = Playfield::calculate_box_size(1);
+            let size_2 = Playfield::calculate_box_size(3);
+            let size_3 = Playfield::calculate_box_size(4);
+            let size_4 = Playfield::calculate_box_size(9);
 
+            assert_eq!(size_1, 1);
+            assert_eq!(size_2, 1);
+            assert_eq!(size_3, 2);
+            assert_eq!(size_4, 3);
+        }
+    }
     mod convert_index {
         use super::*;
         #[test]
@@ -162,6 +178,7 @@ mod tests {
                 playfield,
                 Playfield {
                     size: 3,
+                    box_size: 1,
                     fields: vec![
                         vec![Field::new(1), Field::new(2), Field::new(3)],
                         vec![Field::default(), Field::default(), Field::default()],

src/sudoku_solver.rs

@@ -25,13 +25,13 @@ impl SudokuSolver {
 
     fn populate_possible_values(&mut self) {
         for open_field in &self.playfield.open_fields {
-            let row_index = open_field / self.playfield.size;
+            let (row_idx, col_idx) = self.playfield.convert_index(*open_field);
-            let row = &self.playfield.fields[row_index];
+            let row = &self.playfield.fields[row_idx];
 
             let possible_values_row = possible_values_from_vec(row, self.playfield.size as u32);
 
             let col_index = open_field % self.playfield.size;
-            let col = self.playfield.get_column(col_index);
+            let col = self.playfield.get_column(col_idx);
             let possible_values_col = possible_values_from_vec(&col, self.playfield.size as u32);
 
             let possible_values = possible_values_row
@@ -39,7 +39,7 @@ impl SudokuSolver {
                 .map(|v| *v)
                 .collect();
 
-            let row = &mut self.playfield.fields[row_index];
+            let row = &mut self.playfield.fields[row_idx];
             let field = &mut row[col_index];
             field.possible_values = possible_values;
         }
@@ -86,6 +86,11 @@ mod tests {
             assert_eq!(solved, expected);
         }
     }
+    mod solve_fields {
+        use super::*;
+        #[test]
+        fn simple() {}
+    }
     mod possible_values {
         use super::*;
         #[test]