move all "working" functions to use an array instead of a vector to lower memory overhead

Author: shaggysa

Cargo.toml

@@ -3,10 +3,6 @@ name = "lib-sudoku"
 version = "1.0.0"
 edition = "2024"
 
-[[bin]]
-name = "lib-sudoku"
-path = "src/main.rs"
-
 [lib]
 name = "lib_sudoku"
 crate-type = ["cdylib"]

src/libraries/puzzle_generator.rs

@@ -12,7 +12,7 @@ pub enum Order {
     RANDOM,
 }
 
-fn alt_get_possibilities(puzz: &Vec<u8>, pos: u8, order: &Order) -> Vec<u8> {
+fn alt_get_possibilities(puzz: &[u8; 81], pos: u8, order: &Order) -> Vec<u8> {
     let mut possibilities: Vec<u8> = Vec::new();
     let mut seen: [bool; 10] = [false; 10];
     let row: usize = (pos / 9) as usize;
@@ -49,7 +49,7 @@ fn alt_get_possibilities(puzz: &Vec<u8>, pos: u8, order: &Order) -> Vec<u8> {
     possibilities
 }
 
-fn alt_solver_prep(puzz: Vec<u8>, order: Order) -> Puzzle {
+fn alt_solver_prep(puzz: [u8;81], order: Order) -> Puzzle {
     let mut p: Puzzle = Puzzle {
         puzz,
         blank_positions: Vec::new(),
@@ -100,7 +100,7 @@ fn alt_solver_prep(puzz: Vec<u8>, order: Order) -> Puzzle {
     p
 }
 
-pub fn alt_solve(puzz: Vec<u8>, order: Order) -> PyResult<Vec<u8>> {
+pub fn alt_solve(puzz: [u8; 81], order: Order) -> PyResult<[u8; 81]> {
     if puzz.len() != 81 {
         return Err(pyo3::exceptions::PyValueError::new_err("A puzzle must have a length of 81!"));
     }
@@ -155,17 +155,17 @@ pub fn alt_solve(puzz: Vec<u8>, order: Order) -> PyResult<Vec<u8>> {
     }
 }
 
-fn gen_random_solved() -> Vec<u8> {
-    let puzzle: Vec<u8> = vec![0; 81];
+fn gen_random_solved() -> [u8; 81] {
+    let puzzle: [u8; 81] = [0; 81];
     alt_solve(puzzle, RANDOM).unwrap()
 }
 
-fn is_legal(puzzle: &Vec<u8>) -> bool {
-    puzzle_solver::solve(puzzle.clone()).unwrap() == alt_solve(puzzle.clone(), REVERSE).unwrap()
+fn is_legal(puzzle: &[u8; 81]) -> bool {
+    puzzle_solver::backend_solve(puzzle.clone()).unwrap() == alt_solve(puzzle.clone(), REVERSE).unwrap()
 }
 
 #[pyo3::pyfunction]
-pub fn gen_unsolved(num_hints: usize) -> PyResult<Vec<u8>> {
+pub fn gen_unsolved(num_hints: usize) -> PyResult<[u8; 81]> {
 
     if num_hints < 23 || num_hints > 40 {
         return Err(pyo3::exceptions::PyValueError::new_err("Please specify a value between 23 and 40 for num_hints."));

src/libraries/puzzle_reader.rs

@@ -5,20 +5,16 @@ use std::io::{Write, stdout};
 #[derive(Clone)]
 pub struct PuzzleReader {
     pub size: usize,
-    pub unsolved: Vec<Vec<u8>>,
-    pub solved: Vec<Vec<u8>>,
+    pub unsolved: Vec<[u8; 81]>,
+    pub solved: Vec<[u8; 81]>,
 }
 
 #[pymethods]
 impl PuzzleReader {
     #[new]
     pub fn load_puzzles(file: &str, from_url: bool) -> PyResult<Self> {
 
-        let mut p = PuzzleReader {
-            size: 0,
-            unsolved: Vec::new(),
-            solved: Vec::new(),
-        };
+
 
         let puzzles_string: String;
 
@@ -38,16 +34,23 @@ impl PuzzleReader {
             println!("Read {} in {:?}", file, read_start.elapsed());
         }
 
+        let num_puzzles = (puzzles_string.len() - 15) * 81/82/(81*2);
+
+        let mut p = PuzzleReader {
+            size: num_puzzles,
+            unsolved: Vec::with_capacity(num_puzzles),
+            solved: Vec::with_capacity(num_puzzles),
+        };
+
         let parse_start = std::time::Instant::now();
         let mut first_line = true;
         for line in puzzles_string.lines() {
             if first_line {
                 first_line = false;
                 continue;
             }
-            p.size += 1;
-            let mut unsolved_list = vec![0;81];
-            let mut solved_list = vec![0; 81];
+            let mut unsolved_list: [u8; 81] = [0; 81];
+            let mut solved_list: [u8; 81] = [0; 81];
             let line_bytes = line.as_bytes();
 
             if line_bytes.len() == 163 && line_bytes[81] == 0x2c { //0x2c is the utf-8 char for a comma
@@ -67,17 +70,21 @@ impl PuzzleReader {
         Ok(p)
     }
 
-    pub fn get_unsolved_puzz(&self, line_num: usize) -> PyResult<Vec<u8>> {
+    pub fn get_unsolved_puzz(&self, line_num: usize) -> PyResult<[u8; 81]> {
         Ok(self.unsolved[line_num - 2].clone())
     }
 
-    pub fn get_solved_puzz(&self, line_num: usize) -> PyResult<Vec<u8>> {
+    pub fn get_solved_puzz(&self, line_num: usize) -> PyResult<[u8; 81]> {
         Ok(self.solved[line_num - 2].clone())
     }
 }
 
 #[pyfunction]
 pub fn print_puzz(puzz: Vec<u8>) {
+    backend_print_puzz(puzz.try_into().expect("A puzzle must have a length of 81!"));
+}
+
+pub fn backend_print_puzz(puzz: [u8; 81]) {
     let mut lock = stdout().lock();
 
     for row in 0..9 {

src/libraries/puzzle_solver.rs

@@ -1,6 +1,8 @@
 use pyo3::{pyfunction, PyResult};
+use std::convert::TryInto;
+
 pub(crate) struct Puzzle { 
-    pub puzz: Vec<u8>,
+    pub puzz: [u8; 81],
     pub blank_positions: Vec<u8>,
     pub possibilities: Vec<Vec<u8>>,
     pub cached_possibilities: Vec<[bool;10]>,
@@ -24,9 +26,10 @@ fn no_repeats(items: Vec<u8>) -> bool {
 
 #[pyfunction]
 pub(crate) fn is_valid(puzzle: Vec<u8>) -> PyResult<bool> {
-    if puzzle.len() != 81 {
-        return Err(pyo3::exceptions::PyValueError::new_err("A puzzle must have a length of 81!"));
-    }
+    backend_is_valid(puzzle.try_into().expect("A puzzle must have a length of 81!"))
+}
+
+pub(crate) fn backend_is_valid(puzzle: [u8; 81]) -> PyResult<bool> {
 
     for i in 0..9 { //check rows
         if !no_repeats(Vec::from(&puzzle[i * 9..(i + 1) * 9])) {
@@ -67,7 +70,7 @@ pub(crate) fn is_valid(puzzle: Vec<u8>) -> PyResult<bool> {
     Ok(true)
 }
 
-pub(crate) fn get_possibilities(puzz: &Vec<u8>, pos: u8) -> Vec<u8> {
+pub(crate) fn get_possibilities(puzz: &[u8; 81], pos: u8) -> Vec<u8> {
     let mut possibilities: Vec<u8> = Vec::new();
     let mut seen: [bool; 10] = [false; 10];
     let row: usize = (pos / 9) as usize;
@@ -92,7 +95,7 @@ pub(crate) fn get_possibilities(puzz: &Vec<u8>, pos: u8) -> Vec<u8> {
     }
     possibilities
 }
-fn solver_prep(puzz: Vec<u8>) -> Puzzle {
+fn solver_prep(puzz: [u8; 81]) -> Puzzle {
     let mut p: Puzzle = Puzzle {
         puzz,
         blank_positions: Vec::new(),
@@ -143,7 +146,7 @@ fn solver_prep(puzz: Vec<u8>) -> Puzzle {
     p
 }
 
-pub(crate) fn get_possibilities_as_array(puzz: &Vec<u8>, pos: usize) -> [bool; 10] {
+pub(crate) fn get_possibilities_as_array(puzz: &[u8; 81], pos: usize) -> [bool; 10] {
     let mut seen: [bool; 10] = [true; 10];
     let row: usize = pos / 9;
     let col: usize = pos % 9;
@@ -161,18 +164,20 @@ pub(crate) fn get_possibilities_as_array(puzz: &Vec<u8>, pos: usize) -> [bool; 1
     }
     seen
 }
+
 #[pyfunction]
-pub fn solve(puzz: Vec<u8>) -> PyResult<Vec<u8>> {
-    if puzz.len() != 81 {
-        return Err(pyo3::exceptions::PyValueError::new_err("Your puzzle must have a length of 81!"));
-    }
+pub fn solve(puzz: Vec<u8>) -> PyResult<[u8; 81]> {
+    backend_solve(puzz.try_into().expect("A puzzle must have a length of 81!"))
+}
+
+pub fn backend_solve(puzz: [u8; 81]) -> PyResult<[u8; 81]> {
 
     let mut p = solver_prep(puzz);
     if p.solved {
         return Ok(p.puzz);
     }
 
-    if !is_valid(p.puzz.clone())? {
+    if !backend_is_valid(p.puzz.clone())? {
         return Err(pyo3::exceptions::PyValueError::new_err("The puzzle is illegal!"));
     }
 
@@ -221,7 +226,7 @@ pub fn solve(puzz: Vec<u8>) -> PyResult<Vec<u8>> {
     }
 }
 
-pub async fn async_solve(puzz: Vec<u8>) -> PyResult<Vec<u8>> {
-    solve(puzz)
+pub async fn async_solve(puzz: [u8; 81]) -> PyResult<[u8; 81]> {
+    backend_solve(puzz)
 }
 

src/libraries/speedtest.rs

@@ -1,6 +1,6 @@
 use pyo3::pyfunction;
 use crate::libraries::puzzle_reader;
-use crate::libraries::puzzle_solver::{async_solve, solve};
+use crate::libraries::puzzle_solver::{async_solve, backend_solve};
 
 
 #[pyfunction]
@@ -31,7 +31,7 @@ pub fn async_speedtest(puzzle_reader: &puzzle_reader::PuzzleReader, verbose: boo
     let start_validate = std::time::Instant::now();
 
     for i in 0..solved_puzzles.len() {
-        let pc_solved: Vec<u8>;
+        let pc_solved: [u8; 81];
 
         match &solved_puzzles[i] {
             Ok(puzz) => {
@@ -43,9 +43,9 @@ pub fn async_speedtest(puzzle_reader: &puzzle_reader::PuzzleReader, verbose: boo
         if verbose {
             println!("\nLine {}:", i + 2);
             println!("Unsolved: ",);
-            puzzle_reader::print_puzz(puzzle_reader.unsolved[i].clone());
+            puzzle_reader::backend_print_puzz(puzzle_reader.unsolved[i].clone());
             println!("\nSolved:");
-            puzzle_reader::print_puzz(pc_solved.clone());
+            puzzle_reader::backend_print_puzz(pc_solved.clone());
 
 
         }
@@ -66,16 +66,16 @@ pub fn async_speedtest(puzzle_reader: &puzzle_reader::PuzzleReader, verbose: boo
 #[pyo3(signature = (puzzle_reader, verbose = false))]
 pub fn synchronous_speedtest(puzzle_reader: &puzzle_reader::PuzzleReader, verbose: bool) -> pyo3::PyResult<()> {
     println!("---------------\nStarting Synchronous Speedtest\n---------------");
-    let mut solved_puzzles = Vec::new();
+    let mut solved_puzzles: Vec<pyo3::PyResult<[u8; 81]>> = Vec::with_capacity(puzzle_reader.size);
     let start_solve = std::time::Instant::now();
     for i in 0..puzzle_reader.unsolved.len() {
-        solved_puzzles.push(solve(puzzle_reader.unsolved[i].clone()));
+        solved_puzzles.push(backend_solve(puzzle_reader.unsolved[i].clone()));
     }
     let solve_time = start_solve.elapsed();
     let start_validate = std::time::Instant::now();
 
     for i in 0..solved_puzzles.len() {
-        let pc_solved: Vec<u8>;
+        let pc_solved: [u8; 81];
 
         match &solved_puzzles[i] {
             Ok(puzz) => {
@@ -87,9 +87,9 @@ pub fn synchronous_speedtest(puzzle_reader: &puzzle_reader::PuzzleReader, verbos
         if verbose {
             println!("\nLine {}:", i + 2);
             println!("Unsolved: ",);
-            puzzle_reader::print_puzz(puzzle_reader.unsolved[i].clone());
+            puzzle_reader::backend_print_puzz(puzzle_reader.unsolved[i].clone());
             println!("\nSolved:");
-            puzzle_reader::print_puzz(pc_solved.clone());
+            puzzle_reader::backend_print_puzz(pc_solved.clone());
 
 
         }

testing.py

@@ -4,7 +4,7 @@
 
 def tests():
     reader = sudoku.PuzzleReader(
-        "https://raw.githubusercontent.com/shaggysa/lib_sudoku/master/puzzles.csv", True
+        "puzzles.csv", False
     )
     sudoku.async_speedtest(reader)
     sudoku.synchronous_speedtest(reader)