Add several solving methods
This commit is contained in:
parent
8bc8a6c0c7
commit
10958d2c10
1 changed files with 689 additions and 18 deletions
707
src/main.rs
707
src/main.rs
|
|
@ -1,6 +1,10 @@
|
|||
use std::rc::{Rc, Weak};
|
||||
use std::cell::{RefCell, Ref};
|
||||
use std::cell::{RefCell};
|
||||
use std::collections::HashSet;
|
||||
|
||||
const DEBUG: bool = false;
|
||||
|
||||
#[derive(Clone, Debug, Eq, PartialEq)]
|
||||
enum CellValue {
|
||||
FIXED(u8),
|
||||
UNKNOWN(Vec<u8>)
|
||||
|
|
@ -17,6 +21,10 @@ struct Cell {
|
|||
|
||||
impl Cell {
|
||||
fn set(&self, digit: u8){
|
||||
if DEBUG {
|
||||
println!("Cell {}, {} was set with digit {}", self.x, self.y, digit);
|
||||
}
|
||||
|
||||
self.value.replace(CellValue::FIXED(digit));
|
||||
|
||||
// We fully expect our row, column, and section to still be here even though the Rust compiler won't guarantee it
|
||||
|
|
@ -36,8 +44,60 @@ impl Cell {
|
|||
Cell::process_possibilities(section, digit);
|
||||
}
|
||||
|
||||
fn get_value_copy(&self) -> CellValue {
|
||||
let value = &*self.value.borrow();
|
||||
return value.clone();
|
||||
}
|
||||
|
||||
fn set_value(&self, value: CellValue){
|
||||
match value {
|
||||
CellValue::FIXED(digit) => {
|
||||
self.set(digit);
|
||||
return;
|
||||
},
|
||||
CellValue::UNKNOWN(_) => {
|
||||
self.set_value_exact(value);
|
||||
} // continue on
|
||||
}
|
||||
}
|
||||
|
||||
fn set_value_exact(&self, value: CellValue){
|
||||
if DEBUG {
|
||||
println!("Cell {}, {} was set with CellValue exact {:?}", self.x, self.y, value);
|
||||
}
|
||||
|
||||
self.value.replace(value);
|
||||
self.mark_updates();
|
||||
}
|
||||
|
||||
fn get_value_possibilities(&self) -> Option<Vec<u8>> {
|
||||
let value = &*self.value.borrow();
|
||||
match value {
|
||||
CellValue::FIXED(_) => None,
|
||||
CellValue::UNKNOWN(x) => Some(x.clone())
|
||||
}
|
||||
}
|
||||
|
||||
fn mark_updates(&self){
|
||||
{
|
||||
let row = &*self.row.upgrade().unwrap();
|
||||
let row = &*row.borrow();
|
||||
row.do_update.replace(true);
|
||||
}
|
||||
{
|
||||
let column = &*self.column.upgrade().unwrap();
|
||||
let column = &*column.borrow();
|
||||
column.do_update.replace(true);
|
||||
}
|
||||
{
|
||||
let section = &*self.section.upgrade().unwrap();
|
||||
let section = &*section.borrow();
|
||||
section.do_update.replace(true);
|
||||
}
|
||||
}
|
||||
|
||||
fn process_possibilities(line: &Line, digit: u8){
|
||||
for (_index, cell) in line.iter().enumerate() {
|
||||
for (_index, cell) in line.vec.iter().enumerate() {
|
||||
let cell = &**cell;
|
||||
|
||||
// Find the new CellValue to set; may be None if the cell was already fixed or had no possibilities remaining
|
||||
|
|
@ -53,6 +113,8 @@ impl Cell {
|
|||
_ => {}
|
||||
};
|
||||
|
||||
Some(CellValue::UNKNOWN(new_possibilities))
|
||||
/*
|
||||
if new_possibilities.len() == 1 {
|
||||
let remaining_digit = new_possibilities.first().unwrap().clone();
|
||||
Some(CellValue::FIXED(remaining_digit))
|
||||
|
|
@ -60,23 +122,15 @@ impl Cell {
|
|||
None
|
||||
} else {
|
||||
Some(CellValue::UNKNOWN(new_possibilities))
|
||||
}
|
||||
}*/
|
||||
},
|
||||
_ => {None}
|
||||
CellValue::FIXED(_) => {None}
|
||||
}
|
||||
};
|
||||
|
||||
match new_value_option {
|
||||
Some(new_value) => {
|
||||
match new_value {
|
||||
CellValue::UNKNOWN(_) => {
|
||||
cell.value.replace(new_value);
|
||||
},
|
||||
CellValue::FIXED(new_digit) => {
|
||||
cell.set(new_digit); // Recursive
|
||||
}
|
||||
|
||||
}
|
||||
cell.set_value(new_value);
|
||||
},
|
||||
None => {}
|
||||
}
|
||||
|
|
@ -85,7 +139,46 @@ impl Cell {
|
|||
}
|
||||
}
|
||||
|
||||
type Line = Vec<Rc<Cell>>;
|
||||
struct Line {
|
||||
vec: Vec<Rc<Cell>>,
|
||||
do_update: RefCell<bool>,
|
||||
index: usize,
|
||||
line_type: LineType
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
enum LineType {
|
||||
ROW,
|
||||
COLUMN,
|
||||
SECTION
|
||||
}
|
||||
|
||||
impl Line {
|
||||
fn push(&mut self, x: Rc<Cell>){
|
||||
self.vec.push(x);
|
||||
}
|
||||
|
||||
fn get(&self, index: usize) -> Option<&Rc<Cell>>{
|
||||
self.vec.get(index)
|
||||
}
|
||||
|
||||
fn new(index: usize, line_type: LineType) -> Line {
|
||||
Line {
|
||||
vec: Vec::new(),
|
||||
do_update: RefCell::new(false),
|
||||
index,
|
||||
line_type
|
||||
}
|
||||
}
|
||||
|
||||
fn do_update(&self) -> bool {
|
||||
let do_update = &self.do_update.borrow();
|
||||
let do_update = &**do_update;
|
||||
|
||||
return do_update.clone();
|
||||
}
|
||||
}
|
||||
|
||||
type MultiMut<T> = Rc<RefCell<T>>;
|
||||
|
||||
struct Grid {
|
||||
|
|
@ -101,10 +194,10 @@ impl Grid {
|
|||
let mut columns: Vec<MultiMut<Line>> = Vec::new();
|
||||
let mut sections: Vec<MultiMut<Line>> = Vec::new();
|
||||
|
||||
for _i in 0..9 {
|
||||
rows.push(Rc::new(RefCell::new(Line::new())));
|
||||
columns.push(Rc::new(RefCell::new(Line::new())));
|
||||
sections.push(Rc::new(RefCell::new(Line::new())));
|
||||
for i in 0..9 {
|
||||
rows.push(Rc::new(RefCell::new(Line::new(i, LineType::ROW))));
|
||||
columns.push(Rc::new(RefCell::new(Line::new(i, LineType::COLUMN))));
|
||||
sections.push(Rc::new(RefCell::new(Line::new(i, LineType::SECTION))));
|
||||
}
|
||||
|
||||
for row_index in 0..9 {
|
||||
|
|
@ -244,6 +337,474 @@ impl Grid {
|
|||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
struct FauxCell{
|
||||
index: usize,
|
||||
real_cell: Rc<Cell>,
|
||||
possibilities: HashSet<u8>,
|
||||
in_group: bool
|
||||
}
|
||||
|
||||
impl FauxCell {
|
||||
fn len(&self) -> usize {
|
||||
self.possibilities.len()
|
||||
}
|
||||
|
||||
fn remove(&mut self, to_remove: &HashSet<u8>){
|
||||
to_remove.iter().for_each(|digit| {self.possibilities.remove(digit);});
|
||||
}
|
||||
}
|
||||
|
||||
struct FauxLine (Vec<FauxCell>);
|
||||
|
||||
impl FauxLine {
|
||||
fn get_mut(&mut self, index: usize) -> Option<&mut FauxCell>{
|
||||
return self.0.get_mut(index);
|
||||
}
|
||||
|
||||
fn num_in_group(&self) -> usize {
|
||||
self.0.iter().filter(|fauxcell| fauxcell.in_group).count()
|
||||
}
|
||||
|
||||
fn num_out_group(&self) -> usize {
|
||||
self.0.len() - self.num_in_group()
|
||||
}
|
||||
}
|
||||
|
||||
// See if there's a set of cells with possibilities that exclude those possibilities from other cells.
|
||||
// Runs recursively on each group to identify all groups in case there's more than 2.
|
||||
fn identify_and_process_possibility_groups(line: &Line){
|
||||
if DEBUG {
|
||||
println!("Looking for possibility groups on line {:?} {}", line.line_type, line.index);
|
||||
}
|
||||
|
||||
bisect_possibility_groups(line, vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
|
||||
}
|
||||
|
||||
fn bisect_possibility_groups(line: &Line, cells_of_interest: Vec<usize>){
|
||||
|
||||
/*
|
||||
Algorithm -
|
||||
Setup - Let count = 0
|
||||
1. Choose cell with least number of possibilities. Add to in-group.
|
||||
2. Add to count the number of possibilities in that cell
|
||||
3. Remove the possibilities of that cell from all other out-group cells.
|
||||
4. If the number of cells in group == count, finish.
|
||||
5. Goto 1
|
||||
*/
|
||||
// For later recursive calls; put here because of scope reasons
|
||||
let mut in_group_indices = Vec::new();
|
||||
let mut out_group_indices = Vec::new();
|
||||
let mut run_recursion = false;
|
||||
|
||||
{
|
||||
// <Setup>
|
||||
let mut count = 0;
|
||||
let mut faux_line = FauxLine(Vec::new());
|
||||
|
||||
for i in 0..9 {
|
||||
if !cells_of_interest.contains(&i) {
|
||||
continue;
|
||||
}
|
||||
|
||||
let cell = line.get(i).unwrap();
|
||||
let cell = Rc::clone(cell);
|
||||
|
||||
let faux_possibilities = {
|
||||
let value = &*cell.value.borrow();
|
||||
match value {
|
||||
CellValue::UNKNOWN(possibilities) => {
|
||||
let mut set = HashSet::new();
|
||||
for (_index, digit) in possibilities.iter().enumerate() {
|
||||
set.insert(digit.clone());
|
||||
}
|
||||
set
|
||||
},
|
||||
CellValue::FIXED(_) => { continue }
|
||||
}
|
||||
};
|
||||
|
||||
let faux_cell = FauxCell {
|
||||
index: i,
|
||||
real_cell: cell,
|
||||
possibilities: faux_possibilities,
|
||||
in_group: false
|
||||
};
|
||||
|
||||
faux_line.0.push(faux_cell);
|
||||
}
|
||||
// </Setup>
|
||||
|
||||
// No point in continuing.
|
||||
if faux_line.num_out_group() <= 2 {
|
||||
return;
|
||||
}
|
||||
|
||||
// A kind of do-while loop
|
||||
loop {
|
||||
if faux_line.num_out_group() == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
// Step 1
|
||||
let mut smallest_cell: Option<&mut FauxCell> = None;
|
||||
let mut smallest_size = usize::MAX;
|
||||
|
||||
for (_index, cell) in faux_line.0.iter_mut().filter(|faux_cell| !faux_cell.in_group).enumerate() {
|
||||
if cell.len() < smallest_size {
|
||||
smallest_size = cell.len();
|
||||
smallest_cell = Some(cell);
|
||||
}
|
||||
}
|
||||
|
||||
let smallest_cell = smallest_cell.unwrap(); // Safe because we already verified the out-group had members
|
||||
smallest_cell.in_group = true;
|
||||
|
||||
// Step 2
|
||||
count = count + smallest_size;
|
||||
|
||||
|
||||
let possibilities_to_remove = smallest_cell.possibilities.clone(); // Necessary because of mutable borrow rules
|
||||
|
||||
// Step 3
|
||||
for (_index, cell) in faux_line.0.iter_mut().filter(|faux_cell| !faux_cell.in_group).enumerate() {
|
||||
cell.remove(&possibilities_to_remove);
|
||||
}
|
||||
|
||||
// Step 4 (finish condition)
|
||||
if faux_line.num_in_group() == count {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Now we have to see if this was worth it
|
||||
if faux_line.num_out_group() > 0 { // Worth it
|
||||
// We now have two distinct groups and can separate their possibilities
|
||||
let mut in_group_possibilities = HashSet::new();
|
||||
let mut out_group_possibilities = HashSet::new();
|
||||
|
||||
// Collect the possibilities for each group
|
||||
for (_index, cell) in faux_line.0.iter().enumerate() {
|
||||
if cell.in_group {
|
||||
cell.possibilities.iter().for_each(|digit| {in_group_possibilities.insert(digit.clone());});
|
||||
} else {
|
||||
cell.possibilities.iter().for_each(|digit| {out_group_possibilities.insert(digit.clone());});
|
||||
}
|
||||
}
|
||||
|
||||
// Now to apply this to the real cells
|
||||
for (_index, faux_cell) in faux_line.0.iter().enumerate() {
|
||||
let real_cell = line.get(faux_cell.index).unwrap();
|
||||
let mut possibilities = {
|
||||
let value = &*real_cell.value.borrow();
|
||||
match value {
|
||||
CellValue::UNKNOWN(possibilities) => possibilities.clone(),
|
||||
CellValue::FIXED(_) => {panic!("Faux_cell shouldn't have linked to fixed cell")}
|
||||
}
|
||||
};
|
||||
let starting_possibility_size = possibilities.len();
|
||||
|
||||
let possibilities_to_remove = match faux_cell.in_group {
|
||||
true => &out_group_possibilities,
|
||||
false => &in_group_possibilities
|
||||
};
|
||||
|
||||
for (_i, possibility) in possibilities_to_remove.iter().enumerate() {
|
||||
match possibilities.binary_search(possibility) {
|
||||
Ok(x) => {
|
||||
possibilities.remove(x);
|
||||
},
|
||||
Err(_) => {}
|
||||
};
|
||||
}
|
||||
|
||||
if possibilities.len() < starting_possibility_size { // We have a change to make
|
||||
let new_value = {
|
||||
if possibilities.len() == 1 {
|
||||
CellValue::FIXED(possibilities.pop().unwrap())
|
||||
} else {
|
||||
CellValue::UNKNOWN(possibilities)
|
||||
}
|
||||
};
|
||||
|
||||
real_cell.set_value(new_value);
|
||||
}
|
||||
}
|
||||
|
||||
// Now finally, it's possible that there were 3 or more groups while this algorithm only identifies 2
|
||||
// So we recursively call it but restricted to each of the groups
|
||||
run_recursion = true;
|
||||
for (index, cell) in faux_line.0.iter().enumerate() {
|
||||
if cell.in_group {
|
||||
in_group_indices.push(index);
|
||||
} else {
|
||||
out_group_indices.push(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Out of scope of everything; we need to check again if it was worth it.
|
||||
if run_recursion {
|
||||
bisect_possibility_groups(line, in_group_indices);
|
||||
bisect_possibility_groups(line, out_group_indices);
|
||||
}
|
||||
}
|
||||
|
||||
// Search for a cell with only one possibility so that we can set it to FIXED
|
||||
fn search_single_possibility(line: &Line){
|
||||
if DEBUG {
|
||||
println!("search_single_possibility on line {:?} {}", line.line_type, line.index);
|
||||
}
|
||||
|
||||
for (_index, cell) in line.vec.iter().enumerate(){
|
||||
match cell.get_value_possibilities(){
|
||||
Some(x) => {
|
||||
if x.len() == 1 {
|
||||
let new_value = CellValue::FIXED(x.first().unwrap().clone());
|
||||
cell.set_value(new_value);
|
||||
}
|
||||
},
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
enum PossibilityLines {
|
||||
UNIQUE(usize),
|
||||
INVALID,
|
||||
NONE
|
||||
}
|
||||
|
||||
impl PossibilityLines {
|
||||
fn is_invalid(&self) -> bool {
|
||||
match &self {
|
||||
PossibilityLines::INVALID => true,
|
||||
_ => false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If all the cells for a particular possibility share a same other Line, they can remove that possibility from other cells in the main line.
|
||||
// I.e. If possibility '1' only occurs in the first row for section 0, then you can remove that possibility
|
||||
// from row 0 across the other sections. Conversely, if the possibility only occurs in the first section
|
||||
// for row 0, then you can remove the possibility from the rest of section 0.
|
||||
fn search_useful_constraint(grid: &Grid, line: &Line){
|
||||
if DEBUG {
|
||||
println!("Searching for a useful constraint on line {:?} {}", line.line_type, line.index);
|
||||
}
|
||||
|
||||
let (check_row, check_column, check_section) = match line.line_type {
|
||||
LineType::ROW => {(false, false, true)},
|
||||
LineType::COLUMN => {(false, false, true)},
|
||||
LineType::SECTION => {(true, true, false)},
|
||||
};
|
||||
|
||||
for possibility in 0..9 {
|
||||
let mut rows = match check_row {true => PossibilityLines::NONE, false => PossibilityLines::INVALID};
|
||||
let mut columns = match check_column {true => PossibilityLines::NONE, false => PossibilityLines::INVALID};
|
||||
let mut sections = match check_section {true => PossibilityLines::NONE, false => PossibilityLines::INVALID};
|
||||
|
||||
for cell_id in 0..9 {
|
||||
let cell_ref = line.get(cell_id).unwrap();
|
||||
let cell_ref = Rc::clone(cell_ref);
|
||||
let cell_ref = &*cell_ref;
|
||||
let value = &*cell_ref.value.borrow();
|
||||
|
||||
match value {
|
||||
CellValue::FIXED(x) => { // We can deduce this possibility won't occur elsewhere in our row, so leave for-loop
|
||||
if possibility.eq(x) {
|
||||
rows = process_possibility_line(rows, &cell_ref.row);
|
||||
columns = process_possibility_line(columns, &cell_ref.column);
|
||||
sections = process_possibility_line(sections, &cell_ref.section);
|
||||
break;
|
||||
}
|
||||
}
|
||||
CellValue::UNKNOWN(digits) => {
|
||||
if digits.contains(&possibility) {
|
||||
rows = process_possibility_line(rows, &cell_ref.row);
|
||||
columns = process_possibility_line(columns, &cell_ref.column);
|
||||
sections = process_possibility_line(sections, &cell_ref.section);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if rows.is_invalid() & columns.is_invalid() & sections.is_invalid() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check each line and see if we can determine anything
|
||||
match rows {
|
||||
PossibilityLines::UNIQUE(index) => {
|
||||
remove_possibilities_line(grid.rows.get(index).unwrap(), possibility, &line.line_type, line.index);
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
match columns {
|
||||
PossibilityLines::UNIQUE(index) => {
|
||||
remove_possibilities_line(grid.columns.get(index).unwrap(), possibility, &line.line_type, line.index);
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
match sections {
|
||||
PossibilityLines::UNIQUE(index) => {
|
||||
remove_possibilities_line(grid.sections.get(index).unwrap(), possibility, &line.line_type, line.index);
|
||||
},
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// initial_line_type and initial_line_index are to identify the cells that should NOT have their possibilities removed
|
||||
fn remove_possibilities_line(line: &Rc<RefCell<Line>>, digit_to_remove: u8, initial_line_type: &LineType, initial_line_index: usize) {
|
||||
let line = &*(&**line).borrow();
|
||||
|
||||
for (_index, cell) in line.vec.iter().enumerate() {
|
||||
let new_value = {
|
||||
let value = &*cell.value.borrow();
|
||||
match value {
|
||||
CellValue::UNKNOWN(possibilities) => {
|
||||
let parent_line = match initial_line_type {
|
||||
LineType::ROW => &cell.row,
|
||||
LineType::COLUMN => &cell.column,
|
||||
LineType::SECTION => &cell.section
|
||||
};
|
||||
let parent_line = &*parent_line.upgrade().unwrap();
|
||||
let parent_line = &*parent_line.borrow();
|
||||
if parent_line.index == initial_line_index {
|
||||
// Don't want to apply to this cell
|
||||
continue;
|
||||
}
|
||||
|
||||
let new_possibilities = match possibilities.binary_search(&digit_to_remove) {
|
||||
Ok(x) => {
|
||||
let mut new_possibilities = possibilities.clone();
|
||||
new_possibilities.remove(x);
|
||||
new_possibilities
|
||||
},
|
||||
Err(_) => { continue; }
|
||||
};
|
||||
|
||||
let new_value;
|
||||
if new_possibilities.len() == 1 {
|
||||
new_value = CellValue::FIXED(new_possibilities.first().unwrap().clone());
|
||||
} else {
|
||||
new_value = CellValue::UNKNOWN(new_possibilities);
|
||||
}
|
||||
|
||||
new_value
|
||||
},
|
||||
_ => { continue; }
|
||||
}
|
||||
};
|
||||
|
||||
cell.set_value(new_value);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// We detected
|
||||
fn process_possibility_line(possibility_line: PossibilityLines, line: &Weak<RefCell<Line>>) -> PossibilityLines {
|
||||
let line = line.upgrade().unwrap();
|
||||
let line = &*(&*line).borrow();
|
||||
|
||||
match possibility_line {
|
||||
PossibilityLines::NONE => {PossibilityLines::UNIQUE(line.index)},
|
||||
PossibilityLines::INVALID => {possibility_line},
|
||||
PossibilityLines::UNIQUE(x) => {
|
||||
if line.index.eq(&x) {
|
||||
possibility_line
|
||||
} else {
|
||||
PossibilityLines::INVALID
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn solve_line(grid: &Grid, line: &Line){
|
||||
if DEBUG {
|
||||
println!("Solving {:?} {}", line.line_type, line.index);
|
||||
}
|
||||
|
||||
search_single_possibility(line);
|
||||
if DEBUG {
|
||||
grid.print();
|
||||
}
|
||||
|
||||
identify_and_process_possibility_groups(line);
|
||||
if DEBUG {
|
||||
grid.print();
|
||||
}
|
||||
|
||||
search_useful_constraint(grid, line);
|
||||
if DEBUG {
|
||||
grid.print();
|
||||
}
|
||||
|
||||
line.do_update.replace(false);
|
||||
}
|
||||
|
||||
fn solve_grid(grid: &Grid) {
|
||||
'outer: loop {
|
||||
for (_index, line_ref) in grid.rows.iter().enumerate() {
|
||||
//println!("Processing row {}", _index);
|
||||
let line_ref = &*(&**line_ref).borrow();
|
||||
if line_ref.do_update() {
|
||||
solve_line(&grid, line_ref);
|
||||
}
|
||||
}
|
||||
for (_index, line_ref) in grid.columns.iter().enumerate() {
|
||||
//println!("Processing column {}", _index);
|
||||
let line_ref = &*(&**line_ref).borrow();
|
||||
if line_ref.do_update() {
|
||||
solve_line(&grid, line_ref);
|
||||
}
|
||||
}
|
||||
for (_index, line_ref) in grid.sections.iter().enumerate() {
|
||||
//println!("Processing section {}", _index);
|
||||
let line_ref = &*(&**line_ref).borrow();
|
||||
if line_ref.do_update() {
|
||||
solve_line(&grid, line_ref);
|
||||
}
|
||||
}
|
||||
|
||||
// Check if complete or invalid
|
||||
let mut appears_complete = true;
|
||||
for x in 0..9 {
|
||||
for y in 0..9 {
|
||||
let cell = grid.get(x, y).unwrap();
|
||||
let cell = &*cell;
|
||||
let value = &**(&cell.value.borrow());
|
||||
|
||||
match value {
|
||||
CellValue::UNKNOWN(possibilities) => {
|
||||
appears_complete = false;
|
||||
if possibilities.len() == 0 {
|
||||
println!("Unable to find a solution");
|
||||
break 'outer;
|
||||
}
|
||||
},
|
||||
CellValue::FIXED(_) => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if appears_complete {
|
||||
break 'outer;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn main() {
|
||||
let grid = Grid::new();
|
||||
|
||||
|
|
@ -285,5 +846,115 @@ fn main() {
|
|||
grid.get(8, 3).unwrap().set(4);
|
||||
|
||||
grid.print();
|
||||
|
||||
println!("Now going to start a solver on it");
|
||||
|
||||
solve_grid(&grid);
|
||||
grid.print();
|
||||
println!("\n");
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_search_single_possibility(){
|
||||
let grid = Grid::new();
|
||||
|
||||
for i in 0..8 {
|
||||
grid.get(0, i).unwrap().set(i as u8 +1);
|
||||
}
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![9]), grid.get(0, 8).unwrap().get_value_copy());
|
||||
|
||||
let line = grid.rows.first().unwrap();
|
||||
let line = &*(**line).borrow();
|
||||
|
||||
search_single_possibility(line);
|
||||
|
||||
assert_eq!(CellValue::FIXED(9), grid.get(0, 8).unwrap().get_value_copy());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_identify_and_process_possibility_groups(){
|
||||
let grid = Grid::new();
|
||||
|
||||
// Fill up the first row with values, except for the first section
|
||||
for i in 3..6 {
|
||||
grid.get(0, i).unwrap().set(i as u8 +1);
|
||||
}
|
||||
grid.get(1, 6).unwrap().set(1);
|
||||
grid.get(1, 7).unwrap().set(2);
|
||||
grid.get(1, 8).unwrap().set(3);
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![1, 2, 3, 7, 8, 9]), grid.get(0, 0).unwrap().get_value_copy());
|
||||
|
||||
let line = grid.rows.first().unwrap();
|
||||
let line = &*(**line).borrow();
|
||||
|
||||
identify_and_process_possibility_groups(line);
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![1, 2, 3]), grid.get(0, 0).unwrap().get_value_copy());
|
||||
}
|
||||
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_search_useful_constraint_1(){
|
||||
let grid = Grid::new();
|
||||
|
||||
// Fill up the first row with values, except for the first section
|
||||
for i in 3..6 {
|
||||
grid.get(0, i).unwrap().set(i as u8 +1);
|
||||
}
|
||||
grid.get(1, 6).unwrap().set(1);
|
||||
grid.get(1, 7).unwrap().set(2);
|
||||
grid.get(1, 8).unwrap().set(3);
|
||||
|
||||
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![1, 2, 3, 4, 5, 6, 7, 8, 9]), grid.get(2, 0).unwrap().get_value_copy());
|
||||
|
||||
let line = grid.rows.first().unwrap();
|
||||
let line = &*(**line).borrow();
|
||||
|
||||
search_useful_constraint(&grid, line);
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![4, 5, 6, 7, 8, 9]), grid.get(2, 0).unwrap().get_value_copy());
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn test_search_useful_constraint_2(){
|
||||
let grid = Grid::new();
|
||||
|
||||
// These values come from a specific bug example where a constraint was incorrectly identified
|
||||
grid.get(3, 0).unwrap().set(8);
|
||||
grid.get(3, 1).unwrap().set(5);
|
||||
grid.get(3, 2).unwrap().set(2);
|
||||
grid.get(5, 1).unwrap().set(6);
|
||||
grid.get(6, 1).unwrap().set(8);
|
||||
grid.get(8, 2).unwrap().set(7);
|
||||
|
||||
grid.get(0, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 3, 4, 7, 9]));
|
||||
grid.get(1, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 3, 4, 5, 9]));
|
||||
grid.get(2, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 2]));
|
||||
grid.get(4, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 3, 4, 7]));
|
||||
grid.get(7, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 2, 3, 9]));
|
||||
grid.get(8, 1).unwrap().set_value(CellValue::UNKNOWN(vec![1, 2, 3, 5, 9]));
|
||||
|
||||
// 5 is wrongly removed here
|
||||
grid.get(1, 0).unwrap().set_value(CellValue::UNKNOWN(vec![1, 3, 4, 5, 9]));
|
||||
|
||||
grid.print();
|
||||
|
||||
let line = grid.columns.get(1).unwrap();
|
||||
let line = &*(**line).borrow();
|
||||
|
||||
search_useful_constraint(&grid, line);
|
||||
|
||||
assert_eq!(CellValue::UNKNOWN(vec![1, 3, 4, 5, 9]), grid.get(1, 0).unwrap().get_value_copy());
|
||||
|
||||
|
||||
|
||||
}
|
||||
Loading…
Reference in a new issue