36. Valid Sudoku
Определите, является ли доска Судоку размером 9 на 9 валидной. Необходимо проверить только заполненные ячейки согласно следующим правилам:
Каждая stringa должна содержать цифры от 1 до 9 без повторений.
Каждый столбец должен содержать цифры от 1 до 9 без повторений.
Каждая из девяти подзон размером 3 на 3 в сетке должна содержать цифры от 1 до 9 без повторений.
Esempio:
Input: board =
[["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"]]
Output: true
C# soluzione
abbinato/originalepublic class Solution {
public bool IsValidSudoku(char[][] board) {
int N = 9;
HashSet<char>[] rows = new HashSet<char>[N];
HashSet<char>[] cols = new HashSet<char>[N];
HashSet<char>[] boxes = new HashSet<char>[N];
for (int r = 0; r < N; r++) {
rows[r] = new HashSet<char>();
cols[r] = new HashSet<char>();
boxes[r] = new HashSet<char>();
}
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
char val = board[r][c];
if (val == '.') {
continue;
}
if (rows[r].Contains(val)) {
return false;
}
rows[r].Add(val);
if (cols[c].Contains(val)) {
return false;
}
cols[c].Add(val);
int idx = (r / 3) * 3 + c / 3;
if (boxes[idx].Contains(val)) {
return false;
}
boxes[idx].Add(val);
}
}
return true;
}
}C++ soluzione
bozza automatica, rivedere prima dell'invio#include <bits/stdc++.h>
using namespace std;
// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
public bool IsValidSudoku(char[][] board) {
int N = 9;
HashSet<char>[] rows = new HashSet<char>[N];
HashSet<char>[] cols = new HashSet<char>[N];
HashSet<char>[] boxes = new HashSet<char>[N];
for (int r = 0; r < N; r++) {
rows[r] = new HashSet<char>();
cols[r] = new HashSet<char>();
boxes[r] = new HashSet<char>();
}
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
char val = board[r][c];
if (val == '.') {
continue;
}
if (rows[r].Contains(val)) {
return false;
}
rows[r].push_back(val);
if (cols[c].Contains(val)) {
return false;
}
cols[c].push_back(val);
int idx = (r / 3) * 3 + c / 3;
if (boxes[idx].Contains(val)) {
return false;
}
boxes[idx].push_back(val);
}
}
return true;
}
}Java soluzione
abbinato/originaleclass Solution {
public boolean isValidSudoku(char[][] board) {
int N = 9;
HashSet<Character>[] rows = new HashSet[N];
HashSet<Character>[] cols = new HashSet[N];
HashSet<Character>[] boxes = new HashSet[N];
for (int r = 0; r < N; r++) {
rows[r] = new HashSet<Character>();
cols[r] = new HashSet<Character>();
boxes[r] = new HashSet<Character>();
}
for (int r = 0; r < N; r++) {
for (int c = 0; c < N; c++) {
char val = board[r][c];
if (val == '.') {
continue;
}
if (rows[r].contains(val)) {
return false;
}
rows[r].add(val);
if (cols[c].contains(val)) {
return false;
}
cols[c].add(val);
int idx = (r / 3) * 3 + c / 3;
if (boxes[idx].contains(val)) {
return false;
}
boxes[idx].add(val);
}
}
return true;
}
}JavaScript soluzione
abbinato/originale/**
* @param {character[][]} board * @return {boolean}
*/var isValidSudoku = function(board) {
let rowMap = new Map(); let colmMap = new Map();
let grid33 = new Map();
for (let i = 0; i < 9; i++) {
for (let j = 0; j < 9; j++){ let m = board[3 * Math.floor(i / 3) + Math.floor(j / 3)][((i * 3) % 9) + (j % 3)]
if(!rowMap.get(board[i][j]) board[i][j] == '.' ) { rowMap.set(board[i][j], 1)
} else { return false}
if (!colmMap.get(board[j][i]) board[j][i] == '.' ) { colmMap.set(board[j][i], 1)
} else { return false}
if (!grid33.get(m) || m == '.'){ grid33.set(m, 1)
} else { return false}
} rowMap.clear();
grid33.clear(); colmMap.clear();
} return true
};Python soluzione
abbinato/originaleclass Solution:
def isValidSudoku(self, board: List[List[str]]) -> bool:
N = 9
rows = [set() for _ in range(N)]
cols = [set() for _ in range(N)]
boxes = [set() for _ in range(N)]
for r in range(N):
for c in range(N):
val = board[r][c]
if val == ".":
continue
if val in rows[r]:
return False
rows[r].add(val)
if val in cols[c]:
return False
cols[c].add(val)
idx = (r // 3) * 3 + c // 3
if val in boxes[idx]:
return False
boxes[idx].add(val)
return TrueGo soluzione
abbinato/originalefunc isValidSudoku(board [][]byte) bool {
N := 9
rows := make([]map[byte]bool, N)
cols := make([]map[byte]bool, N)
boxes := make([]map[byte]bool, N)
for i := 0; i < N; i++ {
rows[i] = make(map[byte]bool)
cols[i] = make(map[byte]bool)
boxes[i] = make(map[byte]bool)
}
for r := 0; r < N; r++ {
for c := 0; c < N; c++ {
val := board[r][c]
if val == '.' {
continue
}
if rows[r][val] {
return false
}
rows[r][val] = true
if cols[c][val] {
return false
}
cols[c][val] = true
idx := (r/3)*3 + c/3
if boxes[idx][val] {
return false
}
boxes[idx][val] = true
}
}
return true
}Algorithm
1️⃣
Инициализируйте список из 9 хеш-множеств, где хеш-множество с индексом r будет использоваться для хранения ранее увиденных чисел в строке r судоку. Аналогично инициализируйте списки из 9 хеш-множеств для отслеживания столбцов и блоков.
2️⃣
Итерируйтесь по каждой позиции (r, c) в судоку. На каждой итерации, если на текущей позиции есть number:
Проверьте, существует ли это number в хеш-множестве для текущей строки, столбца или блока. Если да, return false, потому что это второе появление числа в текущей строке, столбце или блоке.
3️⃣
В противном случае обновите множество, отвечающее за отслеживание ранее увиденных чисел в текущей строке, столбце и блоке. Индекс текущего блока рассчитывается как (r / 3) * 3 + (c / 3), где / означает деление нацело.
Если дубликаты не были найдены после посещения каждой позиции на доске судоку, то судоку валидно, поэтому return true.
😎
Vacancies for this task
offerte attive with overlapping task tags are mostrati.