private static void DumpBoard(Board board, string header, Cell highlightCell = null) { Console.WriteLine(header); var dump = board.GetDump(highlightCell); Console.WriteLine(dump); }
Board s(int num, Board b) { if (num > 81 || b.checkComplete()) { return b; } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (b.get(i, j) == 0) { for (int n = 1; n < 10; n++) { if (!existInRow(b, j, n) && !existInCol(b, i, n) && !existInZone(b, i, j, n)) { int[,] copy = (int[,])b.getArray().Clone(); b.set(i, j, n); Board tmp = s(num + 1, b); if (tmp != null) { return tmp; } else { b.set(copy); } } } return null; } } } return b; }
private static IEnumerable<Cell> GetColumnPositions(Board board, Cell value, int gx) { var result = from c in board where c.Value == value.Value && c.XSection == gx select c; return result.ToArray(); }
bool existInCol(Board b, int x, int val) { for (int i = 0; i < 9; i++) { if (b.get(x, i) == val) { return true; } } return false; }
bool existInRow(Board b, int y, int val) { for (int i = 0; i < 9; i++) { if (b.get(i, y) == val) { return true; } } return false; }
public static void Play(Board board) { var strategy = new GameEngine(); var bestEffort = strategy.Solve(board); if (bestEffort.IsSolved()) { Console.WriteLine("SOLVED!"); } else { Console.WriteLine("UNSOLVED."); } }
public Board(Board pBoard) { mPosValues = new bool[9, 9, 10]; mHeatMap = new int[9, 9]; for (int i = 0; i < 9; ++i) for (int j = 0; j < 9; ++j) { mHeatMap[i, j] = pBoard.mHeatMap[i, j]; for (int k = 0; k < 10; ++k) { mPosValues[i, j, k] = pBoard.mPosValues[i, j, k]; } } }
static void Main(string[] args) { Board b = new Board(n); StreamReader inputPuzzles; Square[] firstThree = new Square[3]; int sum = 0; inputPuzzles = new StreamReader("p096_sudoku.txt"); String temp, puzzleString; for (int currentPuzzle = 0; !inputPuzzles.EndOfStream; currentPuzzle++) { puzzleString = ""; temp = ""; temp = inputPuzzles.ReadLine(); while (!inputPuzzles.EndOfStream && !temp.StartsWith("G")) { puzzleString = puzzleString + temp; temp = inputPuzzles.ReadLine(); } if (puzzleString.Length > n) { b = new Board(3); b.setupBoardFromString(puzzleString); //b.showSquares(); b.completePuzzle(); Console.WriteLine(b.showSquares()); temp = ""; //Console.WriteLine(b.showSquares()); for (int index = 0; index < 3; index++) { if ((b.getSquares()[index].getValue() + 1) == 0) { Console.WriteLine(b.showSquares()); break; } temp = temp + (b.getSquares()[index].getValue() + 1); } //Console.WriteLine(temp); sum += int.Parse(temp); //Console.WriteLine(sum); // Console.ReadLine(); } } Console.WriteLine(sum); Console.ReadLine(); }
/* * IntersectionStrategy takes it this far: 9 8 3 2 7 1 9 8 5 4 8 2 7 4 6 9 2 9 1 3 7 >4< 5 2 5 6 1 4 8 7 3 5 4 * Take it further! (resolve that >4<) */ public Cell Solve(Board board) { // iterate over all numbers foreach (var cellValue in Cell.All) { // for each sub-grid for (var x = 0; x < Board.GridSize; x++) { for (var y = 0; y < Board.GridSize; y++) { // and search var values = board.GetGridCells (x,y); if (values.Contains(cellValue)) { continue; } // attempt solve this var availablePositions = board .GetGridCells(x, y) .Where(i => !i.IsAssigned()) .ToArray(); // check columns var adjacentColumnPositions = GetColumnPositions (board, cellValue, x); var adjacentRowPositions = GetRowPositions (board, cellValue, y); var candidates = availablePositions .ExcludeOn(adjacentColumnPositions, i => i.X) .ExcludeOn(adjacentRowPositions, i => i.Y) .ToArray(); if (candidates.Length == 1) { var target = candidates[0]; var move = target.Apply(cellValue); Statistics.NeighbouringNumbersStrategyMoves++; return move; } } } } // give up return null; }
bool existInZone(Board b, int x, int y, int val) { int[] zonesLimits = new int[] { 0, 0, 0, 3, 3, 3, 6, 6, 6 }; for (int i = zonesLimits[x]; i < zonesLimits[x] + 3; i++) { for (int j = zonesLimits[y]; j < zonesLimits[y] + 3; j++) { if (b.get(i, j) == val) { return true; } } } return false; }
private bool FindSolution(Board board, int index) { int row = index/SIZE, column = index%SIZE; if (index == SIZE*SIZE) return true; if (board.IsFilled(row, column)) return FindSolution(board, index+1); foreach(int value in board.GetOptionsForCell(row, column)) { board.SetCellValue(row, column, value); if (FindSolution(board, index+1)) return true; } board.ClearCell(row, column); return false; }
public Board Solve(Board board) { IStrategy strategy = new OverallStrategy(); bool success = true; Board currentBoard = board; DumpBoard(currentBoard, "Intial board:"); do { var move = strategy.Solve(currentBoard); success = (move != null); if (success) { var newBoard = currentBoard.Apply(move); // TODO: /* * var moves = strategy.GetSolutionSpace(board); * if (moves != null) * { * newBoard = moves.Aggregate(board, i => i == null : null ? i.Apply); * } */ // sanity-check var valid = newBoard.Validate(); if (!valid) { Console.WriteLine("ERROR! Board has been corrupted."); success = false; } else { currentBoard = newBoard; TotalMoves++; string msg = string.Format("Current board (Total {0} moves):", TotalMoves); DumpBoard(currentBoard, msg, move); } } } while (success); return currentBoard; }
public Cell Solve(Board board) { // results var solutions = from c in board where !c.IsAssigned() let cands = GetValueCandidates(board, c) where cands.Length == 1 let cand = cands.First() select c.Apply(cand); //var result = solutions.ToArray(); var result = solutions.FirstOrDefault(); if (result != null) { Statistics.IntersectonStrategyMoves ++; } return result; }
private void button1_Click(object sender, RoutedEventArgs e) { ShowMessage("Solving...",MessageType.Message); try { myboard.StringToInt(); } catch(Exception ex) { ShowMessage("Invalid Board, Please Check.", MessageType.Failure); return; } original = myboard.DeepClone(); try { bool test = myboard.IsValid(); watch.Start(); if (!Solve(myboard)) { watch.Stop(); myboard = original; MyBoard.ItemsSource = myboard.StringSpace; ShowMessage("Failed to find solution, time: " + watch.Elapsed.TotalSeconds, MessageType.Failure); } else { watch.Stop(); ShowMessage("Solved Already Silly!", MessageType.Warning); } watch.Reset(); } catch (System.ArgumentException ex) { MyBoard.ToString(); MyBoard.ItemsSource = myboard.StringSpace; MyBoard.Items.Refresh(); ShowMessage("Solved in: "+watch.Elapsed.TotalSeconds+ " seconds.",MessageType.Message); watch.Stop(); watch.Reset(); return; } }
public Cell Solve(Board board) { var strategies = new IStrategy[] { new IntersectionStrategy(), new NeighbouringNumbersStrategy(), new TentativeStrategy() }; foreach (var strategy in strategies) { var result = strategy.Solve(board); if (result != null) { return result; } } return null; }
public static Cell[] GetValueCandidates(Board board, Cell cell) { var columnValues = board.GetAssignedColumnCells(cell); var rowValues = board.GetAssignedRowCells(cell); var gridValues = board.GetGridCells(cell) .Where(i => i.IsAssigned()) .ToArray(); var all = Cell.All; // BUG: "all" keeps bad positional value, corrupting board. var missingColumnValues = all.Except(columnValues).ToArray(); var missingRowValues = all.Except(rowValues) .ToArray(); var missingGridValues = all.Except(gridValues) .ToArray(); var candidates = missingColumnValues .Intersect(missingRowValues) .Intersect(missingGridValues) .ToArray(); return candidates; }
private void button2_Click(object sender, RoutedEventArgs e) { myboard = new Board(); MyBoard.ItemsSource = myboard.StringSpace; ShowMessage("Board Reset",MessageType.Message); }
bool SolveComplete(Board board) { List<Board> sucessors = new System.Collections.Generic.List<Board>(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (board.spaces[i][j] == 0) { for (int r = 1; r < 10; r++) { board.SetSpace(r, i, j); if (board.IsSolved(i, j)) { watch.Stop(); Solved++; return true; } if (board.IsValid(i,j)) { sucessors.Add(board.DeepClone()); } } foreach (Board brd in sucessors) { SolveComplete(brd); } return false; } } } if (myboard.IsValid()) { return true; } return false; }
public Solver(Board board) { this.board = board; }
private bool Generate(Board board) { List<Board> sucessors = new System.Collections.Generic.List<Board>(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (board.spaces[i][j] == 0) { Random rand = new Random(); List<int> nums = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; while(nums.Count!=0) { int r = nums[rand.Next(0,nums.Count)]; nums.Remove(r); board.SetSpace(r, i, j); if (board.IsValid()) { sucessors.Add(board.DeepClone()); if (board.IsSolved(i, j)) { watch.Stop(); myboard = board.DeepClone(); throw new System.ArgumentException("Solved"); } } } foreach (Board brd in sucessors) { Generate(brd); } } } } if (myboard.IsValid()) { return true; } return false; }
private void RemoveSpaces(Board board) { List<Tuple<int, int>> Spaces = new List<Tuple<int, int>>(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { Spaces.Add(new Tuple<int, int>(i, j)); } } Random rand = new Random(); for (int i = 0; i < 81; i++) { int index = rand.Next(0, Spaces.Count); if (board.spaces[Spaces[index].Item1][Spaces[index].Item2] != 0) { int temp = board.spaces[Spaces[index].Item1][Spaces[index].Item2]; board.spaces[Spaces[index].Item1][Spaces[index].Item2] = 0; Removed++; Solved = 0; SolveComplete(board.DeepClone()); if (Solved == 1) { } if (Solved == 1 && Removed >= 50) { myboard = board.DeepClone(); throw new System.ArgumentException("Generated"); } else if (Solved == 1 && Removed < 50) { RemoveSpaces(board.DeepClone()); } board.spaces[Spaces[index].Item1][Spaces[index].Item2] = temp; Removed--; } Spaces.RemoveAt(index); } }
static void Main(string[] args) { // Initialise board Board b = new Board(); b.set(new int[,] { { 0,1,4, 2,0,0, 0,9,0}, { 0,2,0, 0,0,0, 0,0,3}, { 0,6,5, 0,8,0, 0,4,0}, { 0,0,8, 0,3,0, 0,0,0}, { 2,0,0, 5,0,7, 0,0,8}, { 0,0,0, 0,4,0, 6,0,0}, { 0,8,0, 0,2,0, 1,6,0}, { 4,0,0, 0,0,0, 0,5,0}, { 0,7,0, 0,0,5, 9,8,0} }); //b.set(new int[,] { // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0}, // { 0,0,0, 0,0,0, 0,0,0} }); //b.set(new int[,] //{ // { 0,6,1, 2,0,8, 3,0,9}, // { 0,0,0, 0,0,1, 4,0,2}, // { 0,0,2, 0,0,0, 6,0,0}, // { 6,2,0, 0,5,3, 0,0,4}, // { 5,0,0, 0,8,0, 0,0,6}, // { 1,0,0, 6,2,0, 0,7,3}, // { 0,0,4, 0,0,0, 7,0,0}, // { 8,0,6, 3,0,0, 0,0,0}, // { 3,0,5, 7,0,2, 9,6,0} //}); // Ask user for input string input = ""; int x = 0, y = 0, value = 0; string[] split; while (true) { Console.Clear(); b.render(); Console.WriteLine("Enter data in the format [x y value], or enter 0 to solve: "); input = Console.ReadLine(); split = input.Split(' '); if (split.Length == 3) { x = Int32.Parse(split[0]); y = Int32.Parse(split[1]); value = Int32.Parse(split[2]); b.set(x, y, value); } else if (input == "0") { break; } } // Attempt to solve sudoku Solver s = new Solver(b.copy()); Stopwatch watch = new Stopwatch(); watch.Start(); Board result = s.solve(); watch.Stop(); // Check complete if (result == null || !result.checkComplete()) { Console.WriteLine(":( Unable to solve."); } else { Console.Clear(); b.render(); Console.WriteLine("Solved! Time used " + watch.Elapsed.TotalMilliseconds + "ms. Here it is: "); result.render(); } }
private void button3_Click(object sender, RoutedEventArgs e) { Removed = 0; Solved = 0; myboard = new Board(); try { Generate(myboard); } catch (System.ArgumentException ex) { try { RemoveSpaces(myboard); } catch (System.ArgumentException ex2) { myboard.IntToString(); MyBoard.ItemsSource = myboard.StringSpace; } } }
/// <summary> /// Main create a board and tries to solve it /// </summary> /// <param name="args">Filename from the command line</param> public static void Main(string[] args) { if (args.Length > 0) { Board iniBoard = new Board(args[0]); // System.Console.WriteLine(iniBoard); if(solve(iniBoard) && !checkCompleteness(iniBoard)) { iniBoard = backTrack(iniBoard); } if (iniBoard != null) System.Console.Write(iniBoard); else System.Console.Write("Board is unsolvable"); // System.Console.Read(); } else { System.Console.WriteLine("Requires a file to read from"); } }
private void Guess() { //find a square with two possible values Console.WriteLine("Guessing!"); Square[] temp; Board branch; List<Square[]> permutations = new List<Square[]>(); for (int i = 0; i < n4; i++) { if (allSquares[i].getValue() != Square.NULL_VALUE) { foreach (int values in allSquares[i].GetPossibleValuesList()) { temp = new Square[n4]; Array.Copy(allSquares, temp, n4); temp[i].setValue(i); permutations.Add(temp); } } } foreach (Square[] sArr in permutations) { branch = new Board(n, sArr); branch.completePuzzle(); if (branch.isLegal() && branch.isComplete()) { allSquares = branch.allSquares; Console.WriteLine(showSquares() + "\n\n!!!!!!!"); Console.ReadLine(); } } }
private static Board backTrack(Board pBoard) { int coolestNode = pBoard.getLowestHeat(); int row = coolestNode / 9; int col = coolestNode % 9; Board copy = null; for (int i = 1; i < 10; ++i) { copy = pBoard.getCopy(); i = copy.getFirstVal(row, col, i); /* System.Console.WriteLine(copy); System.Console.WriteLine("+++++++++++++++++++++++++++++++++++++++++++++\n" + "row=" + row + " col=" + col + "val=" + i + "\n+++++++++++++++++++++++++++++++++++++++++++++\n"); System.Console.Read();*/ if (i < 10 && copy.update(row, col, i) && solve(copy)) if (checkCompleteness(copy)) return copy; else { copy = backTrack(copy); if (copy != null && checkCompleteness(copy)) return copy; } } return null; }
/// <summary> /// We want to know if we found a partial or complete solution /// </summary> /// <param name="pBoard">Board to check</param> /// <returns>Whether the Board is complete</returns> private static bool checkCompleteness(Board pBoard) { bool complete = true; for (int i = 0; i < 9 && complete; ++i) for (int j = 0; j < 9 && complete; ++j) { //The board is not complete if there is ever more than one possible value if (pBoard.getHeat(i, j) > 1) complete = false; } return complete; }
public Solver(Board board) { b = board; }
/// <summary> /// Attempts to solve the board /// </summary> /// <param name="pBoard">Board to be solved</param> /// <returns>Whether or not the board given is valid</returns> private static bool solve(Board pBoard) { bool update; bool valid = true; do { update = false; for (int i = 0; valid && i < 9; ++i) for (int j = 0; valid && j < 9; ++j) { //If there is only one option and it's not already locked in if (pBoard.getHeat(i, j) == 1 && !pBoard.isLocked(i, j)) { update = true; //Update the board valid = pBoard.update(i, j, pBoard.getFirstVal(i, j)); } } } while(update && valid); return valid; }
public Board getCopy() { Board copy = new Board(this); return copy; }