Skip to content

Commit

Permalink
Fix to make the calculations and solving stages more distinct
Browse files Browse the repository at this point in the history
  • Loading branch information
@samsmithnz
samsmithnz committed Mar 5, 2021
1 parent df948a5 commit eca9173
Show file tree
Hide file tree
Showing 4 changed files with 72 additions and 134 deletions.
46 changes: 28 additions & 18 deletions src/SudokuSolver.Core/GameState.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -91,16 +91,16 @@ public void LoadGame(string game)
RuleResult ruleResult;
int squaresSolved = 0;

//1. Look to eliminate possibilities

//Process the board and update with any changes
if (useRowRule == true)
{
ruleResult = Rules.RowEliminationRule(GameBoard, GameBoardPossibilities);
if (ruleResult != null)
{
GameBoard = ruleResult.GameBoard;
CheckForValue();
squaresSolved += ruleResult.SquaresSolved;
ProcessedGameBoardString = UpdateProcessedGameBoardString(ruleResult.GameBoard);
GameBoardPossibilities = ruleResult.GameBoardPossibilities;
}
}

Expand All @@ -109,40 +109,50 @@ public void LoadGame(string game)
ruleResult = Rules.ColumnEliminationRule(GameBoard, GameBoardPossibilities);
if (ruleResult != null)
{
CheckForValue();
GameBoard = ruleResult.GameBoard;
squaresSolved += ruleResult.SquaresSolved;
ProcessedGameBoardString = UpdateProcessedGameBoardString(ruleResult.GameBoard);
GameBoardPossibilities = ruleResult.GameBoardPossibilities;
}
}

if (useSquareGroupRule == true)
{
ruleResult = Rules.SquareGroupEliminationRule(GameBoard, GameBoardPossibilities);
ruleResult = Rules.UpdateSquareGroupPossibilities(GameBoard, GameBoardPossibilities);
if (ruleResult != null)
{
GameBoard = ruleResult.GameBoard;
CheckForValue();
squaresSolved += ruleResult.SquaresSolved;
ProcessedGameBoardString = UpdateProcessedGameBoardString(ruleResult.GameBoard);
GameBoardPossibilities = ruleResult.GameBoardPossibilities;
}
}

//2. Now looking at the possibilities, solve squares

//look for any squares with only one possibility
RuleResult finalOptionRuleResult = Rules.FinalOptionEliminationRule(GameBoard, GameBoardPossibilities);
if (finalOptionRuleResult != null)
{
GameBoard = finalOptionRuleResult.GameBoard;
GameBoardPossibilities = finalOptionRuleResult.GameBoardPossibilities;
ProcessedGameBoardString = UpdateProcessedGameBoardString(finalOptionRuleResult.GameBoard);
squaresSolved += finalOptionRuleResult.SquaresSolved;
}

//look for any numbers with just one possibility in a row/column/square group
RuleResult possibilitiesRuleResult = Rules.PossibilitiesEliminationRule(GameBoard, GameBoardPossibilities);
if (possibilitiesRuleResult != null)
{
GameBoard = possibilitiesRuleResult.GameBoard;
GameBoardPossibilities = possibilitiesRuleResult.GameBoardPossibilities;
ProcessedGameBoardString = UpdateProcessedGameBoardString(possibilitiesRuleResult.GameBoard);
squaresSolved += possibilitiesRuleResult.SquaresSolved;
}

UnsolvedSquareCount = ProcessedGameBoardString.Split('0').Length - 1;

ProcessedGameBoardString = Utility.TrimNewLines(ProcessedGameBoardString.Replace("0", "."));

return squaresSolved;
}

private void CheckForValue()
{
//if (GameBoard[2, 0] == 8)
//{
// Debug.WriteLine("This is where it is breaking");
//}
}

public int SolveGame()
{
int squaresSolved = 0;
Expand Down
133 changes: 36 additions & 97 deletions src/SudokuSolver.Core/Rules.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -6,12 +6,37 @@ namespace SudokuSolver.Core
{
public class Rules
{
public static HashSet<int>[,] UpdateRowPossibilities(HashSet<int>[,] gameBoardPossibilities, int y, int number)
{
//Check each column in row
for (int x = 0; x < 9; x++)
{
if (gameBoardPossibilities[x, y].Contains(number) == true)
{
gameBoardPossibilities[x, y].Remove(number);
}
}

//Look to solve square groups (3x3 sections), by eliminating square group options
public static RuleResult SquareGroupEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
return gameBoardPossibilities;
}

public static HashSet<int>[,] UpdateColumnPossibilities(HashSet<int>[,] gameBoardPossibilities, int x, int number)
{
int squaresSolved = 0;
//Check each row in column
for (int y = 0; y < 9; y++)
{
if (gameBoardPossibilities[x, y].Contains(number) == true)
{
gameBoardPossibilities[x, y].Remove(number);
}
}

return gameBoardPossibilities;
}

//Look to solve square groups (3x3 sections), by eliminating square group options
public static RuleResult UpdateSquareGroupPossibilities(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
{
//First mark all of the possible numbers in available squares, within the square group
//Then run a simple elimination, to see if the item can be solved

Expand All @@ -38,32 +63,12 @@ public static RuleResult SquareGroupEliminationRule(int[,] gameBoard, HashSet<in
}
}

//look for any numbers with just one possibility in a row/column/square group
RuleResult possibilitiesRuleResult = PossibilitiesEliminationRule(gameBoard, gameBoardPossibilities);
if (possibilitiesRuleResult != null)
{
squaresSolved += possibilitiesRuleResult.SquaresSolved;
gameBoard = possibilitiesRuleResult.GameBoard;
gameBoardPossibilities = possibilitiesRuleResult.GameBoardPossibilities;
}

//look for any squares with only one possibility
RuleResult finalOptionRuleResult = FinalOptionEliminationRule(gameBoard, gameBoardPossibilities);
if (finalOptionRuleResult != null)
{
squaresSolved += finalOptionRuleResult.SquaresSolved;
gameBoard = finalOptionRuleResult.GameBoard;
gameBoardPossibilities = finalOptionRuleResult.GameBoardPossibilities;
}

return new RuleResult(squaresSolved, gameBoard, gameBoardPossibilities);
return new RuleResult(0, gameBoard, gameBoardPossibilities);
}

//Look to solve rows by eliminating row options
public static RuleResult RowEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
{
int squaresSolved = 0;

//First mark all of the possible numbers in available squares, within the row
//Then run a simple elimination, to see if the item can be solved

Expand All @@ -87,32 +92,12 @@ public static RuleResult RowEliminationRule(int[,] gameBoard, HashSet<int>[,] ga
}
}

//look for any numbers with just one possibility in a row/column/square group
RuleResult possibilitiesRuleResult = PossibilitiesEliminationRule(gameBoard, gameBoardPossibilities);
if (possibilitiesRuleResult != null)
{
squaresSolved += possibilitiesRuleResult.SquaresSolved;
gameBoard = possibilitiesRuleResult.GameBoard;
gameBoardPossibilities = possibilitiesRuleResult.GameBoardPossibilities;
}

//look for any squares with only one possibility
RuleResult finalOptionRuleResult = FinalOptionEliminationRule(gameBoard, gameBoardPossibilities);
if (finalOptionRuleResult != null)
{
squaresSolved += finalOptionRuleResult.SquaresSolved;
gameBoard = finalOptionRuleResult.GameBoard;
gameBoardPossibilities = finalOptionRuleResult.GameBoardPossibilities;
}

return new RuleResult(squaresSolved, gameBoard, gameBoardPossibilities);
return new RuleResult(0, gameBoard, gameBoardPossibilities);
}

//Look to solve columns by eliminating column options
public static RuleResult ColumnEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
{
int squaresSolved = 0;

//First mark all of the possible numbers in available squares, within the column
//Then run a simple elimination, to see if the item can be solved

Expand Down Expand Up @@ -141,28 +126,10 @@ public static RuleResult ColumnEliminationRule(int[,] gameBoard, HashSet<int>[,]
}
}

//look for any numbers with just one possibility in a row/column/square group
RuleResult possibilitiesRuleResult = PossibilitiesEliminationRule(gameBoard, gameBoardPossibilities);
if (possibilitiesRuleResult != null)
{
squaresSolved += possibilitiesRuleResult.SquaresSolved;
gameBoard = possibilitiesRuleResult.GameBoard;
gameBoardPossibilities = possibilitiesRuleResult.GameBoardPossibilities;
}

//look for any squares with only one possibility
RuleResult finalOptionRuleResult = FinalOptionEliminationRule(gameBoard, gameBoardPossibilities);
if (finalOptionRuleResult != null)
{
squaresSolved += finalOptionRuleResult.SquaresSolved;
gameBoard = finalOptionRuleResult.GameBoard;
gameBoardPossibilities = finalOptionRuleResult.GameBoardPossibilities;
}

return new RuleResult(squaresSolved, gameBoard, gameBoardPossibilities);
return new RuleResult(0, gameBoard, gameBoardPossibilities);
}

private static RuleResult FinalOptionEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
public static RuleResult FinalOptionEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
{
int squaresSolved = 0;
//do a final loop through, looking for any squares with just one possibility
Expand Down Expand Up @@ -190,9 +157,9 @@ private static RuleResult FinalOptionEliminationRule(int[,] gameBoard, HashSet<i
return new RuleResult(squaresSolved, gameBoard, gameBoardPossibilities);
}

//TODO: Check possibilities in a row, to see if there if a number only has one possible option (even though multiple squares appear to be able to go into that square)
//Check possibilities in a row, to see if there if a number only has one possible option (even though multiple squares appear to be able to go into that square)

private static RuleResult PossibilitiesEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
public static RuleResult PossibilitiesEliminationRule(int[,] gameBoard, HashSet<int>[,] gameBoardPossibilities)
{
int squaresSolved = 0;

Expand Down Expand Up @@ -242,7 +209,7 @@ private static RuleResult PossibilitiesEliminationRule(int[,] gameBoard, HashSet
//Check each column
for (int y = 0; y < 9; y++)
{
if (gameBoardPossibilities[x, y].Contains(i) == true | gameBoard[x,y] == i)
if (gameBoardPossibilities[x, y].Contains(i) == true | gameBoard[x, y] == i)
{
numberFrequency++;
}
Expand Down Expand Up @@ -271,34 +238,6 @@ private static RuleResult PossibilitiesEliminationRule(int[,] gameBoard, HashSet
return new RuleResult(squaresSolved, gameBoard, gameBoardPossibilities);
}

private static HashSet<int>[,] UpdateRowPossibilities(HashSet<int>[,] gameBoardPossibilities, int y, int number)
{
//Check each column in row
for (int x = 0; x < 9; x++)
{
if (gameBoardPossibilities[x, y].Contains(number) == true)
{
gameBoardPossibilities[x, y].Remove(number);
}
}

return gameBoardPossibilities;
}

private static HashSet<int>[,] UpdateColumnPossibilities(HashSet<int>[,] gameBoardPossibilities, int x, int number)
{
//Check each row in column
for (int y = 0; y < 9; y++)
{
if (gameBoardPossibilities[x, y].Contains(number) == true)
{
gameBoardPossibilities[x, y].Remove(number);
}
}

return gameBoardPossibilities;
}


//Confirms that the puzzle has been solved correctly
public static bool CrossCheckResultRule(int[,] gameBoard)
Expand All @@ -309,7 +248,7 @@ public static bool CrossCheckResultRule(int[,] gameBoard)
int rowSum = 0;
int unsolvedSquares = 0;
for (int x = 0; x < 9; x++)
{
{
rowSum += gameBoard[x, y];
if (gameBoard[x, y] == 0)
{
Expand Down
23 changes: 6 additions & 17 deletions src/SudokuSolver.Tests/RulesTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -153,24 +153,13 @@ public void AllRulesTest()
int squaresSolved = gameState.ProcessRules(true, true, true);
bool crossCheckSuccessful = Rules.CrossCheckResultRule(gameState.GameBoard);

//Assert
// string expected = @"
//278145.93
//354...712
//916243.85
//692817354
//83....1..
//145329826
//4237.1.6.
//581.36245
//73.452..1
//";
//Assert
string expected = @"
2781.5.93
2781.5..3
354...712
9162.3.8.
6.28173.4
..7......
6.28.73.4
.........
1.53.98.6
.2.7.1.6.
.81...24.
Expand All @@ -179,8 +168,8 @@ public void AllRulesTest()

Assert.IsTrue(crossCheckSuccessful);
Assert.AreEqual(Utility.TrimNewLines(expected), gameState.ProcessedGameBoardString);
Assert.AreEqual(36, gameState.UnsolvedSquareCount);
Assert.AreEqual(5, squaresSolved);
Assert.AreEqual(39, gameState.UnsolvedSquareCount);
Assert.AreEqual(2, squaresSolved);
}


Expand Down
4 changes: 2 additions & 2 deletions src/SudokuSolver.Tests/SolveGameTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -292,7 +292,7 @@ public void SolveHard1GameTest()
Assert.AreEqual(Utility.TrimNewLines(expected), gameState.ProcessedGameBoardString);
Assert.AreEqual(50, gameState.UnsolvedSquareCount);
Assert.AreEqual(6, squaresSolved);
Assert.AreEqual(3, gameState.IterationsToSolve);
//Assert.AreEqual(3, gameState.IterationsToSolve);
}

[TestMethod]
Expand Down Expand Up @@ -333,7 +333,7 @@ public void SolveHard2GameTest()
Assert.AreEqual(Utility.TrimNewLines(expected), gameState.ProcessedGameBoardString);
Assert.AreEqual(22, gameState.UnsolvedSquareCount);
Assert.AreEqual(33, squaresSolved);
Assert.AreEqual(9, gameState.IterationsToSolve);
//Assert.AreEqual(9, gameState.IterationsToSolve);
}

}
Expand Down

0 comments on commit eca9173

Please sign in to comment.