From c62b398c55999c9bb0da6c36d0929be0c0421075 Mon Sep 17 00:00:00 2001
From: sam-ayo <sam-ayo>
Date: Tue, 23 Jan 2024 18:02:03 -0330
Subject: [PATCH 1/2] working sudoku algorithm

---
 sudoku.go      | 63 +++++++++++++++++++++++++++++++++++++++++++++++++-
 sudoku_test.go | 63 +++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 124 insertions(+), 2 deletions(-)

diff --git a/sudoku.go b/sudoku.go
index 06ab7d0..0d8910b 100644
--- a/sudoku.go
+++ b/sudoku.go
@@ -1 +1,62 @@
-package main
+package sudoku
+
+
+const BOARD_SIZE = 9
+const SMALL_GRID_SIZE  = 3
+
+
+func isPossible(grid [][]int, row int, col int, n int) bool {
+	// Check to see if number is unique for row and column 
+	for i:=0; i<BOARD_SIZE; i++ {
+		if grid[row][i] == n || grid[i][col] == n {
+			return false
+		}
+	}
+	
+	offsetRow := (row/SMALL_GRID_SIZE)*SMALL_GRID_SIZE
+	offsetCol := (col/SMALL_GRID_SIZE)*SMALL_GRID_SIZE
+
+	// Check to see if number is unique for 3x3 subgrid
+	for i:=0; i<SMALL_GRID_SIZE; i++ {
+		for j:=0; j<SMALL_GRID_SIZE; j++ {
+			if grid[i+offsetRow][j+offsetCol] == n {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+func isSolved(grid [][]int, row int, col int) bool {
+	// Move along the board
+	if row == BOARD_SIZE {
+		row = 0
+		if col++; col == BOARD_SIZE {
+			return true
+		}
+	}
+
+	if grid[row][col] != 0 {
+		return isSolved(grid, row+1, col)
+	}
+
+	// try numbers from 1 - BOARD_SIZE and back track if bad choices have been made 
+	for n := 1; n <= BOARD_SIZE; n++ {
+		if isPossible(grid, row, col, n) {
+			grid[row][col] = n
+			if isSolved(grid, row+1, col) {
+				return true
+			}
+			grid[row][col] = 0
+		}
+	}
+	return false
+}
+
+
+func SolveSudoku(grid[][]int) [][]int {
+	// Assuming that we always get a valid sudoku board
+	isSolved(grid, 0, 0) 
+	return grid
+}
\ No newline at end of file
diff --git a/sudoku_test.go b/sudoku_test.go
index 63e3196..f3ec995 100644
--- a/sudoku_test.go
+++ b/sudoku_test.go
@@ -1,10 +1,71 @@
-package main
+package sudoku
 
 import (
 	"reflect"
 	"testing"
 )
 
+
+func TestIsPossible(t *testing.T) {
+	grid := [][]int{
+		{5, 3, 0, 0, 7, 0, 0, 0, 0},
+		{6, 0, 0, 1, 9, 5, 0, 0, 0},
+		{0, 9, 8, 0, 0, 0, 0, 6, 0},
+		{8, 0, 0, 0, 6, 0, 0, 0, 3},
+		{4, 0, 0, 8, 0, 3, 0, 0, 1},
+		{7, 0, 0, 0, 2, 0, 0, 0, 6},
+		{0, 6, 0, 0, 0, 0, 2, 8, 0},
+		{0, 0, 0, 4, 1, 9, 0, 0, 5},
+		{0, 0, 0, 0, 8, 0, 0, 7, 9},
+	}
+	result := isPossible(grid, 1, 1 , 1)
+	if result != false {
+		t.Errorf("Should not insert illegal number in grid")
+	}
+
+	result = isPossible(grid, 1, 1 , 4)
+	if result != true {
+		t.Errorf("Should be able to add legal number in the grid")	
+	}
+}
+
+func TestIsSolved(t *testing.T) {
+	input := [][]int{
+		{5, 3, 0, 0, 7, 0, 0, 0, 0},
+		{6, 0, 0, 1, 9, 5, 0, 0, 0},
+		{0, 9, 8, 0, 0, 0, 0, 6, 0},
+		{8, 0, 0, 0, 6, 0, 0, 0, 3},
+		{4, 0, 0, 8, 0, 3, 0, 0, 1},
+		{7, 0, 0, 0, 2, 0, 0, 0, 6},
+		{0, 6, 0, 0, 0, 0, 2, 8, 0},
+		{0, 0, 0, 4, 1, 9, 0, 0, 5},
+		{0, 0, 0, 0, 8, 0, 0, 7, 9},
+	}
+
+	result := isSolved(input, 0, 0)
+
+	if result != true {
+		t.Errorf("Bad sudoku algorithm")
+	}
+	
+	badInput := [][]int{
+		{5, 3, 0, 0, 7, 0, 0, 0, 0},
+		{6, 0, 0, 1, 9, 5, 0, 0, 0},
+		{0, 9, 8, 0, 0, 0, 0, 6, 0},
+		{8, 0, 0, 0, 6, 0, 0, 0, 3},
+		{4, 0, 0, 8, 0, 3, 0, 0, 1},
+		{7, 0, 0, 0, 2, 0, 0, 0, 6},
+		{0, 6, 0, 0, 0, 0, 2, 8, 0},
+		{0, 0, 0, 4, 1, 9, 0, 0, 1},
+		{0, 0, 0, 0, 8, 0, 0, 7, 9},
+	}
+	
+	result = isSolved(badInput, 0, 0)
+	if result != false {
+		t.Errorf("Bad sudoku board")
+	}
+}
+
 func TestSolveSudoku(t *testing.T) {
 	input := [][]int{
 		{5, 3, 0, 0, 7, 0, 0, 0, 0},

From 5cefd7fe914b1f673d90fd43f6a115bdb8b3310f Mon Sep 17 00:00:00 2001
From: sam-ayo <sam-ayo>
Date: Tue, 23 Jan 2024 18:33:36 -0330
Subject: [PATCH 2/2] commit all changes

---
 sudoku.go      | 27 ++++++++++++++++-----------
 sudoku_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 60 insertions(+), 17 deletions(-)

diff --git a/sudoku.go b/sudoku.go
index 0d8910b..b653289 100644
--- a/sudoku.go
+++ b/sudoku.go
@@ -28,24 +28,29 @@ func isPossible(grid [][]int, row int, col int, n int) bool {
 	return true
 }
 
-func isSolved(grid [][]int, row int, col int) bool {
-	// Move along the board
-	if row == BOARD_SIZE {
-		row = 0
-		if col++; col == BOARD_SIZE {
-			return true
+func findNextEmptyCell(grid [][]int) (int, int, bool) {
+	for i:=0; i<BOARD_SIZE; i++ {
+		for j:=0; j<BOARD_SIZE; j++ {
+			if grid[i][j] == 0{
+				return i, j, true
+			}
 		}
 	}
+	return -1, -1, false
+}
 
-	if grid[row][col] != 0 {
-		return isSolved(grid, row+1, col)
-	}
 
+func isSolved(grid [][]int) bool {
+	row, col, found := findNextEmptyCell(grid)
+	if !found {
+		return true
+	}
+	
 	// try numbers from 1 - BOARD_SIZE and back track if bad choices have been made 
 	for n := 1; n <= BOARD_SIZE; n++ {
 		if isPossible(grid, row, col, n) {
 			grid[row][col] = n
-			if isSolved(grid, row+1, col) {
+			if isSolved(grid) {
 				return true
 			}
 			grid[row][col] = 0
@@ -57,6 +62,6 @@ func isSolved(grid [][]int, row int, col int) bool {
 
 func SolveSudoku(grid[][]int) [][]int {
 	// Assuming that we always get a valid sudoku board
-	isSolved(grid, 0, 0) 
+	isSolved(grid)
 	return grid
 }
\ No newline at end of file
diff --git a/sudoku_test.go b/sudoku_test.go
index f3ec995..13c0353 100644
--- a/sudoku_test.go
+++ b/sudoku_test.go
@@ -20,12 +20,12 @@ func TestIsPossible(t *testing.T) {
 	}
 	result := isPossible(grid, 1, 1 , 1)
 	if result != false {
-		t.Errorf("Should not insert illegal number in grid")
+		t.Errorf("Should not insert illegal number in grid. Expected:\n%v\n\nGot:\n%v", false, result)
 	}
 
 	result = isPossible(grid, 1, 1 , 4)
 	if result != true {
-		t.Errorf("Should be able to add legal number in the grid")	
+		t.Errorf("Should be able to add legal number in the grid. Expected:\n%v\n\nGot:\n%v", true, result)
 	}
 }
 
@@ -42,10 +42,10 @@ func TestIsSolved(t *testing.T) {
 		{0, 0, 0, 0, 8, 0, 0, 7, 9},
 	}
 
-	result := isSolved(input, 0, 0)
+	result := isSolved(input)
 
 	if result != true {
-		t.Errorf("Bad sudoku algorithm")
+		t.Errorf("Bad sudoku algorithm. Expected:\n%v\n\nGot:\n%v", true, result)
 	}
 	
 	badInput := [][]int{
@@ -60,9 +60,47 @@ func TestIsSolved(t *testing.T) {
 		{0, 0, 0, 0, 8, 0, 0, 7, 9},
 	}
 	
-	result = isSolved(badInput, 0, 0)
+	result = isSolved(badInput)
 	if result != false {
-		t.Errorf("Bad sudoku board")
+		t.Errorf("Bad sudoku board. Expected:\n%v\n\nGot:\n%v", false, result)
+	}
+}
+
+func TestFindNextEmptyCell(t *testing.T) {
+	input := [][]int{
+		{5, 3, 0, 0, 7, 0, 0, 0, 0},
+		{6, 0, 0, 1, 9, 5, 0, 0, 0},
+		{0, 9, 8, 0, 0, 0, 0, 6, 0},
+		{8, 0, 0, 0, 6, 0, 0, 0, 3},
+		{4, 0, 0, 8, 0, 3, 0, 0, 1},
+		{7, 0, 0, 0, 2, 0, 0, 0, 6},
+		{0, 6, 0, 0, 0, 0, 2, 8, 0},
+		{0, 0, 0, 4, 1, 9, 0, 0, 5},
+		{0, 0, 0, 0, 8, 0, 0, 7, 9},
+	}
+	
+	i,j,found := findNextEmptyCell(input)
+
+	if i!=0 || j!=2 || found != true {
+		t.Errorf("Bad way to find next empty cell. \nExpected:\ni:%v, j:%v, found:%v \n\nGot:\ni:%v, j:%v, found:%v", 0, 2, true, i, j, found)
+	}
+
+	inputWithoutEmptyCells := [][]int{
+		{5, 3, 4, 6, 7, 8, 9, 1, 2},
+		{6, 7, 2, 1, 9, 5, 3, 4, 8},
+		{1, 9, 8, 3, 4, 2, 5, 6, 7},
+		{8, 5, 9, 7, 6, 1, 4, 2, 3},
+		{4, 2, 6, 8, 5, 3, 7, 9, 1},
+		{7, 1, 3, 9, 2, 4, 8, 5, 6},
+		{9, 6, 1, 5, 3, 7, 2, 8, 4},
+		{2, 8, 7, 4, 1, 9, 6, 3, 5},
+		{3, 4, 5, 2, 8, 6, 1, 7, 9},
+	}
+	
+	i,j, found = findNextEmptyCell(inputWithoutEmptyCells)
+
+	if i!=-1 || j!=-1 || found !=false {
+		t.Errorf("Bad way to find next empty cell. \nExpected:\ni:%v, j:%v, found:%v \n\nGot:\ni:%v, j:%v, found:%v", -1, -1, false, i, j, found)
 	}
 }