add 037 039 040 046 047 500 57 617 728

zongyanqi · zongyanqi · commit 3fd0aebc41b0 · 2018-01-05T17:05:53.000+08:00
diff --git a/037-Sudoku-Solver.js b/037-Sudoku-Solver.js
@@ -0,0 +1,88 @@
+/**
+ * https://leetcode.com/problems/sudoku-solver/description/
+ * Difficulty:Hard
+ *
+ * Write a program to solve a Sudoku puzzle by filling the empty cells.
+ * Empty cells are indicated by the character '.'.
+ * You may assume that there will be only one unique solution.
+ */
+
+/**
+ * @param {character[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+var solveSudoku = function (board) {
+    solve(board);
+    console.log(board);
+};
+
+function solve(board) {
+    for (var i = 0; i < 9; i++) {
+        for (var j = 0; j < 9; j++) {
+            var ch = board[i][j];
+            if (ch === '.') {
+                for (var k = 1; k <= 9; k++) {
+
+                    if (isValid(i, j, board, '' + k)) {
+
+                        board[i][j] = '' + k;
+                        // console.log(board);
+                        // console.log('-------------');
+                        if (solve(board)) {
+                            // console.log(board);
+                            // console.log('-------------');
+                            return true;
+                        } else {
+                            board[i][j] = '.';
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+function isValid(row, col, board, t) {
+
+    for (var i = 0; i < 9; i++) {
+        var ch = board[row][i];
+        if (ch === t) return false;
+
+        ch = board[i][col];
+        if (ch === t) return false;
+
+        ch = board[Math.floor(row / 3) * 3 + Math.floor(i / 3)][Math.floor(col / 3) * 3 + i % 3];
+        // if (row === 0 && col === 8) {
+        //     console.log('~ ', Math.floor(row / 3) * 3 + Math.floor(i / 3), Math.floor(row / 3) * 3 + i % 3, ch);
+        // }
+        if (ch === t) return false;
+    }
+    return true;
+
+}
+
+console.log(solveSudoku([
+    [".", ".", "9", "7", "4", "8", ".", ".", "."],
+    ["7", ".", ".", ".", ".", ".", ".", ".", "."],
+    [".", "2", ".", "1", ".", "9", ".", ".", "."],
+    [".", ".", "7", ".", ".", ".", "2", "4", "."],
+    [".", "6", "4", ".", "1", ".", "5", "9", "."],
+    [".", "9", "8", ".", ".", ".", "3", ".", "."],
+    [".", ".", ".", "8", ".", "3", ".", "2", "."],
+    [".", ".", ".", ".", ".", ".", ".", ".", "6"],
+    [".", ".", ".", "2", "7", "5", "9", ".", "."]
+]));
+
+console.log([
+    ["5", "1", "9", "7", "4", "8", "6", "3", "2"],
+    ["7", "8", "3", "6", "5", "2", "4", "1", "9"],
+    ["4", "2", "6", "1", "3", "9", "8", "7", "5"],
+    ["3", "5", "7", "9", "8", "6", "2", "4", "1"],
+    ["2", "6", "4", "3", "1", "7", "5", "9", "8"],
+    ["1", "9", "8", "5", "2", "4", "3", "6", "7"],
+    ["9", "7", "5", "8", "6", "3", "1", "2", "4"],
+    ["8", "3", "2", "4", "9", "1", "7", "5", "6"],
+    ["6", "4", "1", "2", "7", "5", "9", "8", "3"]
+])
diff --git a/039-Combination-Sum.js b/039-Combination-Sum.js
@@ -0,0 +1,50 @@
+/**
+ * https://leetcode.com/problems/combination-sum/description/
+ * Difficulty:Medium
+ *
+ * Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
+ * The same repeated number may be chosen from C unlimited number of times.
+ * Note:
+ * All numbers (including target) will be positive integers.
+ * The solution set must not contain duplicate combinations.
+ * For example, given candidate set [2, 3, 6, 7] and target 7,
+ * A solution set is:
+ * [
+ *  [7],
+ *  [2, 2, 3]
+ * ]
+ */
+
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum = function (candidates, target) {
+
+    var res = [];
+    var temp = [];
+    helper(res, temp, candidates, target, 0);
+    return res;
+
+};
+
+function helper(res, temp, candidates, target, start) {
+
+    if (target === 0) {
+        res.push([...temp]);
+        return;
+    }
+
+    for (var i = start; i < candidates.length; i++) {
+        if (candidates[i] <= target) {
+            temp.push(candidates[i]);
+            helper(res, temp, candidates, target - candidates[i], i);
+            temp.length -= 1;
+        }
+
+    }
+}
+
+console.log(combinationSum([1, 2, 3, 5, 6, 7], 7));
+console.log(combinationSum([7, 2, 3, 5, 6, 1], 7));
diff --git a/040-Combination-Sum-II.js b/040-Combination-Sum-II.js
@@ -0,0 +1,45 @@
+/**
+ * Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.
+ * Each number in C may only be used once in the combination.
+ * Note:
+ * All numbers (including target) will be positive integers.
+ * The solution set must not contain duplicate combinations.
+ * For example, given candidate set [10, 1, 2, 7, 6, 1, 5] and target 8,
+ * A solution set is:
+ * [
+ *  [1, 7],
+ *  [1, 2, 5],
+ *  [2, 6],
+ *  [1, 1, 6]
+ * ]
+ */
+
+/**
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+var combinationSum2 = function (candidates, target) {
+
+    var res = [];
+    var temp = [];
+    candidates.sort((b, a) => b - a);
+    helper(res, temp, candidates, target, 0);
+    return res;
+};
+
+function helper(res, temp, candidates, target, start) {
+    if (target === 0) {
+        return res.push([...temp]);
+    }
+
+    for (var i = start; i < candidates.length && candidates[i] <= target; i++) {
+        if (i === start || candidates[i] !== candidates[i - 1]) {
+            temp.push(candidates[i]);
+            helper(res, temp, candidates, target - candidates[i], i + 1);
+            temp.length -= 1;
+        }
+    }
+}
+
+console.log(combinationSum2([10, 1, 2, 7, 6, 1, 5], 8));
diff --git a/046-Permutations.js b/046-Permutations.js
@@ -0,0 +1,38 @@
+/**
+ * https://leetcode.com/problems/permutations/description/
+ * Difficulty:Medium
+ *
+ * Given a collection of distinct numbers, return all possible permutations.
+ * For example,
+ * [1,2,3] have the following permutations:
+ * [
+ *  [1,2,3],
+ *  [1,3,2],
+ *  [2,1,3],
+ *  [2,3,1],
+ *  [3,1,2],
+ *  [3,2,1]
+ * ]
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function (nums) {
+    if (!nums.length) return [];
+    var res = [[]];
+    for (var i = 0; i < nums.length; i++) {
+        var len = res.length;
+        for (var j = 0; j < len; j++) {
+            var oldArr = res.shift();
+            for (var k = 0; k <= oldArr.length; k++) {
+                var newArr = oldArr.slice();
+                newArr.splice(k, 0, nums[i]);
+                res.push(newArr);
+            }
+        }
+    }
+    return res;
+};
+console.log(permute([1, 2, 3]));
diff --git a/047-Permutations-II.js b/047-Permutations-II.js
@@ -0,0 +1,47 @@
+/**
+ * https://leetcode.com/problems/permutations-ii/description/
+ * Difficulty:Medium
+ *
+ * Given a collection of numbers that might contain duplicates, return all possible unique permutations.
+ * For example,
+ * [1,1,2] have the following unique permutations:
+ *  [
+ *  [1,1,2],
+ *  [1,2,1],
+ *  [2,1,1]
+ * ]
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permuteUnique = function (nums) {
+    if (!nums.length) return [];
+    nums.sort((a, b) => a - b);
+    var res = [[]];
+    for (var i = 0; i < nums.length; i++) {
+        var len = res.length;
+        for (var j = 0; j < len; j++) {
+            var oldArr = res.shift();
+            if (i > 0 && nums[i] === nums[i - 1]) {
+                var k = oldArr.lastIndexOf(nums[i]);
+            } else {
+                k = 0;
+            }
+            for (; k <= oldArr.length; k++) {
+
+                if (k === oldArr.length || nums[i] !== oldArr[k]) {
+                    var newArr = oldArr.slice();
+                    newArr.splice(k, 0, nums[i]);
+                    // console.log(oldArr, newArr);
+                    res.push(newArr);
+                }
+
+            }
+        }
+    }
+    return res;
+};
+
+console.log(permuteUnique([1, 2, 2, 1]));
diff --git a/500-Keyboard-Row.js b/500-Keyboard-Row.js
@@ -0,0 +1,40 @@
+/**
+ * https://leetcode.com/problems/keyboard-row/description/
+ * Difficulty:Easy
+ *
+ * Given a List of words, return the words that can be typed using letters of alphabet on only one row's of American keyboard like the image below.
+ *
+ * Example 1:
+ * Input: ["Hello", "f", "Dad", "Peace"]
+ * Output: ["Alaska", "Dad"]
+ * Note:
+ * You may use one character in the keyboard more than once.
+ * You may assume the input string will only contain letters of alphabet.
+ */
+
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+var findWords = function (words) {
+
+    var s = 'qwertyuiopasdfghjklzxcvbnm';
+    return words.filter(w => {
+        if (!w) return true;
+        w = w.toLowerCase();
+        var t = row(w[0]);
+        for (var i = 1; i < w.length; i++) {
+            if (t !== row(w[i])) return false;
+        }
+        return true;
+    });
+
+    function row(ch) {
+        var i = s.indexOf(ch);
+        if (i < 10) return 0;
+        if (i < 19) return 1;
+        return 2;
+    }
+
+};
+console.log(findWords(["Hello", "Alaska", "Dad", "Peace"]))
diff --git a/557-Reverse-Words-in-a-String-III.js b/557-Reverse-Words-in-a-String-III.js
@@ -0,0 +1,20 @@
+/**
+ * https://leetcode.com/problems/reverse-words-in-a-string-iii/description/
+ * Difficulty:Easy
+ *
+ * Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.
+ * Example 1:
+ * Input: "Let's take LeetCode contest"
+ * Output: "s'teL ekat edoCteeL tsetnoc"
+ * Note: In the string, each word is separated by single space and there will not be any extra space in the string.
+ */
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseWords = function (s) {
+    return s.split(' ').map(w => w.split('').reverse().join('')).join(' ');
+};
+
+console.log(reverseWords(`Let's take LeetCode contest`))
diff --git a/617-Merge-Two-Binary-Trees.js b/617-Merge-Two-Binary-Trees.js
diff --git a/728-Self-Dividing-Numbers.js b/728-Self-Dividing-Numbers.js
