solution for valid sudoku

Author: javydevx

1_arrays_and_hashing/8_valid_sudoku/solution.go

@@ -0,0 +1,111 @@
+package validsudoku
+
+// Time complexity: O(1) - The board size is fixed at 9x9, so the operations are constant time.
+// Space complexity: O(1) - No additional space is used that scales with input size.
+func IsValidSudokuBruteForce(board [][]byte) bool {
+	check := func(nums []byte) bool {
+		count := [9]int{}
+		for _, ch := range nums {
+			if ch != '.' {
+				idx := ch - '1'
+				if count[idx] > 0 {
+					return false
+				}
+				count[idx]++
+			}
+		}
+		return true
+	}
+
+	// Check rows
+	for i := 0; i < 9; i++ {
+		if !check(board[i]) {
+			return false
+		}
+	}
+
+	// Check columns
+	for j := 0; j < 9; j++ {
+		col := make([]byte, 9)
+		for i := 0; i < 9; i++ {
+			col[i] = board[i][j]
+		}
+		if !check(col) {
+			return false
+		}
+	}
+
+	// Check 3x3 sub-boxes
+	for boxRow := 0; boxRow < 3; boxRow++ {
+		for boxCol := 0; boxCol < 3; boxCol++ {
+			box := make([]byte, 0, 9)
+			for i := 0; i < 3; i++ {
+				for j := 0; j < 3; j++ {
+					box = append(box, board[boxRow*3+i][boxCol*3+j])
+				}
+			}
+			if !check(box) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Time complexity: O(1) - The board size is fixed at 9x9, so the operations are constant time.
+// Space complexity: O(1) - No additional space is used that scales with input size.
+func IsValidSudokuHashSet(board [][]byte) bool {
+	rows := [9]map[byte]bool{}
+	cols := [9]map[byte]bool{}
+	boxes := [9]map[byte]bool{}
+
+	for i := range rows {
+		rows[i] = map[byte]bool{}
+		cols[i] = map[byte]bool{}
+		boxes[i] = map[byte]bool{}
+	}
+
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			val := board[i][j]
+			if val == '.' {
+				continue
+			}
+			boxIdx := (i/3)*3 + j/3
+
+			if rows[i][val] || cols[j][val] || boxes[boxIdx][val] {
+				return false
+			}
+			rows[i][val] = true
+			cols[j][val] = true
+			boxes[boxIdx][val] = true
+		}
+	}
+	return true
+}
+
+// Time complexity: O(1) - The board size is fixed at 9x9, so the operations are constant time.
+// Space complexity: O(1) - No additional space is used that scales with input size.
+func IsValidSudokuBitMask(board [][]byte) bool {
+	var rows, cols, boxes [9]int
+
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			val := board[i][j]
+			if val == '.' {
+				continue
+			}
+			bit := 1 << (val - '1')
+			boxIdx := (i/3)*3 + j/3
+
+			if (rows[i]&bit) != 0 || (cols[j]&bit) != 0 || (boxes[boxIdx]&bit) != 0 {
+				return false
+			}
+
+			rows[i] |= bit
+			cols[j] |= bit
+			boxes[boxIdx] |= bit
+		}
+	}
+	return true
+}

1_arrays_and_hashing/8_valid_sudoku/solution_test.go

@@ -0,0 +1,95 @@
+package validsudoku
+
+import "testing"
+
+func TestIsValidSudoku(t *testing.T) {
+	cases := []struct {
+		name     string
+		fn       func([][]byte) bool
+		board    [][]byte
+		expected bool
+	}{
+		// IsValidSudokuBruteForce
+		{"Brute Force - Valid", IsValidSudokuBruteForce, validSudokuBoard(), true},
+		{"Brute Force - Invalid Row", IsValidSudokuBruteForce, invalidRowSudokuBoard(), false},
+		{"Brute Force - Invalid Column Only", IsValidSudokuBruteForce, invalidColOnlySudokuBoard(), false},
+		{"Brute Force - Invalid Box Only", IsValidSudokuBruteForce, invalidBoxOnlySudokuBoard(), false},
+
+		// IsValidSudokuHashSet - can use original or new ones, HashSet checks "all at once"
+		{"Hash Set - Valid", IsValidSudokuHashSet, validSudokuBoard(), true},
+		{"Hash Set - Invalid Row", IsValidSudokuHashSet, invalidRowSudokuBoard(), false},
+		{"Hash Set - Invalid Column", IsValidSudokuHashSet, originalInvalidColSudokuBoard(), false}, // or invalidColOnlySudokuBoard()
+		{"Hash Set - Invalid Box", IsValidSudokuHashSet, originalInvalidBoxSudokuBoard(), false},    // or invalidBoxOnlySudokuBoard()
+
+		// IsValidSudokuBitMask - similar to HashSet
+		{"BitMask - Valid", IsValidSudokuBitMask, validSudokuBoard(), true},
+		{"BitMask - Invalid Row", IsValidSudokuBitMask, invalidRowSudokuBoard(), false},
+		{"BitMask - Invalid Column", IsValidSudokuBitMask, originalInvalidColSudokuBoard(), false}, // or invalidColOnlySudokuBoard()
+		{"BitMask - Invalid Box", IsValidSudokuBitMask, originalInvalidBoxSudokuBoard(), false},    // or invalidBoxOnlySudokuBoard()
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got := c.fn(c.board)
+			if got != c.expected {
+				t.Errorf("%s failed: expected %v, got %v for board:\n%v", c.name, c.expected, got, boardToString(c.board))
+			}
+		})
+	}
+}
+
+// Helper to print board for easier debugging
+func boardToString(board [][]byte) string {
+	s := ""
+	for i := 0; i < 9; i++ {
+		for j := 0; j < 9; j++ {
+			s += string(board[i][j]) + " "
+		}
+		s += "\n"
+	}
+	return s
+}
+
+func validSudokuBoard() [][]byte {
+	return [][]byte{
+		{'5', '3', '.', '.', '7', '.', '.', '.', '.'},
+		{'6', '.', '.', '1', '9', '5', '.', '.', '.'},
+		{'.', '9', '8', '.', '.', '.', '.', '6', '.'},
+		{'8', '.', '.', '.', '6', '.', '.', '.', '3'},
+		{'4', '.', '.', '8', '.', '3', '.', '.', '1'},
+		{'7', '.', '.', '.', '2', '.', '.', '.', '6'},
+		{'.', '6', '.', '.', '.', '.', '2', '8', '.'},
+		{'.', '.', '.', '4', '1', '9', '.', '.', '5'},
+		{'.', '.', '.', '.', '8', '.', '.', '7', '9'},
+	}
+}
+
+func invalidRowSudokuBoard() [][]byte {
+	board := validSudokuBoard()
+	board[0][1] = '5' // Duplicate 5 in first row
+	return board
+}
+
+func invalidColOnlySudokuBoard() [][]byte {
+	board := validSudokuBoard()
+	board[1][0] = '8' // Col 0: 5,8,.,8,... (invalid); Row 1: 8,.,.,1,9,5,... (valid)
+	return board
+}
+
+func invalidBoxOnlySudokuBoard() [][]byte {
+	board := validSudokuBoard()
+	board[1][1] = '8' // Box 0,0: contains two '8's; Row 1 and Col 1 remain valid
+	return board
+}
+
+func originalInvalidColSudokuBoard() [][]byte {
+	board := validSudokuBoard()
+	board[1][0] = '5'
+	return board
+}
+
+func originalInvalidBoxSudokuBoard() [][]byte {
+	board := validSudokuBoard()
+	board[1][1] = '9'
+	return board
+}