Судоку

public class Solution
{
    public static bool IsValidSudoku(List<List<char>> board)
    {
        // храним пару (номер строки, значение)
        var rows = new HashSet<string>();
        var cols = new HashSet<string>();
        var blocks = new HashSet<string>();

        for (int i = 0; i < 9; ++i)
        {
            for (int j = 0; j < 9; ++j)
            {
                char val = board[i][j];
                if (val == '.')
                {
                    continue;
                }
                int blockIdx = (i / 3) * 3 + (j / 3);

                // создаем строки для каждой проверки: строка, колонка и блок
                string rowKey = "row" + i + val;
                string colKey = "col" + j + val;
                string blockKey = "block" + blockIdx + val;

                // если у нас уже есть такой элемент в строке/столбце/блоке
                // значит невалидное судоку
                if (rows.Contains(rowKey) || cols.Contains(colKey) || blocks.Contains(blockKey))
                {
                    return false;
                }

                // добавляем комбинации строка/колонка/блок в соответствующие множества
                rows.Add(rowKey);
                cols.Add(colKey);
                blocks.Add(blockKey);
            }
        }
        return true;
    }
}

#include <vector>
#include <unordered_set>
#include <string>

using namespace std;

bool isValidSudoku(const vector<vector<char>>& board) {
    // храним пару (номер строки, значение)
    unordered_set<string> rows, cols, blocks;

    for (int i = 0; i < 9; ++i) {
        for (int j = 0; j < 9; ++j) {
            char val = board[i][j];
            if (val == '.') {
                continue;
            }
            int blockIdx = (i / 3) * 3 + (j / 3);

            // создаем строки для каждой проверки: строка, колонка и блок
            string rowKey = "row" + to_string(i) + val;
            string colKey = "col" + to_string(j) + val;
            string blockKey = "block" + to_string(blockIdx) + val;

            // если у нас уже есть такой элемент в строке/столбце/блоке
            // значит невалидное судоку
            if (rows.count(rowKey) || cols.count(colKey) || blocks.count(blockKey)) {
                return false;
            }

            // добавляем комбинации строка/колонка/блок в соответствующие множества
            rows.insert(rowKey);
            cols.insert(colKey);
            blocks.insert(blockKey);
        }
    }
    return true;
}

package main;

func isValidSudoku(board [][]rune) bool {
    // храним пару (номер строки, значение)
    rows := make(map[[2]int]struct{})
    // храним пару (номер колонки, значение)
    cols := make(map[[2]int]struct{})
    // храним пару (номер блока, значение)
    blocks := make(map[[2]int]struct{})

    for i := 0; i < 9; i++ {
        for j := 0; j < 9; j++ {
            val := board[i][j]
            if val == '.' {
                continue
            }
            blockIdx := (i / 3) * 3 + (j / 3)
            // если у нас уже есть такой элемент в строке/столбце/блоке
            // значит невалидное судоку
            if _, found := rows[[2]int{i, int(val)}]; found {
                return false
            }
            if _, found := cols[[2]int{j, int(val)}]; found {
                return false
            }
            if _, found := blocks[[2]int{blockIdx, int(val)}]; found {
                return false
            }
            rows[[2]int{i, int(val)}] = struct{}{}
            cols[[2]int{j, int(val)}] = struct{}{}
            blocks[[2]int{blockIdx, int(val)}] = struct{}{}
        }
    }
    return true
}

import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Solution {
    public boolean isValidSudoku(List<List<Character>> board) {
        // храним пару (номер строки, значение)
        Set<String> rows = new HashSet<>();
        // храним пару (номер колонки, значение)
        Set<String> cols = new HashSet<>();
        // храним пару (номер блока, значение)
        Set<String> blocks = new HashSet<>();

        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char val = board.get(i).get(j);
                if (val == '.') {
                    continue;
                }
                int blockIdx = (i / 3) * 3 + (j / 3);
                // если у нас уже есть такой элемент в строке/столбце/блоке
                // значит невалидное судоку
                if (!rows.add("row" + i + val) || !cols.add("col" + j + val) || !blocks.add("block" + blockIdx + val)) {
                    return false;
                }
            }
        }
        return true;
    }
}

from typing import *

def is_valid_sudoku(board: List[List[str]]) -> bool:
    # храним пару (номер строки, значение)
    rows = set()
    # храним пару (номер колонки, значение)
    cols = set()
    # храним пару (номер блока, значение)
    blocks = set()
    for i in range(len(board)):
        for j in range(len(board[0])):
            val = board[i][j]
            if val == ".":
                continue
            blockIdx = i // 3 * 3 + j //3
            # если у нас уже есть такой элемент в строке/столбце/блоке
            # значит невалидное судоку
            if (i, val) in rows or (j, val) in cols or (blockIdx, val) in blocks:
                return False
            rows.add((i, val))
            cols.add((j, val))
            blocks.add((blockIdx, val))
    return True

export function isValidSudoku(board) {
    // храним пару (номер строки, значение)
    const rows = new Set();
    // храним пару (номер колонки, значение)
    const cols = new Set();
    // храним пару (номер блока, значение)
    const blocks = new Set();

    for (let i = 0; i < board.length; i++) {
        for (let j = 0; j < board[0].length; j++) {
            const val = board[i][j];
            if (val === ".") {
                continue;
            }
            const blockIdx = Math.floor(i / 3) * 3 + Math.floor(j / 3);

            // если у нас уже есть такой элемент в строке/столбце/блоке
            // значит невалидное судоку
            if (rows.has(`${i}-${val}`) || cols.has(`${j}-${val}`) || blocks.has(`${blockIdx}-${val}`)) {
                return false;
            }

            rows.add(`${i}-${val}`);
            cols.add(`${j}-${val}`);
            blocks.add(`${blockIdx}-${val}`);
        }
    }

    return true;
}