Valid Sudoku

class Solution {
    public boolean isValidSudoku(char[][] board) {

        Set<String> seen = new HashSet<>();

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c == '.') continue;    // skip empty cells

                // Try to add all three constraints
                // If any add() returns false → duplicate!
                if (!seen.add(c + " in row " + i) ||
                    !seen.add(c + " in col " + j) ||
                    !seen.add(c + " in box " + i/3 + "-" + j/3))
                    return false;
            }
        }
        return true;
    }
}

func isValidSudoku(board [][]byte) bool {

    seen := make(map[string]bool)

    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            c := board[i][j]
            if c == '.' {
                continue              // skip empty cells
            }

            // Build keys for all three constraints
            rowKey := fmt.Sprintf("%c in row %d", c, i)
            colKey := fmt.Sprintf("%c in col %d", c, j)
            boxKey := fmt.Sprintf("%c in box %d-%d", c, i/3, j/3)

            if seen[rowKey] || seen[colKey] || seen[boxKey] {
                return false          // duplicate found
            }
            seen[rowKey] = true
            seen[colKey] = true
            seen[boxKey] = true
        }
    }
    return true
}

class Solution:
    def is_valid_sudoku(self, board: list[list[str]]) -> bool:

        seen: set[str] = set()

        for i in range(9):
            for j in range(9):
                c = board[i][j]
                if c == ".":
                    continue              # skip empty cells

                # Try to add all three constraints
                # If any key already exists → duplicate!
                row_key = f"{c} in row {i}"
                col_key = f"{c} in col {j}"
                box_key = f"{c} in box {i // 3}-{j // 3}"

                if row_key in seen or col_key in seen or box_key in seen:
                    return False
                seen.add(row_key)
                seen.add(col_key)
                seen.add(box_key)

        return True

use std::collections::HashSet;

impl Solution {
    pub fn is_valid_sudoku(board: Vec<Vec<char>>) -> bool {

        let mut seen: HashSet<String> = HashSet::new();

        for i in 0..9 {
            for j in 0..9 {
                let c = board[i][j];
                if c == '.' {
                    continue;             // skip empty cells
                }

                // Build keys for all three constraints
                let row_key = format!("{} in row {}", c, i);
                let col_key = format!("{} in col {}", c, j);
                let box_key = format!("{} in box {}-{}", c, i / 3, j / 3);

                if !seen.insert(row_key)
                    || !seen.insert(col_key)
                    || !seen.insert(box_key)
                {
                    return false;         // duplicate found
                }
            }
        }
        true
    }
}

function isValidSudoku(board: string[][]): boolean {

    const seen = new Set<string>();

    for (let i = 0; i < 9; i++) {
        for (let j = 0; j < 9; j++) {
            const c = board[i][j];
            if (c === ".") continue;    // skip empty cells

            // Try to add all three constraints
            // If set already has the key → duplicate!
            const rowKey = `${c} in row ${i}`;
            const colKey = `${c} in col ${j}`;
            const boxKey = `${c} in box ${Math.floor(i/3)}-${Math.floor(j/3)}`;

            if (seen.has(rowKey) || seen.has(colKey) || seen.has(boxKey))
                return false;
            seen.add(rowKey);
            seen.add(colKey);
            seen.add(boxKey);
        }
    }
    return true;
}