[LeetCode]36. Valid Sudoku

Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

1. Each row must contain the digits 1-9 without repetition.

2. Each column must contain the digits 1-9 without repetition.

3. Each of the 9 3x3 sub-boxes of the grid must contain the digits 1-9 without repetition.

A partially filled sudoku which is valid.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.

Example 1:

Input:
[
  ["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

Example 2:

Input:
[
  ["8","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: false
Explanation: Same as Example 1, except with the 5 in the top left corner being 
    modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.

Note:

• A Sudoku board (partially filled) could be valid but is not necessarily solvable.

• Only the filled cells need to be validated according to the mentioned rules.

• The given board contain only digits 1-9 and the character '.'.

• The given board size is always 9x9.

Analyse:

​

Solution:

class Solution {
    
    func isValidSudoku(_ board: [[Character]]) -> Bool {
        for i in 0..<board.count {
            let isValid = self.checkIsSudoku(i1: i, i2: i + 1, j1:0, j2:board[i].count, board);
            
            if(isValid == false) {
                return false;
            }
        }
        
        for i in 0..<board[0].count {
            let isValid = self.checkIsSudoku(i1: 0, i2: board.count, j1:i, j2:i + 1, board);
            if(isValid == false) {
                return false;
            }
        }
        
        for i in 0..<3 {
            for j in 0..<3 
            {
                let isValid = self.checkIsSudoku(i1: i * 3, i2: i * 3 + 3, j1: j * 3, j2: j * 3 + 3, board);
                if(isValid == false) {
                    return false;
                }
            }
        }
        
        return true;
    }
     
    func checkIsSudoku(i1: Int, i2: Int, j1:Int, j2:Int, _ board: [[Character]]) -> Bool {
        var array:[Character] = [];
        
        for i in i1..<i2 {
            for j in j1..<j2 {
                let value = board[i][j];
                
                if(value == ".") {
                    continue;
                }
                  
                if(array.index(of: value) != nil) {
                    // print("\(value), \(array.index(of: value))");
                    return false;
                }
                else {
                    array.append(value);
                }
            }
        }
        
        return true;
    }
}

Solution2:

class Solution {
    func isValidSudoku(_ board: [[Character]]) -> Bool {
        
        for i in 0..<board.count {
            var hlist: [Character: Int] = [:]
            
            for j in 0..<board.count {
                let hValue = board[i][j]
                
                if(hValue == ".") {
                    continue
                }
                
                if(hlist[hValue] != nil) {
                    return false
                }
                
                hlist[hValue] = j
            } 
        }
        
        for i in 0..<board.count {

            var vlist: [Character: Int] = [:]
            
            for j in 0..<board.count {

                let vValue = board[j][i]
                
                if(vValue == ".") {
                    continue
                }
                
                if(vlist[vValue] != nil) {
                    return false
                }
                
                vlist[vValue] = j
            } 
        }
        
        var i = 0
        while(i < board.count) {
            var j = 0
            
            while(j < board.count) {
            
                var list: [Character: Int] = [:]
                for k in 0..<3 {
                    for n in 0..<3 {
                        let value = board[i + k][j + n]
                        if(value == ".") {
                            continue
                        }
                        
                        if(list[value] != nil) {
                            return false
                        }     
                        
                        list[value] = i
                    }
                }
                
                j += 3
            }
            
            i += 3
        }
        
        return true
    }
}