36. Valid Sudoku

https://leetcode.com/problems/valid-sudoku/

C++

class Solution {
public:
    bool isValidSudoku(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            if (!valid(board[i])) {
                return false;
            }
        }

        vector<char> nums;
        for (int i = 0; i < 9; i++) {
            nums.clear();
            for (int j = 0; j < 9; j++) {
                nums.push_back(board[j][i]);
            }
            if (!valid(nums)) {
                return false;
            }
        }

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                nums.clear();
                nums.insert(nums.end(), board[j*3].begin()+i*3, board[j*3].begin()+i*3+3);
                nums.insert(nums.end(), board[j*3+1].begin()+i*3, board[j*3+1].begin()+i*3+3);
                nums.insert(nums.end(), board[j*3+2].begin()+i*3, board[j*3+2].begin()+i*3+3);
                if (!valid(nums)) {
                    return false;
                }
            }
        }

        return true;
    }

    bool valid(vector<char>& nums) {
        unordered_map<char, bool> m;
        for (auto& c : nums) {
            if (c == '.') {
                continue;
            }
            if (m.find(c) != m.end()) {
                return false;
            }
            m[c] = true;
        }
        return true;
    }
};

Go

func isValidSudoku(board [][]byte) bool {
    for i := 0; i < 9; i++ {
        if !valid(board[i]) {
            return false
        }
    }

    for i := 0; i < 9; i++ {
        var nums []byte
        for j := 0; j < 9; j++ {
            nums = append(nums, board[j][i])
        }
        if !valid(nums) {
            return false
        }
    }

    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            var nums []byte
            nums = append(nums, board[j*3][i*3:i*3+3]...)
            nums = append(nums, board[j*3+1][i*3:i*3+3]...)
            nums = append(nums, board[j*3+2][i*3:i*3+3]...)
            if !valid(nums) {
                return false
            }
        }
    }

    return true
}

func valid(nums []byte) bool {
    var m = make(map[byte]bool)
    for _, num := range nums {
        if num == '.' {
            continue
        }
        if _, ok := m[num]; ok {
            return false
        }
        m[num] = true
    }
    return true
}

JavaScript

/**
 * @param {character[][]} board
 * @return {boolean}
 */
var isValidSudoku = function(board) {
  function valid(nums) {
    nums = nums.filter(x => x !== '.')
    return new Set(nums).size === nums.length
  }

  for (let i = 0; i < 9; i++) {
    if (!valid(board[i])) {
      return false
    }
  }

  for (let i = 0; i < 9; i++) {
    let nums = []
    for (let j = 0; j < 9; j++) {
      nums.push(board[j][i])
    }
    if (!valid(nums)) {
      return false
    }
  }

  for (let i = 0; i < 3; i++) {
    for (let j = 0; j < 3; j++) {
      let nums = board[j * 3].slice(i * 3, i * 3 + 3)
        .concat(board[j * 3 + 1].slice(i * 3, i * 3 + 3))
        .concat(board[j * 3 + 2].slice(i * 3, i * 3 + 3))
      if (!valid(nums)) {
        return false
      }
    }
  }

  return true
}

Python

class Solution(object):

    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        for i in range(9):
            if not self.valid([board[i][j] for j in range(9)]) or not self.valid([board[j][i] for j in range(9)]):
                return False

        for i in range(3):
            for j in range(3):
                if not self.valid([board[m][n] for n in range(3 * j, 3 * j + 3) for m in range(3 * i, 3 * i + 3)]):
                    return False

        return True

    def valid(self, nums):
        nums = filter(lambda x: x != '.', nums)
        return len(set(nums)) == len(nums)