diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/1-reverse_words_in_a_string.cpp b/1-reverse_words_in_a_string.cpp deleted file mode 100644 index d692f61..0000000 --- a/1-reverse_words_in_a_string.cpp +++ /dev/null @@ -1,38 +0,0 @@ -class Solution { -public: - void reverseWords(string &s) { - istringstream is(s); - string tmp=""; - string out=""; - while(is>>tmp){ - tmp+=" "; - tmp+=out; - out=tmp; - } - s=out.substr(0,out.length()-1); - } -}; - -/* -#include -#include -#include -using namespace std; - -int main () { - - int n,val; - string stringvalues; - - stringvalues = "125 320 512 750 333"; - istringstream iss(stringvalues); - - for (n=0; n<5; n++) - { - iss >> val; - cout << val*2 << endl; - } - - return 0; -} -*/ diff --git a/16-single_number.cpp b/16-single_number.cpp deleted file mode 100644 index 06cb336..0000000 --- a/16-single_number.cpp +++ /dev/null @@ -1,29 +0,0 @@ -class Solution { -public: - int singleNumber(int A[], int n) { - int result = 0; - for(int i = 0; i < n; i++) { - result = result ^ A[i]; - } - return result; - } -}; -/* -#include -using namespace std; - -int singleNumber(int A[], int n) { - int result = 0; - for(int i = 0; i < n; i++) { - result = result ^ A[i]; - } - return result; -} -int main() { - int arr[] = {2,3,4,5,6,4,6,2,5}; - int single = singleNumber(arr, 9); - cout<<"single:"< &tokens) { - vector::iterator string_ite; - vector stack; - int result; - for(string_ite=tokens.begin ();string_ite!=tokens.end ();string_ite++) { - string s = *string_ite; - if(s.compare("+") == 0 || - s.compare("-") == 0 || - s.compare("*") == 0 || - s.compare("/") == 0) { - int a = stack[stack.size()-2]; - int b = stack[stack.size()-1]; - - stack.pop_back(); - stack.pop_back(); - if(s.compare("+") == 0) { - result = a+b; - } - if(s.compare("-") == 0) { - result = a-b; - } - if(s.compare("*") == 0) { - result = a*b; - } - if(s.compare("/") == 0) { - result = a/b; - } - stack.push_back(result); - } else { - int number = atoi(s.c_str()); - stack.push_back(number); - } - - } - return stack[0]; - } -}; - - -/* -#include -#include -#include -#include - -using namespace std; - -void print_vector(vector v) { - for (int index=0;index &token) { - vector::iterator string_ite; - vector stack; - int result; - for(string_ite=token.begin ();string_ite!=token.end ();string_ite++) { - string s = *string_ite; - if(s.compare("+") == 0 || - s.compare("-") == 0 || - s.compare("*") == 0 || - s.compare("/") == 0) { - int a = stack[stack.size()-2]; - int b = stack[stack.size()-1]; - - stack.pop_back(); - stack.pop_back(); - if(s.compare("+") == 0) { - result = a+b; - } - if(s.compare("-") == 0) { - result = a-b; - } - if(s.compare("*") == 0) { - result = a*b; - } - if(s.compare("/") == 0) { - result = a/b; - } - stack.push_back(result); - } else { - int number = atoi(s.c_str()); - stack.push_back(number); - } - - } - return stack[0]; -} - -int main() { - string str[] = {"8", "2", "/"}; - vector rpn(str,str+sizeof(str)/sizeof(str[0])); - int ret = evalRPN (rpn); - cout< &points) { - if(points.size() < 3) { - return points.size(); - } - int maxPoints = 0; //the max point in line - int size = points.size(); - map count; - map::iterator iter; - for(int i = 0; i < size; i++ ) { - int x1 = points[i].x; - int y1 = points[i].y; - int coincideCount = 0; //number of duplicate points - count.clear(); - count[(double)INT_MIN] = 0; - for(int j = i + 1; j < size; j++) { - int x2 = points[j].x; - int y2 = points[j].y; - if(x1 == x2 && y1 == y2) { - coincideCount++; - } else if(x1 == x2){ - count[(double)INT_MIN]++; - } else { - double slope = 1.0*(y1-y2)/(x1-x2); - count[slope]++; - } - } - for(iter = count.begin(); iter != count.end(); iter++) { - if(iter->second + coincideCount > maxPoints) { - maxPoints = iter->second + coincideCount; - } - } - } - maxPoints = maxPoints + 1; - return maxPoints; - } -}; - - - -/* -#include -#include -#include -#include -#include -#include - -using namespace std; - -struct Point { - int x; - int y; - Point() : x(0), y(0) {} - Point(int a, int b) : x(a), y(b) {} -}; - -int maxPoints(vector &points) { - if(points.size() < 3) { - return points.size(); - } - int maxPoints = 0; //the max point in line - int size = points.size(); - map count; - map::iterator iter; - for(int i = 0; i < size; i++ ) { - int x1 = points[i].x; - int y1 = points[i].y; - int coincideCount = 0; //number of duplicate points - count.clear(); - count[(double)INT_MIN] = 0; - for(int j = i + 1; j < size; j++) { - int x2 = points[j].x; - int y2 = points[j].y; - if(x1 == x2 && y1 == y2) { - coincideCount++; - } else if(x1 == x2){ - count[(double)INT_MIN]++; - } else { - double slope = 1.0*(y1-y2)/(x1-x2); - count[slope]++; - } - } - for(iter = count.begin(); iter != count.end(); iter++) { - if(iter->second + coincideCount > maxPoints) { - maxPoints = iter->second + coincideCount; - } - } - } - maxPoints = maxPoints + 1; - return maxPoints; -} -int main() { - Point p1 = Point(1,1); - Point p2 = Point(2,2); - Point p3 = Point(4,3); - Point p4 = Point(4,4); - vector points; - points.push_back(p1); - points.push_back(p2); - points.push_back(p3); - points.push_back(p4); - - int maxNumber = maxPoints(points); - cout<= len1) { + var tmp; + tmp = l1; l1 = l2; l2 = tmp; + } + + var head = l1; + var val1, val2; + var isOverTen = false; + var prev; + while (l1 !== null) { + val1 = l1.val; + val2 = l2 !== null ? l2.val : 0; + + if (isOverTen) { + val1++; + isOverTen = false; + } + if (val1 + val2 >= 10) { + l1.val = val1 + val2 - 10; + isOverTen = true; + } else { + l1.val = val1 + val2; + } + + prev = l1; + l1 = l1.next; + if (l2 !== null) { + l2 = l2.next; + } + } + + if (isOverTen) { + prev.next = new ListNode(1); + } + + return head; +}; +``` + + +### 6. [ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/description/) +```javascript +/** + * @param {string} s + * @param {number} numRows + * @return {string} + */ +var convert = function(s, numRows) { + var chars = s.split(''); + var arrs = []; + for(var k = 0; k < numRows; k++) { + arrs.push([]); + } + + var i = 0; + while(i < chars.length) { + for(var x = 0; x < numRows && i < chars.length; x++) { + arrs[x].push(chars[i++]); + } + for(var x = numRows - 2; x > 0 && i < chars.length; x--) { + arrs[x].push(chars[i++]); + } + } + + var ret = ''; + arrs.map(function(item) { + ret = ret.concat(item.join('')); + }); + return ret; +}; +``` + + +### 7. [Reverse Integer](https://leetcode.com/problems/reverse-integer/description/) +```javascript +/** + * @param {number} x + * @return {number} + */ +var reverse = function(x) { + var flag = (x < 0 ? true : false); + x = Math.abs(x); + var reverse = parseInt(new String(x).split('').reverse().join(''), 10); + if(reverse > Math.pow(2, 31)) { + return 0; + } + if(flag) { + return 0 - reverse; + } else { + return reverse; + } + +}; +``` + + +### 8. [String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/description/) +```javascript +/** + * @param {string} str + * @return {number} + */ +var myAtoi = function(str) { + var ret = parseInt(str, 10); + if(Number.isNaN(ret)) { + return 0; + } + if(ret > 2147483647) { + return 2147483647; + } else if(ret < -2147483648) { + return -2147483648; + } else { + return ret; + } +}; +``` + + +### 9. [Palindrome Number](https://leetcode.com/problems/palindrome-number/description/) +```javascript +/** + * @param {number} x + * @return {boolean} + */ +var isPalindrome = function(x) { + x += ''; + var i = 0; + var j = x.length - 1; + while(i < j) { + if(x[i] != x[j]) { + return false + } + i++; + j--; + } + return true; +}; +``` + + +### 12. [Integer to Roman](https://leetcode.com/problems/integer-to-roman/description/) +```javascript +/** + * @param {number} num + * @return {string} + */ +var intToRoman = function(num) { + var M = ["", "M", "MM", "MMM"]; + var C = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]; + var X = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]; + var I = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]; + + return [ + M[parseInt(num / 1000)], + C[parseInt((num % 1000) / 100)], + X[parseInt((num % 100) / 10)], + I[num % 10] + ].join(''); +}; +``` + + +### 13. [Roman to Integer](https://leetcode.com/problems/roman-to-integer/description/) +```javascript +/** + * @param {string} s + * @return {number} + * + * Symbol Value + * I 1 + * V 5 + * X 10 + * L 50 + * C 100 + * D 500 + * M 1,000 + + */ +var romanToInt = function(s) { + var map = { + 'I':1, + 'V':5, + 'X':10, + 'L':50, + 'C':100, + 'D':500, + 'M':1000 + }; + + var sum = 0; + var right = 'I'; + + for(var i = s.length - 1; i >=0; i--) { + if(i < s.length - 1) { + right = s[i + 1]; + } + if(map[s[i]] < map[right]) { + sum -= map[s[i]]; + } else { + sum += map[s[i]]; + right = s[i]; + } + } + return sum; +}; + +``` + + +### 14. [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/description/) +```javascript +/** + * @param {string[]} strs + * @return {string} + */ +var longestCommonPrefix = function(strs) { + if (strs.length === 0) return ''; + if (strs.length === 0) return strs[1]; + + var ret = ''; + var isBreak = false; + var isCommon = true; + var char; + + for (var j = 0; j < strs[0].length; j++) { + char = strs[0][j]; + + for (var i = 1; i < strs.length; i++) { + if (strs[i].length <= j || strs[i][j] !== char) { + isBreak = true; + break; + } + } + if (isBreak) { + break; + } + ret += strs[0][j]; + } + return ret; +}; + +``` + + +### 15. [3Sum](https://leetcode.com/problems/3sum/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[][]} + */ + +var threeSum = function(nums) { + var ret = []; + + nums = nums.sort((a, b) => a - b); + for (var i = 0; i + 2 < nums.length; i++) { + if (i > 0 && nums[i] == nums[i - 1]) { + continue; + } + + var j = i + 1, k = nums.length - 1; + var target = -nums[i]; + + while (j < k) { + if (nums[j] + nums[k] == target) { + ret.push([nums[i], nums[j], nums[k]]); + j++; + k--; + while (j < k && nums[j] == nums[j - 1]) j++; + while (j < k && nums[k] == nums[k + 1]) k--; + } else if (nums[j] + nums[k] > target) { + k--; + } else { + j++; + } + } + } + + return ret; +}; + +``` + + +### 16. [3Sum Closest](https://leetcode.com/problems/3sum-closest/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +var threeSumClosest = function(nums, target) { + var closet = Number.MAX_SAFE_INTEGER; + var closetTarget; + + nums = nums.sort((a, b) => a - b); + + for (var i = 0; i + 2 < nums.length; i++) { + if (i > 0 && nums[i] == nums[i - 1]) { + continue; + } + + var j = i + 1, k = nums.length - 1; + + while (j < k) { + if (Math.abs(nums[j] + nums[k] + nums[i] - target) < closet) { + closet = Math.abs(nums[j] + nums[k] + nums[i] - target); + closetTarget = nums[j] + nums[k] + nums[i]; + } + + if (nums[j] + nums[k] + nums[i] === target) { + return target; + } else if (nums[j] + nums[k] + nums[i] > target) { + k--; + } else { + j++; + } + } + } + + return closetTarget; +}; + +``` + + +### 17. [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/) +```javascript +/** + * @param {string} digits + * @return {string[]} + */ +var letterCombinations = function(digits) { + if(digits.length === 0) { + return []; + } + + var map = { + 2: ['a', 'b', 'c'], + 3: ['d', 'e', 'f'], + 4: ['g', 'h', 'i'], + 5: ['j', 'k', 'l'], + 6: ['m', 'n', 'o'], + 7: ['p', 'q', 'r', 's'], + 8: ['t', 'u', 'v'], + 9: ['w', 'x', 'y', 'z'], + }; + + if(digits.length === 1) { + return map[digits]; + } else { + var front = map[digits.slice(0, 1)]; + var back = letterCombinations(digits.slice(1)); + var ret = []; + + front.forEach(f => { + back.forEach(b => { + ret.push(f + b); + }); + }); + + return ret; + } +}; + + +``` + + +### 19. [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} n + * @return {ListNode} + */ +var removeNthFromEnd = function(head, n) { + var front = head; + var end = head; + for(var i = 0; i <= n && front; i++) { + front = front.next; + } + + // delete first node + if(i < n + 1) { + return head.next; + } + + while(front) { + front = front.next; + end = end.next; + } + end.next = end.next.next; + return head; +}; +``` + + +### 20. [Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/) +```javascript +/** + * @param {string} s + * @return {boolean} + */ +var isValid = function(s) { + var stack = []; + var match = { + ')': '(', + ']': '[', + '}': '{' + }; + var len; + for(var i = 0; i < s.length; i++) { + len = stack.length; + if(len > 0 && stack[len-1] == match[s[i]]) { + stack.pop(); + } else { + stack.push(s[i]); + } + } + return stack.length === 0; +}; + +``` + + +### 21. [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} l1 + * @param {ListNode} l2 + * @return {ListNode} + */ +var mergeTwoLists = function(l1, l2) { + if(!l1) return l2; + if(!l2) return l1; + var head = null + if(l1.val < l2.val) { + head = l1; + l1 = l1.next; + } else { + head = l2; + l2 = l2.next; + } + + newlist = head; + while(l1 && l2) { + if(l1.val < l2.val) { + newlist.next = l1; + l1 = l1.next; + } else { + newlist.next = l2; + l2 = l2.next; + } + newlist = newlist.next; + } + if(!l1) { + newlist.next = l2; + } else { + newlist.next = l1; + } + + return head; +}; +``` + + +### 22. [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/description/) +```javascript +/** + * @param {number} n + * @return {string[]} + */ +var generateParenthesis = function(n) { + if(n === 0) { + return []; + } else if(n === 1){ + return ['()']; + } else { + var parenthesis = generateParenthesis(n - 1); + var retObj = {}; + + parenthesis.forEach(p => { + for(var i = 0; i < p.length + 1; i++) { + var charArr = p.split(''); + + charArr.splice(i, 0, '()'); + retObj[charArr.join('')] = true; + } + }); + + return Object.keys(retObj); + } +}; + +``` + + +### 24. [Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var swapPairs = function(head) { + if(head === null || head.next === null) { + return head; + } + + var newhead = null; + var tmp1 = head.next; + var tmp2 = head.next.next; + head.next.next = head; + head.next = tmp2; + newhead = tmp1; + + var p = head; + while(p && p.next && p.next.next) { + tmp1 = p.next.next; + tmp2 = p.next.next.next; + p.next.next.next = p.next; + p.next.next = tmp2; + p.next = tmp1; + p = p.next.next; + } + + return newhead; +}; +``` + + +### 26. [Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var removeDuplicates = function(nums) { + var i = 0; + var j = 0; + while(j < nums.length) { + if(nums[i] == nums[j]) { + j++; + } else { + i++; + nums[i] = nums[j]; + j++; + } + } + return i + 1; + +}; +``` + + +### 27. [Remove Element](https://leetcode.com/problems/remove-element/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} val + * @return {number} + */ +var removeElement = function(nums, val) { + var head = 0; + var tail = nums.length - 1; + while(head <= tail) { + if(nums[head] != val) { + head++; + continue; + } + + if(nums[tail] == val) { + tail--; + continue; + } + + nums[head] = nums[tail]; + tail--; + } + return head; +}; +``` + + +### 28. [Implement strStr()](https://leetcode.com/problems/implement-strstr/description/) +```javascript +/** + * @param {string} haystack + * @param {string} needle + * @return {number} + */ + +var strStr = function(haystack, needle) { + if (needle === '') return 0; + for(var i = 0;; i++) { + for(var j = 0;; j++) { + if (j == needle.length) return i; + if (i + j >= haystack.length) return -1; + if (haystack[i + j] != needle[j]) break; + } + } + return -1; +}; + +``` + + +### 29. [Divide Two Integers](https://leetcode.com/problems/divide-two-integers/description/) +```cpp +class Solution { +public: + int divide(int dividend, int divisor) { + if (!divisor || (dividend == INT_MIN && divisor == -1)) + return INT_MAX; + int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1; + long long dvd = labs(dividend); + long long dvs = labs(divisor); + int res = 0; + while (dvd >= dvs) { + long long temp = dvs, multiple = 1; + while (dvd >= (temp << 1)) { + temp <<= 1; + multiple <<= 1; + } + dvd -= temp; + res += multiple; + } + return sign == 1 ? res : -res; + } +}; +``` + + +### 31. [Next Permutation](https://leetcode.com/problems/next-permutation/description/) +```javascript +var nextPermutation = function(nums) { + if (nums.length <= 1) { + return; + } + + var i = nums.length - 2; + var j = nums.length - 1; + while (nums[i] >= nums[i + 1] && i > -1) { + i--; + } + if (i >= 0) { + while (nums[j] <= nums[i]) { + j--; + } + + var temp; + temp = nums[i]; + nums[i] = nums[j]; + nums[j] = temp; + } + + var start = i + 1; + var end = nums.length - 1; + + while (start < end) { + temp = nums[start]; + nums[start] = nums[end]; + nums[end] = temp; + start++; + end--; + } + +}; +``` + + +### 33. [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +function binarySearch(nums, target) { + var end = nums.length - 1; + var start = 0; + var middle = parseInt((start + end) / 2); + + while (end >= start) { + if (nums[middle] == target) { + return middle; + } else if(nums[middle] > target) { + end = middle - 1; + } else if(nums[middle] < target) { + start = middle + 1; + } + middle = parseInt((start + end) / 2); + } + return -1; +} + +var search = function(nums, target) { + var i = 0; + while(nums[i] <= nums[i+1]) { + i++; + } + + if (nums[0] <= target && target <= nums[i]) { + return binarySearch(nums.slice(0, i + 1), target); + } else if (nums[i + 1] <= target && target <= nums[nums.length - 1]){ + var ret = binarySearch(nums.slice(i + 1), target); + return ret == -1 ? -1 : i + 1 + ret; + } else { + return -1; + } +}; + +``` + + +### 35. [Search Insert Position](https://leetcode.com/problems/search-insert-position/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +var searchInsert = function(nums, target) { + var start = 0; + var end = nums.length - 1; + var middle = parseInt((start + end) / 2); + + while(start <= end) { + if (target === nums[middle]) { + return middle; + } else if (target > nums[middle]) { + start = middle + 1; + } else if (target < nums[middle] ) { + end = middle - 1; + } + if (start > end) { + if (target < nums[middle]) { + return middle; + } else { + return middle + 1; + } + } else { + middle = parseInt((start + end) / 2); + } + } +}; +``` + + +### 36. [Valid Sudoku](https://leetcode.com/problems/valid-sudoku/description/) +```javascript +/** + * @param {character[][]} board + * @return {boolean} + */ +var isValidSudoku = function(board) { + var rowExist = {}; + var colExist = {}; + var boxExist = {}; + var k, value; + for (var i = 0; i < board.length; i++) { + for (var j = 0; j < board[i].length; j++) { + value = board[i][j]; + k = parseInt(i / 3, 10) * 3 + parseInt(j / 3, 10); //the number of the box + if (!rowExist[i]) { + rowExist[i] = {}; + } + if (!colExist[j]) { + colExist[j] = {}; + } + if (!boxExist[k]) { + boxExist[k] = {}; + } + + if (value !== '.') { + if (rowExist[i][value] || colExist[j][value] || boxExist[k][value]) { + return false; + } else { + rowExist[i][value] = true; + colExist[j][value] = true; + boxExist[k][value] = true; + } + } + } + } + return true; +}; +``` + + +### 38. [Count and Say](https://leetcode.com/problems/count-and-say/description/) +```javascript +/** + * @param {number} n + * @return {string} + */ + +var countAndSay = function(n) { + if (n === 1) return '1'; + + var last = countAndSay(n - 1); + var digit = last[0]; + var count = 0; + var ret = ''; + + for (var i = 0; i < last.length; i++) { + if (last[i] !== digit) { + ret += count + digit; + digit = last[i]; + count = 0; + } + count++; + } + ret += count + digit; + + return ret; +}; +``` + + +### 46. [Permutations](https://leetcode.com/problems/permutations/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[][]} + */ +var permute = function(nums) { + var ret = []; + if(nums.length == 1) { + ret.push(nums); + return ret; + } + + var head, pre_ret, item, item_copy; + head = nums.shift(); + pre_ret = permute(nums); + for(var i = 0; i < pre_ret.length; i++ ) { + item = pre_ret[i]; + for(var j = 0; j <= item.length; j++) { + item_copy = [].slice.call(item); + item_copy.splice(j, 0, head); + ret.push(item_copy); + } + } + return ret; +}; +``` + + +### 53. [Maximum Subarray](https://leetcode.com/problems/maximum-subarray/description/) +```python +class Solution(object): + def maxSubArray(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + # dp[i] = dp[i - 1] + nums[i] (dp[i - i] > 0) + # dp[i] = nums[i] (dp[i - i] < 0) + dp = {} + dp[0] = nums[0] + maxv = nums[0] + + for i in range(1, len(nums)): + if dp[i - 1] > 0: + dp[i] = dp[i - 1] + nums[i] + else: + dp[i] = nums[i] + maxv = max(maxv, dp[i]) + + return maxv +``` + + +### 54. [Spiral Matrix](https://leetcode.com/problems/spiral-matrix/description/) +```javascript +/** + * @param {number[][]} matrix + * @return {number[]} + */ +var spiralOrder = function(matrix) { + if (matrix.length == 0) {return [];} + var n = matrix.length; + var m = matrix[0].length; + var up = 0, right = m - 1, down = n - 1, left = 0; + var ret = []; + + while(true) { + for(var r = left; r <= right; r++) ret.push(matrix[up][r]); + if (++up > down) break; + + for(var d = up; d <= down; d++) ret.push(matrix[d][right]); + if (--right < left) break; + + for(var l = right; l >= left; l--) ret.push(matrix[down][l]); + if (--down < up) break; + + for(var u = down; u >= up; u--) ret.push(matrix[u][left]); + if (++left > right) break; + } + return ret; +}; + +``` + + +### 58. [Length of Last Word](https://leetcode.com/problems/length-of-last-word/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ +var lengthOfLastWord = function(s) { + return s.trim().split(' ').pop().length; +}; +``` + + +### 62. [Unique Paths](https://leetcode.com/problems/unique-paths/description/) +```javascript +/** + * @param {number} m + * @param {number} n + * @return {number} + */ +var uniquePaths = function(m, n) { + var dp = Array(n).fill(1).map(() => Array(m).fill(1)); + + for (var i = 1; i < n; i++) { + for (var j = 1; j < m; j++) { + dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; + } + } + + return dp[n - 1][m - 1]; +}; +``` + + +### 63. [Unique Paths II](https://leetcode.com/problems/unique-paths-ii/description/) +```javascript +/** + * @param {number[][]} obstacleGrid + * @return {number} + */ +var uniquePathsWithObstacles = function(obstacleGrid) { + var n = obstacleGrid.length; + var m = obstacleGrid[0].length; + + if (obstacleGrid[n - 1][m - 1] === 1 || obstacleGrid[0][0] === 1) return 0; + + var dp = Array(n).fill(null).map(() => Array(m).fill(0)); + for (var i = 0; i < m && obstacleGrid[0][i] === 0; i++) dp[0][i] = 1; + for (var j = 0; j < n && obstacleGrid[j][0] === 0; j++) dp[j][0] = 1; + + var top, left; + for (var i = 1; i < n; i++) { + for (var j = 1; j < m; j++) { + top = obstacleGrid[i - 1][j] === 1 ? 0 : dp[i - 1][j]; + left = obstacleGrid[i][j - 1] === 1 ? 0 : dp[i][j - 1]; + dp[i][j] = top + left; + } + } + + return dp[n - 1][m - 1]; +}; +``` + + +### 66. [Plus One](https://leetcode.com/problems/plus-one/description/) +```javascript +/** + * @param {number[]} digits + * @return {number[]} + */ +var plusOne = function(digits) { + digits.unshift(0); + var tail = digits.length - 1; + digits[tail]++; + while(tail > 0) { + if(digits[tail] == 10) { + digits[tail] = 0; + tail--; + digits[tail]++; + } else { + tail--; + } + } + if(digits[0] == 0) { + digits.shift(); + } + return digits; +}; +``` + + +### 69. [Sqrt(x)](https://leetcode.com/problems/sqrtx/description/) +```javascript +/** + * @param {number} x + * @return {number} + */ +var mySqrt = function(x) { + var start = 1; + var end = x; + var middle; + + while (start <= end) { + middle = start + parseInt((end - start) / 2); + if (x / middle === middle) { + return middle; + } else if (x / middle > middle) { + start = middle + 1; + } else { + end = middle - 1; + } + } + + return end; +}; + +``` + + +### 70. [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/description/) +```python +class Solution(object): + def climbStairs(self, n): + """ + :type n: int + :rtype: int + """ + # dp[i] 爬i阶台阶有多少种方式 + # dp[i] = dp[i - 1] + dp[i - 2] + dp = {} + dp[1] = 1 + dp[2] = 2 + + for i in range(3, n + 1): + dp[i] = dp[i - 1] + dp[i - 2] + + return dp[n] + +``` + + +### 73. [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/description/) +```javascript +/** + * @param {number[][]} matrix + * @return {void} Do not return anything, modify matrix in-place instead. + */ +var setZeroes = function(matrix) { + var hasZeroFirstCol = false; + for(var i = 0; i < matrix.length; i++) { + if(matrix[i][0] === 0) { + hasZeroFirstCol = true; + } + for(var j = 1; j < matrix[i].length; j++) { + if(matrix[i][j] === 0) { + matrix[0][j] = matrix[i][0] = 0; + } + } + } + for(var y = matrix.length - 1; y >= 0; y--) { + for(var x = matrix[y].length - 1; x >= 1; x--) { + if(matrix[0][x] === 0 || matrix[y][0] === 0) { + matrix[y][x] = 0; + } + } + if(hasZeroFirstCol) { + matrix[y][0] = 0; + } + } +}; +``` + + +### 83. [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var deleteDuplicates = function(head) { + var iter = head; + while(iter) { + if(iter.next && iter.val === iter.next.val) { + iter.next = iter.next.next; + } else { + iter = iter.next; + } + } + return head; +}; +``` + + +### 88. [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/) +```javascript +/** + * @param {number[]} nums1 + * @param {number} m + * @param {number[]} nums2 + * @param {number} n + * @return {void} Do not return anything, modify nums1 in-place instead. + */ +var merge = function(nums1, m, nums2, n) { + while(n > 0) { + if(m <= 0 || nums1[m - 1] <= nums2[n -1]) { + nums1[m + n - 1] = nums2[n - 1]; + n--; + } else { + nums1[m + n - 1] = nums1[m - 1]; + m--; + } + } +}; +``` + + +### 92. [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} m + * @param {number} n + * @return {ListNode} + */ + +var reverseBetween = function(head, m, n) { + function reverseList(head) { + if(!head) { + return head; + } + var prev = null; + var next = null; + while(head) { + next = head.next; + head.next = prev; + prev = head; + head = next; + } + return prev; + } + if(m === n) { + return head; + } + var middleLeft = null; + var middleRight = null; + var left = null; + var right = null; + + var i = 1; + var point = head; + while(point) { + if(i + 1 === m) { + left = point; + } + if(i === m) { + middleLeft = point; + } + if(i === n) { + middleRight = point; + } + if(i === n + 1) { + right = point; + } + i++; + point = point.next; + } + if(left) { + left.next = null; + } + + middleRight.next = null; + reverseList(middleLeft); + middleLeft.next = right; + + if(left) { + left.next = middleRight; + return head; + } else { + return middleRight; + } +}; + +``` + + +### 94. [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/description/) +```python +# Definition for a binary tree node. +# class TreeNode(object): +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution(object): + def inorder(self, root, list): + if root == None: + return + self.inorder(root.left, list) + list.append(root.val) + self.inorder(root.right, list) + + def inorderTraversal(self, root): + l = [] + self.inorder(root, l) + return l +``` + + +### 98. [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ +function isValid(root, max, min) { + if (root === null) return true; + if (root.val >= max || root.val <= min) return false; + + return isValid(root.left, root.val, min) && isValid(root.right, max, root.val); +} +var isValidBST = function(root) { + return isValid(root, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER); +}; + +``` + + +### 100. [Same Tree](https://leetcode.com/problems/same-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} p + * @param {TreeNode} q + * @return {boolean} + */ +var isSameTree = function(p, q) { + if(p == null || q == null) { + return p == q; + } + if(p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right)) { + return true; + } else { + return false; + } +}; +``` + + +### 101. [Symmetric Tree](https://leetcode.com/problems/symmetric-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ + +var isSymmetric = function(root) { + function isSymmetricNode(left, right) { + if(!left && !right) { + return true; + } + if((left && !right) || (!left && right)) { + return false; + } + return (left.val == right.val) + && isSymmetricNode(left.left, right.right) + && isSymmetricNode(left.right, right.left); + } + if(root === null) { + return true; + } + var left = root.left; + var right = root.right; + return isSymmetricNode(left, right); +}; + +``` + + +### 102. [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[][]} + */ +var traversal = function(ret, root, depth) { + if(root === null) { + return; + } + if(!Array.isArray(ret[depth])) { + ret[depth] = []; + } + ret[depth].push(root.val); + traversal(ret, root.left, depth + 1); + traversal(ret, root.right, depth + 1); +} +var levelOrder = function(root) { + var ret = []; + traversal(ret, root, 0); + return ret; +}; +``` + + +### 104. [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var maxDepth = function(root) { + if(root == null) { + return 0; + } else { + return Math.max(maxDepth(root.left), maxDepth(root.right)) +1; + } +}; +``` + + +### 107. [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[][]} + */ +var traversal = function(ret, root, depth) { + if(root === null) { + return; + } + if(!Array.isArray(ret[depth])) { + ret[depth] = []; + } + ret[depth].push(root.val); + traversal(ret, root.left, depth + 1); + traversal(ret, root.right, depth + 1); +} +var levelOrderBottom = function(root) { + var ret = []; + traversal(ret, root, 0); + return ret.reverse(); +}; +``` + + +### 108. [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {number[]} nums + * @return {TreeNode} + */ + +var sortedArrayToBST = function(nums) { + if (nums.length === 0) {return null;} + var start = 0; + var end = nums.length - 1; + var middle = parseInt((start + end) / 2); + + var root, node1, node2, node3; + + if (nums.length <= 3) { + node1 = new TreeNode(nums[0]); + if (nums.length === 1) { + return node1; + } + + node2 = new TreeNode(nums[1]); + node2.left = node1; + if (nums.length === 2) { + return node2; + } + + node3 = new TreeNode(nums[2]); + node2.right = node3; + return node2; + + } else { + root = new TreeNode(nums[middle]); + root.left = sortedArrayToBST(nums.slice(0, middle)); + root.right = sortedArrayToBST(nums.slice(middle + 1)); + } + return root; +}; +``` + + +### 110. [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ +var maxDeepth = function(root) { + if(root === null) { + return 0; + } else { + return Math.max(maxDeepth(root.left), maxDeepth(root.right)) + 1; + } +} +var isBalanced = function(root) { + if(root === null) { + return true; + } + var leftDeepth = maxDeepth(root.left); + var rightDeepth = maxDeepth(root.right); + + if(Math.abs(leftDeepth - rightDeepth) <= 1 + && isBalanced(root.left) + && isBalanced(root.right) + ) { + return true; + } else { + return false; + } +}; +``` + + +### 111. [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var minDepth = function(root) { + if(root === null) { + return 0; + } + var leftDepth = minDepth(root.left); + var rightDepth = minDepth(root.right); + + if(leftDepth !== 0 && rightDepth !== 0) { + return Math.min(leftDepth, rightDepth) + 1; + } else if(leftDepth === 0) { + return rightDepth + 1; + } else { + return leftDepth + 1; + } +}; +``` + + +### 112. [Path Sum](https://leetcode.com/problems/path-sum/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} sum + * @return {boolean} + */ +var hasPathSum = function(root, sum) { + if(root == null) { + return false; + } + if(root.left == null && root.right == null && sum == root.val) { + return true; + } + if(hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val)) { + return true; + } else { + return false; + } +}; +``` + + +### 118. [Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/description/) +```javascript +/** + * @param {number} numRows + * @return {number[][]} + */ +var generate = function(numRows) { + if(numRows === 0) { + return []; + } + if(numRows === 1) { + return [[1]]; + } + + var ret = [[1]]; + for(var i = 1; i < numRows; i++) { + ret.push([]); + for(var j = 0; j < ret[i - 1].length - 1; j++) { + ret[i].push(ret[i-1][j] + ret[i-1][j + 1]); + } + ret[i].unshift(1); + ret[i].push(1); + } + return ret; +}; +``` + + +### 119. [Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/description/) +```javascript +/** + * @param {number} rowIndex + * @return {number[]} + */ +var getRow = function(rowIndex) { + var ret = []; + ret[0] = 1; + for(var i = 1; i <= rowIndex; i++ ) { + ret[i] = 1; + for(j = i - 1; j > 0; j--) { + ret[j] = ret[j] + ret[j - 1]; + } + } + return ret; +}; +``` + + +### 120. [Triangle](https://leetcode.com/problems/triangle/description/) +```javascript +/** + * @param {number[][]} triangle + * @return {number} + */ +var minimumTotal = function(triangle) { + if (triangle.length === 0 || triangle[0].length === 0) return 0; + var dp = Array(triangle.length).fill(null); + dp[0] = triangle[0][0]; + var minv = dp[0]; + var prev; + + for (var i = 1; i < triangle.length; i++) { + prev = dp.slice(); // copy dp + dp[0] = prev[0] + triangle[i][0]; + for (var j = 1; j < triangle[i].length - 1; j++) { + dp[j] = Math.min(prev[j - 1], prev[j]) + triangle[i][j]; + } + dp[triangle[i].length - 1] = prev[triangle[i].length - 2] + triangle[i][triangle[i].length - 1]; + } + + return Math.min.apply(null, dp); +}; +``` + + +### 121. [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/) +```javascript +/** + * @param {number[]} prices + * @return {number} + */ +var maxProfit = function(prices) { + var min = Number.MAX_VALUE; + var profit = 0; + + for(var i = 0; i < prices.length; i++) { + min = Math.min(min, prices[i]); + profit = Math.max(profit, prices[i] - min); + } + + return profit; +}; +``` + + +### 122. [Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/) +```javascript +/** + * @param {number[]} prices + * @return {number} + */ +var maxProfit = function(prices) { + var len = prices.length; + var minsum = 0; + var maxsum = 0; + var isUp; + var lastIsUp; + + for(var i = 0; i < prices.length - 1; i++) { + if(prices[i] < prices[i+1]) { + isUp = true; + } else { + isUp = false; + } + if(isUp && (i === 0 || lastIsUp === false)) { + minsum += prices[i]; + } + if(lastIsUp && isUp === false) { + maxsum += prices[i]; + } + if(isUp && i === prices.length - 2) { + maxsum += prices[i + 1]; + } + lastIsUp = isUp; + } + return maxsum - minsum; +}; +``` + + +### 125. [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/description/) +```javascript +/** + * @param {string} s + * @return {boolean} + */ +var isPalindrome = function(s) { + var str = s.split('').filter(function(c) { + return c.match(/[\w\d]/); + }).join('').toLowerCase(); + + if(str === '') { + return true; + } + var i = 0; + var j = str.length - 1; + while(i < j) { + if(str[i] != str[j]) { + return false; + } + i++; + j--; + } + return true; +}; +``` + + +### 136. [Single Number](https://leetcode.com/problems/single-number/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var singleNumber = function(nums) { + return nums.reduce(function(prev, cur) { + return prev ^ cur; + }); +}; +``` + + +### 138. [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/) +```javascript +/** + * Definition for singly-linked list with a random pointer. + * function RandomListNode(label) { + * this.label = label; + * this.next = this.random = null; + * } + */ + +/** + * @param {RandomListNode} head + * @return {RandomListNode} + */ + +var copyLinkList = function(head) { + if (head === null) { + return null; + } + + var new_head = new RandomListNode(head.label); + var new_current = new_head; + var node; + + head = head.next; + while(head !== null) { + node = new RandomListNode(head.label); + new_current.next = node; + new_current = node; + head = head.next; + } + + return new_head; +}; + +var copyRandomList = function(head) { + if (head === null) { + return null; + } + + var new_head = copyLinkList(head); + var new_list = []; + var old_list = []; + + var new_curr = new_head; + var old_curr = head; + while (new_curr !== null) { + new_list.push(new_curr); + old_list.push(old_curr); + new_curr = new_curr.next; + old_curr = old_curr.next; + } + + for (var i = 0; i < new_list.length; i++) { + new_list[i].random = old_list[i]; + old_list[i].next = new_list[i]; + } + + for (i = 0; i < new_list.length; i++) { + if (old_list[i].random === null) { + new_list[i].random = null; + } else { + new_list[i].random = old_list[i].random.next; + } + } + + for (i = 0; i < old_list.length - 1; i++) { + old_list[i].next = old_list[i + 1]; + } + old_list[old_list.length - 1].next = null; + + + return new_head; +}; + + +``` + + +### 139. [Word Break](https://leetcode.com/problems/word-break/description/) +```python +class Solution(object): + def wordBreak(self, s, wordDict): + """ + :type s: str + :type wordDict: List[str] + :rtype: bool + """ + + #dp[i] measn word[:i+1] can be segmented + + dp = {} + dp[0] = True + for i in range(1, len(s) + 1): + for j in range(0, i): + if dp.get(j, False) and s[j:i] in wordDict: + dp[i] = True + + return dp.get(len(s), False) +``` + + +### 141. [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ + +/** + * @param {ListNode} head + * @return {boolean} + */ +var hasCycle = function(head) { + if (head === null) {return false;} + var fast = head; + var slow = head; + + while(slow.next !== null && slow.next.next !== null) { + fast = fast.next; + slow = slow.next.next; + if (slow === fast) return true; + } + + return false; +}; +``` + + +### 144. [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ + +var preorderTraversal = function(root) { + if(root === null) return []; + var ret = []; + + function pre(root) { + if(root) { + ret.push(root.val); + pre(root.left); + pre(root.right); + } + } + pre(root); + return ret; +}; +``` + + +### 146. [LRU Cache](https://leetcode.com/problems/lru-cache/description/) +```python +class Node: + def __init__(self, k, v): + self.key = k + self.val = v + self.prev = None + self.next = None + +class LRUCache(object): + + def __init__(self, capacity): + """ + :type capacity: int + """ + self.capacity = capacity + self.head = Node('head', None) + self.tail = Node('tail', None) + self.map = {} + self.head.next = self.tail + self.tail.prev = self.head + + + def get(self, key): + """ + :type key: int + :rtype: int + """ + if not self.map.has_key(key): + return -1 + target = self.map[key] + self._remove(target) + self._add(target) + return target.val + + def put(self, key, value): + """ + :type key: int + :type value: int + :rtype: void + """ + if self.map.has_key(key): + self._remove(self.map[key]) + target = Node(key, value) + self._add(target) + self.map[key] = target + + if len(self.map) > self.capacity: + delete_node = self.head.next + self._remove(delete_node) + del self.map[delete_node.key] + + # add before the tail + def _add(self, node): + p_node = self.tail.prev + p_node.next = node + node.next = self.tail + self.tail.prev = node + node.prev = p_node + + # remove the node + def _remove(self, node): + p_node = node.prev + n_node = node.next + p_node.next = n_node + n_node.prev = p_node + +``` + + +### 148. [Sort List](https://leetcode.com/problems/sort-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var sortList = function(head) { + function merge(l1, l2) { + if(!l1) return l2; + if(!l2) return l1; + var head = null + if(l1.val < l2.val) { + head = l1; + l1 = l1.next; + } else { + head = l2; + l2 = l2.next; + } + var newlist = head; + while(l1 && l2) { + if(l1.val < l2.val) { + newlist.next = l1; + l1 = l1.next; + } else { + newlist.next = l2; + l2 = l2.next; + } + newlist = newlist.next; + } + if(!l1) { + newlist.next = l2; + } else { + newlist.next = l1; + } + return head; + } + + if(!head || !head.next) { + return head; + } + + var p1 = head; + var p2 = head; + + // p1 go step 1 + // p2 go step 2 + while(p1 && p2) { + p2 = p2.next; + if(p2) { + p2 = p2.next; + } + if(!p2) { + break; + } + p1 = p1.next; + } + + var right = p1.next; + p1.next = null; + var left = head; + + return merge(sortList(left), sortList(right)); +} +``` + + +### 149. [Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/description/) +```cpp +/** + * Definition for a point. + * struct Point { + * int x; + * int y; + * Point() : x(0), y(0) {} + * Point(int a, int b) : x(a), y(b) {} + * }; + */ +class Solution { +public: + int maxPoints(vector &points) { + if(points.size() < 3) { + return points.size(); + } + int maxPoints = 0; //the max point in line + int size = points.size(); + map count; + map::iterator iter; + for(int i = 0; i < size; i++ ) { + int x1 = points[i].x; + int y1 = points[i].y; + int coincideCount = 0; //number of duplicate points + count.clear(); + count[(double)INT_MIN] = 0; + for(int j = i + 1; j < size; j++) { + int x2 = points[j].x; + int y2 = points[j].y; + if(x1 == x2 && y1 == y2) { + coincideCount++; + } else if(x1 == x2){ + count[(double)INT_MIN]++; + } else { + double slope = 1.0*(y1-y2)/(x1-x2); + count[slope]++; + } + } + for(iter = count.begin(); iter != count.end(); iter++) { + if(iter->second + coincideCount > maxPoints) { + maxPoints = iter->second + coincideCount; + } + } + } + maxPoints = maxPoints + 1; + return maxPoints; + } +}; +``` + + +### 150. [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/) +```javascript +/** + * @param {string[]} tokens + * @return {number} + */ + var evalRPN = function(tokens) { + var stack = []; + var a, b, result; + for(var i = 0; i < tokens.length; i++) { + if(Number.isNaN(parseInt(tokens[i]))) { + b = stack.pop(); + a = stack.pop(); + if(tokens[i] == '+') { + result = a + b; + } else if(tokens[i] == '-') { + result = a - b; + } else if(tokens[i] == '*') { + result = a * b; + } else if(tokens[i] == '/') { + result = a / b; + } + stack.push(parseInt(result, 10)); + } else { + stack.push(parseInt(tokens[i], 10)); + } + } + return stack.pop(); +}; +``` + + +### 151. [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/description/) +```javascript +/** + * @param {string} str + * @returns {string} + */ +var reverseWords = function(str) { + return str.split(' ').reverse().filter(function(item) { + return '' != item; + }).join(' ').trim(); +}; +``` + + +### 152. [Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/description/) +```python +class Solution(object): + def maxProduct(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + ret = maxv = minv = nums[0] + + for i in nums[1:]: + if i >= 0: + maxv = max(i, maxv * i) + minv = min(i, minv * i) + else: + maxv_tmp = maxv + maxv = max(i, minv * i) + minv = min(i, maxv_tmp * i) + + ret = max(ret, maxv) + + return ret +``` + + +### 155. [Min Stack](https://leetcode.com/problems/min-stack/description/) +```javascript +/** + * @constructor + */ +var MinStack = function() { + this.stack = []; + this.min = Number.MAX_SAFE_INTEGER; +}; + +/** + * @param {number} x + * @returns {void} + */ +MinStack.prototype.push = function(x) { + if(x < this.min) { + this.min = x; + } + this.stack.push(x); +}; + +/** + * @returns {void} + */ +MinStack.prototype.pop = function() { + var number = this.stack.pop(); + if(number == this.min) { + this.min = Math.min.apply(null, this.stack); + } +}; + +/** + * @returns {number} + */ +MinStack.prototype.top = function() { + if(this.stack.length > 0) { + return this.stack[this.stack.length - 1]; + } else { + return undefined; + } +}; + +/** + * @returns {number} + */ +MinStack.prototype.getMin = function() { + return this.min; +}; +``` + + +### 160. [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ + +/** + * @param {ListNode} headA + * @param {ListNode} headB + * @return {ListNode} + */ +var getIntersectionNode = function(headA, headB) { + if(headA === null || headB === null) { + return null; + } + var pointA = headA; + var pointB = headB; + var i = 0; + var j = 0; + var k = 0; + while(pointA.next !== null) { + pointA = pointA.next; + i++; + } + while(pointB.next !== null) { + pointB = pointB.next; + j++; + } + if(pointB != pointA) { + return null; + } + pointA = headA; + pointB = headB; + + if(i > j) { + while(k < i - j){pointA = pointA.next;k++;} + } else { + while(k < j - i){pointB = pointB.next;k++;} + } + while(pointA != pointB) { + pointA = pointA.next; + pointB = pointB.next; + } + return pointA; +}; +``` + + +### 162. [Find Peak Element](https://leetcode.com/problems/find-peak-element/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ + +function find(nums, low, high) { + if (low === high) { + return low; + } else { + var mid1 = parseInt((low + high) / 2); + var mid2 = mid1 + 1; + + if (nums[mid1] > nums[mid2]) { + return find(nums, low, mid1); + } else { + return find(nums, mid2, high); + } + } +} +var findPeakElement = function(nums) { + return find(nums, 0, nums.length - 1); +}; + +``` + + +### 165. [Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/description/) +```javascript +/** + * @param {string} version1 + * @param {string} version2 + * @return {number} + */ +var compareVersion = function(version1, version2) { + var arr1 = version1.split('.').map(function(item) { + return parseInt(item); + }); + var arr2 = version2.split('.').map(function(item) { + return parseInt(item); + }); + var a, b; + for(var i = 0; i < arr1.length || i < arr2.length; i++) { + a = i >= arr1.length ? 0 : arr1[i]; + b = i >= arr2.length ? 0 : arr2[i]; + if(a > b) { + return 1; + } else if(a < b) { + return -1; + } + } + return 0; +}; +``` + + +### 166. [Fraction to Recurring Decimal](https://leetcode.com/problems/fraction-to-recurring-decimal/description/) +```javascript +/** + * @param {number} numerator + * @param {number} denominator + * @return {string} + */ +var fractionToDecimal = function(numerator, denominator) { + // be divided with no remainder + if (numerator % denominator === 0) { + return String(numerator / denominator); + } + + // plus or minus + var ret = ''; + if (numerator * denominator < 0) ret += '-'; + numerator = Math.abs(numerator); + denominator = Math.abs(denominator); + + // integral part + var remain; + ret += Math.floor(numerator / denominator) + '.'; + remain = numerator % denominator; + + // decimal part + var digit; + var decimal = ''; + var i = 0; + var remainIndexMap = {}; + /* + * remain and the decimal part index + * e.g. 2 / 333 = 0.(006) + * remainIndexMap['2'] = 0; + * remainIndexMap['20'] = 1; + * remainIndexMap['200'] = 2; + * The decimal is 006 + */ + remainIndexMap[remain] = 0; + + while (true) { + remain *= 10; + digit = Math.floor(remain / denominator); + decimal += digit; + remain = remain % denominator; + + if (remainIndexMap[remain] !== undefined) { + ret += `${decimal.slice(0, remainIndexMap[remain])}(${decimal.slice(remainIndexMap[remain])})`; + break; + } else { + remainIndexMap[remain] = ++i; + } + + if (remain === 0) { + ret += decimal; + break; + } + } + + return ret; +}; + + +``` + + +### 167. [Two Sum II - Input array is sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/) +```javascript +/** + * @param {number[]} numbers + * @param {number} target + * @return {number[]} +*/ +var twoSum = function(numbers, target) { + var start = 0; + var end = numbers.length - 1; + + while (start < end) { + if (numbers[start] + numbers[end] === target) { + break; + } else if (numbers[start] + numbers[end] < target) { + start++; + } else { + end--; + } + } + + return [start + 1, end + 1]; +}; + +``` + + +### 168. [Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/description/) +```javascript +/** + * @param {number} n + * @return {string} + */ +var convertToTitle = function(n) { + var ret = '' + while(n > 0) { + n--; + ret = String.fromCharCode(65 + n % 26) + ret; + n = Math.floor(n / 26); + } + return ret; +}; +``` + + +### 169. [Majority Element](https://leetcode.com/problems/majority-element/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var majorityElement = function(nums) { + var count = 1; + var item = nums[0]; + for(var i = 1; i < nums.length; i++) { + if(count === 0) { + count = 1; + item = nums[i]; + } else { + if(nums[i] == item) { + count++; + } else { + count--; + } + } + } + return item; +}; +``` + + +### 170. [Two Sum III - Data structure design](https://leetcode.com/problems/two-sum-iii-data-structure-design/description/) +```python +class TwoSum: + + # initialize your data structure here + def __init__(self): + self.table = dict() + + # @return nothing + def add(self, number): + self.table[number] = self.table.get(number, 0) + 1; + + # @param value, an integer + # @return a Boolean + def find(self, value): + for i in self.table.keys(): + j = value - i + if i == j and self.table.get(i) > 1 or i != j and self.table.get(j, 0) > 0: + return True + return False +``` + + +### 171. [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ +var titleToNumber = function(s) { + var arr = s.split(''); + var digit; + var sum = 0; + for(var i = arr.length - 1, j = 0; i >= 0; i--, j++) { + digit = arr[i].charCodeAt(0) - 64; + sum += digit * Math.pow(26, j) + } + return sum; +}; +``` + + +### 172. [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var trailingZeroes = function(n) { + var sum = 0; + var divisor = 5; + while(n >= divisor) { + sum += Math.floor(n / divisor); + divisor *= 5; + } + return sum; +}; +``` + + +### 173. [Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/) +```javascript +/** + * Definition for binary tree + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ + +/** + * @constructor + * @param {TreeNode} root - root of the binary search tree + */ +var BSTIterator = function(root) { + this.root = root; + this.stack = []; + this._push(this.root); +}; + + +/** + * @this BSTIterator + * @returns {boolean} - whether we have a next smallest number + */ +BSTIterator.prototype.hasNext = function() { + return this.stack.length > 0; +}; + +/** + * @this BSTIterator + * @returns {number} - the next smallest number + */ +BSTIterator.prototype.next = function() { + if (this.stack.length > 0) { + var node = this.stack.pop(); + this._push(node.right); + + return node.val; + } +}; + +BSTIterator.prototype._push = function(curr) { + while (curr) { + this.stack.push(curr); + curr = curr.left; + } +}; + +/** + * Your BSTIterator will be called like this: + * var i = new BSTIterator(root), a = []; + * while (i.hasNext()) a.push(i.next()); +*/ +``` + + +### 179. [Largest Number](https://leetcode.com/problems/largest-number/description/) +```javascript +/** + * @param {number[]} nums + * @return {string} + */ +var largestNumber = function(nums) { + var retStr = nums.sort(function(num1, num2) { + var arr1 = num1 + ''.split(); + var arr2 = num2 + ''.split(); + var len1 = arr1.length; + var len2 = arr2.length; + var a, b; + + for (var i = 0; i < len1 || i < len2; i++) { + a = i >= arr1.length ? arr1[i % len1] : arr1[i]; + b = i >= arr2.length ? arr2[i % len2] : arr2[i]; + if (a != b) { + return b - a; + } + } + + var isRise; + var checkArr = len1 > len2 ? arr1 : arr2; + for (var j = 0; j < checkArr.length - 1; j++) { + if (checkArr[j] != checkArr[j + 1]) { + if (checkArr[j] > checkArr[j + 1]) { + isRise = false; + break; + } else { + isRise = true; + break; + } + } + } + if (isRise) { + return len1 - len2; + } else { + return len2 - len1; + } + + + }).join(''); + + if (retStr[0] == '0') { + return '0'; + } else { + return retStr; + } +}; +``` + + +### 187. [Repeated DNA Sequences](https://leetcode.com/problems/repeated-dna-sequences/description/) +```javascript +/** +* @param {string} s +* @return {string[]} +*/ +var findRepeatedDnaSequences = function(s) { + var ret = []; + var uniqMap = {}; + var valueMap = {}; + var charCodeA = 'A'.charCodeAt(0); + + valueMap['A'.charCodeAt(0) - charCodeA] = 0; + valueMap['C'.charCodeAt(0) - charCodeA] = 1; + valueMap['G'.charCodeAt(0) - charCodeA] = 2; + valueMap['T'.charCodeAt(0) - charCodeA] = 3; + + var bitValue = 0; + var offset = 0; + for (var i = 0; i < s.length - 9; i++) { + for (var j = i; j < i + 10; j++) { + bitValue |= valueMap[s.charCodeAt(j) - charCodeA] << offset; + offset += 2; + } + if (uniqMap[bitValue] === undefined) { + uniqMap[bitValue] = true; + } else if (uniqMap[bitValue] === true) { + ret.push(s.slice(i, 10 + i)); + uniqMap[bitValue] = false; + } + + offset = 0; + bitValue = 0; + } + + return ret; +}; + +``` + + +### 189. [Rotate Array](https://leetcode.com/problems/rotate-array/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {void} Do not return anything, modify nums in-place instead. + */ +var rotate = function(nums, k) { + for(var i = 0; i < k; i++) { + nums.unshift(nums.pop()); + } +}; +``` + + +### 190. [Reverse Bits](https://leetcode.com/problems/reverse-bits/description/) +```c +uint32_t reverseBits(uint32_t n) { + uint32_t mask = 1 << 31; + uint32_t ret = 0; + + for (uint32_t i = 0; i < 32; i++) { + if (n & 1 == 1) { + ret = ret | mask; + } + n = n >> 1; + mask = mask >> 1; + } + + return ret; +} + +``` + + +### 191. [Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/description/) +```javascript +/** + * @param {number} n - a positive integer + * @return {number} + */ +var hammingWeight = function(n) { + var count = 0; + while (n) { + n = n & (n - 1); + count++; + } + + return count; +}; +``` + + +### 198. [House Robber](https://leetcode.com/problems/house-robber/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var rob = function(nums) { + if(nums.length === 0) { + return 0; + } + if(nums.length === 1) { + return nums[0]; + } + + var max = {}; + max[0] = nums[0]; + max[1] = Math.max(nums[0], nums[1]); + for(var i = 2; i < nums.length; i++) { + max[i] = Math.max(max[i - 2] + nums[i], max[i -1]); + } + return max[nums.length - 1]; +}; +``` + + +### 200. [Number of Islands](https://leetcode.com/problems/number-of-islands/description/) +```javascript +/** + * @param {character[][]} grid + * @return {number} + */ +var numIslands = function(grid) { + var m = grid.length; + if (m === 0) return 0; + var n = grid[0].length; + + var island = []; + for (var i = 0; i < m; i++) { + for (var j = 0; j < n; j++) { + if(grid[i][j] === '1') { + island.push([i, j]); + grid[i][j] = false; + } + } + } + function nextUnvisit(island) { + for (var k = 0; k < island.length; k++) { + var [i, j] = island[k]; + if (grid[i][j] === false) { + return [i, j]; + } + } + return null; + } + + var count = 0; + while(nextUnvisit(island) !== null) { + count++; + var queue = []; + queue.push(nextUnvisit(island)); + while (queue.length > 0) { + var [i, j] = queue.pop(); + grid[i][j] = true; + var list = [[-1, 0], [1, 0], [0, -1], [0, 1]]; + for(var key in list) { + var [p, q] = list[key]; + var x = i + p; + var y = j + q; + if (x >= 0 && x < m && y >= 0 && y < n && grid[x][y] === false) { + queue.push([x, y]); + } + } + } + } + + return count; +}; + +``` + + +### 201. [Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/description/) +```javascript +/** + * @param {number} m + * @param {number} n + * @return {number} + */ +var rangeBitwiseAnd = function(m, n) { + var count = 0; + + while (m !== n) { + m = m >> 1; + n = n >> 1; + count++; + } + + return m << count; +}; +``` + + +### 202. [Happy Number](https://leetcode.com/problems/happy-number/description/) +```javascript +/** + * @param {number} n + * @return {boolean} + */ + +var isHappy = function(n) { + var nums = []; + var ret = n; + + var squire = x => Math.pow(parseInt(x), 2); + var add = (prev, cur) => prev + cur; + while(ret !== 1) { + if(nums.indexOf(ret) > -1) { + return false; + } else { + nums.push(ret); + } + digits = ret.toString().split('').map(squire); + ret = digits.reduce(add); + } + return true; +} +``` + + +### 203. [Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} val + * @return {ListNode} + */ +var removeElements = function(head, val) { + while(head && head.val == val) { + head = head.next; + } + + if(!head) { + return head; + } + + var prev = head; + var iter = head.next; + + while(iter) { + if(iter.val == val) { + prev.next = iter.next; + } else { + prev = iter; + } + iter = iter.next; + } + + return head; +}; +``` + + +### 204. [Count Primes](https://leetcode.com/problems/count-primes/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var countPrimes = function(n) { + var isPrime = []; + for (var i = 2; i < n; i++) { + isPrime[i] = true; + } + + for (var i = 2; i * i < n; i++) { + if (isPrime[i]) { + for (var j = i * i; j < n; j += i) { + isPrime[j] = false; + } + } + } + + var count = 0; + for (var i = 2; i < n; i++) { + if (isPrime[i]) { + count++; + } + } + + return count; +}; + +``` + + +### 205. [Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/description/) +```javascript +/** + * @param {string} s + * @param {string} t + * @return {boolean} + */ +var isIsomorphic = function(s, t) { + if (s.length !== t.length) return false; + + var smap = {}; + var tmap = {}; + + for (var i = 0; i < s.length; i++) { + if (smap[s[i]] === undefined && tmap[t[i]] === undefined) { + smap[s[i]] = t[i]; + tmap[t[i]] = s[i]; + } + + if (smap[s[i]] !== t[i] || tmap[t[i]] !== s[i] ){ + return false; + } + } + + return true; +}; +``` + + +### 206. [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var reverseList = function(head) { + if (head === null || head.next === null) return head; + + var prev = head; + var p = head.next; + var tmp; + + head.next = null; + while (p !== null) { + tmp = p.next; + p.next = prev; + prev = p; + p = tmp; + } + + return prev; +}; +``` + + +### 208. [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/description/) +```python +class Node(object): + def __init__(self, val): + self.isEnd = False + self.val = val + self.dict = {} + +class Trie(object): + + def __init__(self): + """ + Initialize your data structure here. + """ + self.root = Node('root') + + def insert(self, word): + """ + Inserts a word into the trie. + :type word: str + :rtype: void + """ + + cur = self.root + for i in word: + if cur.dict.get(i) == None: + cur.dict[i] = Node(i) + cur = cur.dict[i] + + cur.isEnd = True + + def search(self, word): + """ + Returns if the word is in the trie. + :type word: str + :rtype: bool + """ + cur = self.root; + for i in word: + if cur.dict.get(i): + cur = cur.dict[i] + else: + return False + + return cur.isEnd + + def startsWith(self, prefix): + """ + Returns if there is any word in the trie that starts with the given prefix. + :type prefix: str + :rtype: bool + """ + cur = self.root + for i in prefix: + if cur.dict.get(i): + cur = cur.dict[i] + else: + return False + return True + + +# Your Trie object will be instantiated and called as such: +# obj = Trie() +# obj.insert(word) +# param_2 = obj.search(word) +# param_3 = obj.startsWith(prefix) +``` + + +### 217. [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/description/) +```javascript +/** + * @param {number[]} nums + * @return {boolean} + */ +var containsDuplicate = function(nums) { + for(var i = 0; i < nums.length; i++) { + for(var j = i + 1 ; j < nums.length; j++) { + if(nums[i] == nums[j]) { + return true; + } + } + } + return false; +}; +``` + + +### 219. [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {boolean} + */ + /* +var containsNearbyDuplicate = function(nums, k) { + for(var i = 0; i < nums.length; i++) { + for(var j = i + 1; j < nums.length && j - i <= k; j++) { + if(nums[i] === nums[j]) { + return true; + } + } + } + return false; +}; +*/ + +var containsNearbyDuplicate = function(nums, k) { + var index = {}; + var value; + for(var i = 0; i < nums.length; i++) { + value = nums[i]; + if(index[value] === undefined) { + index[value] = [i]; + } else if(i - index[value][index[value].length - 1] <= k){ + return true; + } else { + index[value].push(i); + } + } + return false; +} +``` + + +### 223. [Rectangle Area](https://leetcode.com/problems/rectangle-area/description/) +```javascript +/** + * @param {number} A + * @param {number} B + * @param {number} C + * @param {number} D + * @param {number} E + * @param {number} F + * @param {number} G + * @param {number} H + * @return {number} + */ +var computeArea = function(A, B, C, D, E, F, G, H) { + var areaA = (C-A) * (D-B); + var areaB = (G-E) * (H-F); + + var left = Math.max(A, E); + var right = Math.min(G, C); + var bottom = Math.max(F, B); + var top = Math.min(D, H); + + var overlap = 0; + + if(right > left && top > bottom) { + overlap = (right - left) * (top - bottom); + } + return areaA + areaB - overlap; +}; +``` + + +### 225. [Implement Stack using Queues](https://leetcode.com/problems/implement-stack-using-queues/description/) +```python +class MyStack(object): + + def __init__(self): + """ + Initialize your data structure here. + """ + self.queue = [] + + def push(self, x): + """ + Push element x onto stack. + :type x: int + :rtype: void + """ + self.queue.append(x) + for i in range(len(self.queue) - 1): + self.queue.append(self.queue.pop(0)) + + + def pop(self): + """ + Removes the element on top of the stack and returns that element. + :rtype: int + """ + return self.queue.pop(0) + + def top(self): + """ + Get the top element. + :rtype: int + """ + return self.queue[0] + + def empty(self): + """ + Returns whether the stack is empty. + :rtype: bool + """ + return len(self.queue) == 0 + + + +# Your MyStack object will be instantiated and called as such: +# obj = MyStack() +# obj.push(x) +# param_2 = obj.pop() +# param_3 = obj.top() +# param_4 = obj.empty() +``` + + +### 226. [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {TreeNode} + */ +var invertTree = function(root) { + if(root !== null) { + var tmp; + tmp = root.left; + root.left = root.right; + root.right = tmp; + + invertTree(root.left); + invertTree(root.right); + } + return root; +}; +``` + + +### 228. [Summary Ranges](https://leetcode.com/problems/summary-ranges/description/) +```javascript +/** + * @param {number[]} nums + * @return {string[]} + */ +var summaryRanges = function(nums) { + if(nums.length === 0) { + return nums; + } + + var ret = []; + var start = 0; + + for(var i = 1; i < nums.length; i++) { + if(nums[i] - nums[i-1] != 1) { + ret.push(nums.slice(start, i)); + start = i; + } + } + ret.push(nums.slice(start)); + + ret = ret.map(function(item) { + if(item.length > 1) { + return item[0] + '->' + item[item.length - 1]; + } else { + return item[0] + ''; + } + }); + + return ret; +}; +``` + + +### 231. [Power of Two](https://leetcode.com/problems/power-of-two/description/) +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var isPowerOfTwo = function(n) { + if(n === 0) return false; + while(n !== 1) { + if(n % 2 === 0) { + n = n / 2; + } else { + return false; + } + } + return true; +}; +``` + + +### 232. [Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/description/) +```javascript +/** + * @constructor + */ +var Queue = function() { + this.stack1 = []; + this.stack2 =[]; +}; + +/** + * @param {number} x + * @returns {void} + */ +Queue.prototype.push = function(x) { + this.stack1.push(x); +}; + +/** + * @returns {void} + */ +Queue.prototype.pop = function() { + if(this.stack2.length > 0) { + return this.stack2.pop(); + } + if(this.stack1.length > 0) { + while(this.stack1.length > 0) { + this.stack2.push(this.stack1.pop()); + } + return this.stack2.pop(); + } + return null; +}; + +/** + * @returns {number} + */ +Queue.prototype.peek = function() { + if(this.stack2.length > 0) { + return this.stack2[this.stack2.length - 1]; + } + if(this.stack1.length > 0) { + return this.stack1[0]; + } + return null; +}; + +/** + * @returns {boolean} + */ +Queue.prototype.empty = function() { + return this.stack1.length === 0 && this.stack2.length === 0; +}; +``` + + +### 234. [Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {boolean} + */ +var isPalindrome = function(head) { + function reverseList(head) { + if(!head) { + return head; + } + var prev = null; + var next = null; + while(head) { + next = head.next; + head.next = prev; + prev = head; + head = next; + } + return prev; + } + if(!head || !head.next ) { + return true; + } + var slow = head; + var fast = head; + while(fast && fast.next && fast.next.next) { + slow = slow.next; + fast = fast.next.next; + } + + slow.next = reverseList(slow.next); + slow = slow.next; + + while(slow) { + if(head.val !== slow.val) { + return false; + } + head = head.next; + slow = slow.next; + } + + return true; +}; +``` + + +### 235. [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {TreeNode} p + * @param {TreeNode} q + * @return {TreeNode} + */ +var lowestCommonAncestor = function(root, p, q) { + var tmp; + if(p.val > q.val) { + tmp = p; + p = q; + q = tmp; + } + if(root.val >= p.val && root.val <= q.val) { + return root; + }else if(p.val < root.val & q.val < root.val) { + return lowestCommonAncestor(root.left, p, q); + } else if(p.val > root.val && q.val > root.val){ + return lowestCommonAncestor(root.right, p, q); + } +}; +``` + + +### 237. [Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} node + * @return {void} Do not return anything, modify node in-place instead. + */ +var deleteNode = function(node) { + node.val = node.next.val; + node.next = node.next.next; +}; +``` + + +### 238. [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[]} + */ +var productExceptSelf = function(nums) { + var zeroCount = 0; + var products = nums + .filter((num) => { + if(num === 0) zeroCount++; + return num !== 0; + }) + .reduce((prev, curr) => prev * curr, 1); + return nums.map((num) => { + if(zeroCount >= 2) { + return 0; + } + if(zeroCount === 1) { + return num === 0 ? products : 0; + } + return products / num; + + }); +}; +``` + + +### 242. [Valid Anagram](https://leetcode.com/problems/valid-anagram/description/) +```javascript +/** + * @param {string} s + * @param {string} t + * @return {boolean} + */ +var isAnagram = function(s, t) { + var arr1 = s.split('').sort(); + var arr2 = t.split('').sort(); + if(arr1.length !== arr2.length) { + return false; + } + for(var i = 0; i < arr1.length; i++) { + if(arr1[i] !== arr2[i]) { + return false; + } + } + return true; +}; +``` + + +### 243. [Shortest Word Distance](https://leetcode.com/problems/shortest-word-distance/description/) +```python +import sys +class Solution(object): + def shortestDistance(self, words, word1, word2): + """ + :type words: List[str] + :type word1: str + :type word2: str + :rtype: int + """ + index1 = index2 = None + minDist = sys.maxint + + for k, v in enumerate(words): + if v == word1: + index1 = k + if v == word2: + index2 = k + if index1 != None and index2 != None: + minDist = min(minDist, abs(index1 - index2)) + + return minDist +``` + + +### 244. [Shortest Word Distance II](https://leetcode.com/problems/shortest-word-distance-ii/description/) +```python +import sys +class WordDistance(object): + + def __init__(self, words): + """ + :type words: List[str] + """ + self.position = {} + for index, word in enumerate(words): + self.position[word] = self.position.get(word, []) + [index] + + def shortest(self, word1, word2): + """ + :type word1: str + :type word2: str + :rtype: int + """ + l1, l2 = self.position[word1], self.position[word2] + i = j = 0 + res = sys.maxint + + while i < len(l1) and j < len(l2): + res = min(res, abs(l1[i] - l2[j])) + if l1[i] < l2[j]: + i += 1 + else: + j += 1 + return res + + + +# Your WordDistance object will be instantiated and called as such: +# obj = WordDistance(words) +# param_1 = obj.shortest(word1,word2) +``` + + +### 257. [Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {string[]} + */ +var binaryTreePaths = function(root) { + if(root === null) { + return []; + } + var ret = []; + var str = arguments[1] ? arguments[1] : ''; + if(str) { + str = str + '->' + root.val; + } else { + str = root.val + ''; + } + if(root.left === null && root.right === null) { + ret.push(str); + } + + if(root.left) { + var leftRet = binaryTreePaths(root.left, str); + Array.prototype.push.apply(ret, leftRet); + } + if(root.right) { + var rightRet = binaryTreePaths(root.right, str); + Array.prototype.push.apply(ret, rightRet); + } + return ret; +}; +``` + + +### 258. [Add Digits](https://leetcode.com/problems/add-digits/description/) +```javascript +/** + * @param {number} num + * @return {number} + */ +var addDigits = function(num) { + return 1 + (num - 1) % 9; +}; +``` + + +### 263. [Ugly Number](https://leetcode.com/problems/ugly-number/description/) +```javascript +/** + * @param {number} num + * @return {boolean} + */ +var isUgly = function(num) { + if(num <= 0) { + return false; + } + while(num % 2 === 0) {num /= 2;} + while(num % 3 === 0) {num /= 3;} + while(num % 5 === 0) {num /= 5;} + return num === 1 ? true : false; +}; +``` + + +### 268. [Missing Number](https://leetcode.com/problems/missing-number/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var missingNumber = function(nums) { + return (0 + nums.length) * (nums.length + 1) / 2 - nums.reduce((p, c) => p + c, 0); +}; +``` + + +### 278. [First Bad Version](https://leetcode.com/problems/first-bad-version/description/) +```javascript +/** + * Definition for isBadVersion() + * + * @param {integer} version number + * @return {boolean} whether the version is bad + * isBadVersion = function(version) { + * ... + * }; + */ + +/** + * @param {function} isBadVersion() + * @return {function} + */ +var solution = function(isBadVersion) { + /** + * @param {integer} n Total versions + * @return {integer} The first bad version + */ + return function(n) { + var start = 1; + var end = n; + var middle; + while (start <= end) { + middle = start + Math.floor((end - start) / 2); + if (middle + 1 <= n && !isBadVersion(middle) && isBadVersion(middle + 1)) { + return middle + 1; + } + if (middle - 1 > 0 && !isBadVersion(middle - 1) && isBadVersion(middle)) { + return middle + } + if (middle === 1 && isBadVersion(middle)) { + return middle; + } + if (isBadVersion(middle)) { + end = middle - 1; + } else { + start = middle + 1; + } + } + return 'null'; + }; +}; +``` + + +### 281. [Zigzag Iterator](https://leetcode.com/problems/zigzag-iterator/description/) +```python +class ZigzagIterator(object): + + def __init__(self, v1, v2): + self.data = [(len(v), iter(v)) for v in (v1, v2) if v] + + def next(self): + len, iter = self.data.pop(0) + if len > 1: + self.data.append((len-1, iter)) + return next(iter) + + def hasNext(self): + return bool(self.data) +``` + + +### 283. [Move Zeroes](https://leetcode.com/problems/move-zeroes/description/) +```javascript +/** + * @param {number[]} nums + * @return {void} Do not return anything, modify nums in-place instead. + */ +var moveZeroes = function(nums) { + var sum = 0; + for(var i = nums.length - 1; i >=0; i--) { + if(nums[i] === 0) { + nums.splice(i,1); + sum++; + } + } + [].push.apply(nums, new Array(sum).fill(0)) +}; +``` + + +### 290. [Word Pattern](https://leetcode.com/problems/word-pattern/description/) +```javascript +/** + * @param {string} pattern + * @param {string} str + * @return {boolean} + */ +var wordPattern = function(pattern, str) { + var s = pattern; + var t = str.split(' '); + if (s.length !== t.length) return false; + + var smap = {}; + var tmap = {}; + + for (var i = 0; i < s.length; i++) { + if (smap[s[i]] === undefined && tmap[t[i]] === undefined) { + smap[s[i]] = t[i]; + tmap[t[i]] = s[i]; + } + + if (smap[s[i]] !== t[i] || tmap[t[i]] !== s[i] ){ + return false; + } + } + + return true; +}; +``` + + +### 292. [Nim Game](https://leetcode.com/problems/nim-game/description/) +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var canWinNim = function(n) { + return !(n !== 0 && n%4 === 0); +}; +``` + + +### 295. [Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/description/) +```python +import Queue + +class MedianFinder(object): + + def __init__(self): + """ + initialize your data structure here. + """ + self.small = Queue.PriorityQueue() + self.large = Queue.PriorityQueue() + + + def addNum(self, num): + """ + :type num: int + :rtype: void + """ + self.small.put(num) + self.large.put(-self.small.get()) + + if self.small.qsize() < self.large.qsize(): + self.small.put(-self.large.get()) + + + def findMedian(self): + """ + :rtype: float + """ + if self.small.qsize() > self.large.qsize(): + return float(self.small.queue[0]) + else: + return (float(self.small.queue[0] - self.large.queue[0])) / 2 + + + + +# Your MedianFinder object will be instantiated and called as such: +# obj = MedianFinder() +# obj.addNum(num) +# param_2 = obj.findMedian() +``` + + +### 297. [Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/) +```python +class Codec: + + def serialize(self, root): + """Encodes a tree to a single string. + + :type root: TreeNode + :rtype: str + """ + if root == None: + return [] + left = self.serialize(root.left) + right = self.serialize(root.right) + + if len(right) == 0 and len(left) == 0: + return [root.val] + elif len(right) == 0: + return [root.val, left]; + else: + return [root.val, left, right]; + + # 1[2,3[4,5]] + def deserialize(self, data): + """Decodes your encoded data to tree. + + :type data: str + :rtype: TreeNode + """ + if data == []: + return + + if data == None: + return + elif isinstance(data, int): + return TreeNode(data) + elif isinstance(data, list): + root = TreeNode(data[0]) + if (len(data) > 1): + root.left = self.deserialize(data[1]) + if (len(data) > 2): + root.right = self.deserialize(data[2]) + return root + +``` + + +### 298. [Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/description/) +```python +# Definition for a binary tree node. +# class TreeNode(object): +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution(object): + def longestConsecutive(self, root): + """ + :type root: TreeNode + :rtype: int + """ + if root == None: + return 0 + + self.maxLen = 1 + self.find(root, root.val, 1) + return self.maxLen + + def find(self, node, value, len): + if node.left: + if node.left.val == value + 1: + self.maxLen = max(self.maxLen, len + 1) + self.find(node.left, node.left.val, len + 1) + else: + self.find(node.left, node.left.val, 1) + + if node.right: + if node.right.val == value + 1: + self.maxLen = max(self.maxLen, len + 1) + self.find(node.right, node.right.val, len + 1) + else: + self.find(node.right, node.right.val, 1) +``` + + +### 303. [Range Sum Query - Immutable](https://leetcode.com/problems/range-sum-query-immutable/description/) +```javascript +/** + * @param {number[]} nums + */ +var NumArray = function(nums) { + this.dp = []; + this.dp[0] = nums[0]; + for (var i = 1; i < nums.length; i++) { + this.dp[i] = this.dp[i - 1] + nums[i]; + } +}; + +/** + * @param {number} i + * @param {number} j + * @return {number} + */ +NumArray.prototype.sumRange = function(i, j) { + return this.dp[j] - (i === 0 ? 0 : this.dp[i - 1]); +}; + +/** + * Your NumArray object will be instantiated and called as such: + * var obj = Object.create(NumArray).createNew(nums) + * var param_1 = obj.sumRange(i,j) + */ +``` + + +### 307. [Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/description/) +```javascript +/** + * @param {number[]} nums + */ +var NumArray = function(nums) { + this.nums = [0].concat(nums); + this.BIT = [0]; + for (var i = 1; i < this.nums.length; i++) { + this.BIT[i] = 0; + for (var j = i - this.lowestbit(i) + 1; j <= i; j++) { + this.BIT[i] += this.nums[j]; + } + } +}; + +// lowestbit 指将i转为二进制后,最后一个1的位置所代表的数值 +NumArray.prototype.lowestbit = function(v) { + return (v & -v); +}; +/** +* @param {number} i +* @param {number} val +* @return {void} +*/ + +// (1)假如i是左子节点，那么其父节点下标为i+(lowestbit(i)) +// (2)假如i是右子节点，那么其父节点下标为i-(lowestbit(i)) +// 更新BIT[i], 以及包含了num[i]的BIT, 也就是i的右父节点 +NumArray.prototype.update = function(i, val) { + var k = i + 1; + var delta = val - this.nums[k]; + this.nums[k] = val; + while (k < this.nums.length) { + this.BIT[k] += delta; + k = k + this.lowestbit(k); + } +}; + +// 求当前结点，以及它的所有右侧父节点 +NumArray.prototype.sumLeft = function(i) { + var sum = 0; + while (i > 0) { + sum += this.BIT[i]; + i = i - this.lowestbit(i); + } + return sum; +}; +/** +* @param {number} i +* @param {number} j +* @return {number} +*/ +NumArray.prototype.sumRange = function(i, j) { + return this.sumLeft(j + 1) - this.sumLeft(i); +}; + +/** +* Your NumArray object will be instantiated and called as such: +* var obj = Object.create(NumArray).createNew(nums) +* obj.update(i,val) +* var param_2 = obj.sumRange(i,j) +*/ +``` + + +### 312. [Burst Balloons](https://leetcode.com/problems/burst-balloons/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +function brust(memo, nums, left, right) { + if (memo[left][right] !== undefined) { + return memo[left][right]; + } + + var max = 0; + for (var i = left + 1; i < right; i++) { + max = Math.max(max, + nums[left] * nums[i] * nums[right] + + brust(memo, nums, left, i) + + brust(memo, nums, i, right)); + } + memo[left][right] = max; + + return max; +} + +var maxCoins = function(nums) { + // delete 0, and 1 in front and end + nums = [1].concat(nums.filter(item => { + return item !== 0; + })).concat(1); + + // init the memo + var memo = []; + for (var i = 0; i < nums.length; i++) { + memo.push(new Array(nums.length)); + } + + return brust(memo, nums, 0, nums.length - 1); +}; + +``` + + +### 319. [Bulb Switcher](https://leetcode.com/problems/bulb-switcher/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var bulbSwitch = function(n) { + return parseInt(Math.sqrt(n)); +}; +``` + + +### 326. [Power of Three](https://leetcode.com/problems/power-of-three/description/) +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var isPowerOfThree = function(n) { + while(true) { + if(n === 1) { + return true; + } + if(n === 0 || n === 2) { + return false; + } + if(n % 3 !== 0) { + return false; + } else { + n = n / 3; + } + } + return true; +}; +``` + + +### 328. [Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var oddEvenList = function(head) { + if(head === null) { + return null; + } + var second = head.next; + + var odd = head; + var even = head.next; + while(odd && odd.next && odd.next.next) { + odd.next = even.next; + odd = odd.next; + if(odd) { + even.next = odd.next; + even = even.next; + } + } + odd.next = second; + return head; +}; +``` + + +### 338. [Counting Bits](https://leetcode.com/problems/counting-bits/description/) +```javascript +var countBits = function(num) { + var dp = [0]; + for (var i = 1; i <= num; i++) { + dp[i] = i % 2 === 0 ? dp[i / 2] : dp[(i - 1) / 2] + 1; + } + + return dp +}; +``` + + +### 340. [Longest Substring with At Most K Distinct Characters](https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/description/) +```javascript +/** + * @param {string} s + * @param {number} k + * @return {number} + */ +var lengthOfLongestSubstringKDistinct = function(s, k) { + var map = {}; + var j = 0; + var maxLen = 0; + var charCount = 0; + var low, high; + + for (var i = 0; i < s.length; i++) { + var char = s[i]; + + if (map[char] === undefined || map[char] === 0) { + map[char] = 1; + charCount++; + } else { + map[char]++; + } + + if (charCount <= k && i - j + 1> maxLen) { + low = j; + high = i; + maxLen = i - j + 1; + } + if (charCount > k) { + while (charCount > k) { + var tail = s[j]; + map[tail]--; + if (map[tail] === 0) { + charCount--; + } + j++; + } + } + } + + // the longest string: s.slice(low, high + 1) + return maxLen; +}; + +``` + + +### 342. [Power of Four](https://leetcode.com/problems/power-of-four/description/) +```javascript +/** + * @param {number} num + * @return {boolean} + + +var isPowerOfFour = function(num) { + return num > 0 && (num & (num - 1)) === 0 && (num & 0x55555555) !== 0; +}; + */ + +var isPowerOfFour = function(num) { + if (num < 1) { + return false; + } else if (num === 1) { + return true; + } else if (num % 4 !== 0) { + return false; + } else { + return isPowerOfFour(num / 4); + } +}; +``` + + +### 343. [Integer Break](https://leetcode.com/problems/integer-break/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var integerBreak = function(n) { + var maxArr = { + 1: 1, + 2: 1, + }; + var maxValue = null; + var value = null; + + for(var i = 3; i <= n; i++) { + maxValue = Number.MIN_SAFE_INTEGER; + for(var j = 1; j <= i / 2; j++) { + value = Math.max(j, maxArr[j]) * Math.max(i - j, maxArr[i - j]); + if(value > maxValue) { + maxValue = value; + } + } + maxArr[i] = maxValue; + } + + return maxArr[n]; +}; +``` + + +### 344. [Reverse String](https://leetcode.com/problems/reverse-string/description/) +```javascript +/** + * @param {string} s + * @return {string} + */ +var reverseString = function(s) { + return s.split('').reverse().join(''); +}; +``` + + +### 345. [Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/description/) +```javascript +/** + * @param {string} s + * @return {string} + */ +var reverseVowels = function(s) { + s = s.split(''); + var vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']; + var start = -1; + var end = s.length; + var temp; + + while (start < end) { + while (start < end && vowels.indexOf(s[++start]) === -1); + while (start < end && vowels.indexOf(s[--end]) === -1); + temp = s[start]; + s[start] = s[end]; + s[end] = temp; + } + + return s.join(''); +}; +``` + + +### 346. [Moving Average from Data Stream](https://leetcode.com/problems/moving-average-from-data-stream/description/) +```python +class MovingAverage(object): + + def __init__(self, size): + """ + Initialize your data structure here. + :type size: int + """ + self.size = size + self.queue = [] + self.count = 0 + self.sum = 0.0 + + + def next(self, val): + """ + :type val: int + :rtype: float + """ + self.count += 1 + self.queue.append(val) + self.sum += val + + if self.count > self.size: + self.sum -= self.queue[0] + self.queue.pop(0) + + return self.sum / min(self.size, self.count) + + + +# Your MovingAverage object will be instantiated and called as such: +# obj = MovingAverage(size) +# param_1 = obj.next(val) +``` + + +### 347. [Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {number[]} + */ + +function SortNumber(size) { + this.size = size; + this.container = []; +} +SortNumber.prototype.setCompare = function(compare) { + this.compare = compare; +} +SortNumber.prototype.getMax = function() { + return this.max; +} +SortNumber.prototype.getMin = function() { + return this.min; +} +SortNumber.prototype.getAll = function() { + return this.container; +} +SortNumber.prototype.setBigNumber = function(num) { + if (this.container.length < this.size) { + this.container.push(num); + } else if (this.compare(this.min, num) < 0) { + this.container.shift(); + this.container.push(num); + } else { + return; + } + + this.container.sort(this.compare); + this.max = this.container[this.container.length - 1]; + this.min = this.container[0]; +} + +var topKFrequent = function(nums, k) { + var topNumber = new SortNumber(k); + topNumber.setCompare((a, b) => a.count - b.count); + var showTimes = {}; + nums.map((num) => { + if(showTimes[num]) { + showTimes[num]++; + } else { + showTimes[num] = 1; + } + }); + for(var num in showTimes) { + topNumber.setBigNumber({ + value: num, + count: showTimes[num], + }); + } + + return topNumber.getAll().map((item) => parseInt(item.value)); +}; +``` + + +### 348. [Design Tic-Tac-Toe](https://leetcode.com/problems/design-tic-tac-toe/description/) +```python +class TicTacToe(object): + + def __init__(self, n): + """ + Initialize your data structure here. + :type n: int + """ + self.row = [0] * n + self.col = [0] * n + self.diagonal = 0 + self.antiDiagonal = 0 + self.size = n + + + def move(self, row, col, player): + """ + Player {player} makes a move at ({row}, {col}). + @param row The row of the board. + @param col The column of the board. + @param player The player, can be either 1 or 2. + @return The current winning condition, can be either: + 0: No one wins. + 1: Player 1 wins. + 2: Player 2 wins. + :type row: int + :type col: int + :type player: int + :rtype: int + """ + weight = 1 if player == 1 else -1 + self.col[col] += weight + self.row[row] += weight + if col == row: + self.diagonal += weight + if col + row == self.size - 1: + self.antiDiagonal += weight + + if self.size in [self.col[col], self.row[row], self.diagonal, self.antiDiagonal]: + return 1 + elif -self.size in [self.col[col], self.row[row], self.diagonal, self.antiDiagonal]: + return 2 + else: + return 0 + + +# Your TicTacToe object will be instantiated and called as such: +# obj = TicTacToe(n) +# param_1 = obj.move(row,col,player) +``` + + +### 349. [Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/description/) +```javascript +/** + * @param {number[]} nums1 + * @param {number[]} nums2 + * @return {number[]} + */ + +var intersection = function (nums1, nums2) { + var ret = []; + for (var i = 0; i < nums1.length; i++) { + for (var j = 0; j < nums2.length; j++) { + if (nums1[i] == nums2[j] && ret.indexOf(nums1[i]) === -1) { + ret.push(nums1[i]); + break; + } + } + } + return ret; +} +``` + + +### 350. [Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/description/) +```javascript +/** + * @param {number[]} nums1 + * @param {number[]} nums2 + * @return {number[]} + */ +var intersect = function(nums1, nums2) { + var map = {}; + var ret = []; + + nums1.forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + nums2.forEach(i => { + if(map[i] !== undefined && map[i] > 0) { + ret.push(i); + map[i]--; + } + }); + + return ret; +}; +``` + + +### 357. [Count Numbers with Unique Digits](https://leetcode.com/problems/count-numbers-with-unique-digits/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var countNumbersWithUniqueDigits = function(n) { + var dp = []; + var ret = 0; + + dp[0] = 1; + dp[1] = 9; + for (var i = 2; i <= 10; i++) { + dp[i] = dp[i - 1] * (11 - i); + } + for (var i = 0; i <= Math.min(10, n); i++) { + ret += dp[i]; + } + + return ret; +}; + +``` + + +### 361. [Bomb Enemy](https://leetcode.com/problems/bomb-enemy/description/) +```python +class Solution(object): + def maxKilledEnemies(self, grid): + """ + :type grid: List[List[str]] + :rtype: int + """ + if grid == None or len(grid) == 0 or len(grid[0]) == 0: + return 0 + ret = 0 + colCount = {} + rowCount = 0 + for i in range(len(grid)): + for j in range(len(grid[0])): + if j == 0 or grid[i][j - 1] == 'W': + rowCount = self.getRowCount(grid, i, j) + if i == 0 or grid[i - 1][j] == 'W': + colCount[j] = self.getColCount(grid, i, j) + if grid[i][j] == '0': + ret = max(rowCount + colCount[j], ret) + + return ret + def getRowCount(self, grid, i, j): + count = 0 + while j < len(grid[0]) and grid[i][j] != 'W': + if grid[i][j] == 'E': + count += 1 + j += 1 + return count + def getColCount(self, grid, i, j): + count = 0 + while i < len(grid) and grid[i][j] != 'W': + if grid[i][j] == 'E': + count += 1 + i += 1 + return count + +``` + + +### 362. [Design Hit Counter](https://leetcode.com/problems/design-hit-counter/description/) +```python +class HitCounter(object): + + def __init__(self): + """ + Initialize your data structure here. + """ + self.time = [None] * 300 + self.hits = [0] * 300 + + def hit(self, timestamp): + """ + Record a hit. + @param timestamp - The current timestamp (in seconds granularity). + :type timestamp: int + :rtype: void + """ + index = timestamp % 300 + if self.time[index] != timestamp: + self.time[index] = timestamp + self.hits[index] = 1 + else: + self.hits[index] += 1 + + + def getHits(self, timestamp): + """ + Return the number of hits in the past 5 minutes. + @param timestamp - The current timestamp (in seconds granularity). + :type timestamp: int + :rtype: int + """ + total = 0 + for i in range(300): + if self.time[i] != None and timestamp - self.time[i] < 300: + total += self.hits[i] + + return total +``` + + +### 367. [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/description/) +```javascript +/** + * @param {number} num + * @return {boolean} + */ +var isPerfectSquare = function(num) { + if (num < 1) return false; + if (num === 1) return true; + + var start = 0; + var end = num; + var middle = num / 2; + + while (start <= end) { + if (parseInt(num / middle) === middle && num % middle === 0) { + return true; + } else if (num / middle > middle) { + start = middle + 1; + } else if (num / middle < middle) { + end = middle - 1; + } + middle = parseInt((start + end) / 2); + } + + return false; +}; +``` + + +### 371. [Sum of Two Integers](https://leetcode.com/problems/sum-of-two-integers/description/) +```javascript +/** + * @param {number} a + * @param {number} b + * @return {number} + */ +/* +var getSum = function(a, b) { + if (b === 0) { + return a; + } else { + return getSum(a ^ b, (a & b) << 1 ); + } +}; +*/ + +var getSum = function(a, b) { + var tmp; + + while (b !== 0) { + tmp = a ^ b; + b = (a & b) << 1; + a = tmp; + } + + return a; +}; +``` + + +### 374. [Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/description/) +```java +/* The guess API is defined in the parent class GuessGame. + @param num, your guess + @return -1 if my number is lower, 1 if my number is higher, otherwise return 0 + int guess(int num); */ + +public class Solution extends GuessGame { + public int guessNumber(int n) { + int start = 1; + int end = n; + int middle; + + while (start <= end) { + middle = (end - start) / 2 + start; + if (guess(middle) == 0) { + return middle; + } else if (guess(middle) > 0) { + start = middle + 1; + } else { + end = middle - 1; + } + } + return 0; + } +} +``` + + +### 382. [Linked List Random Node](https://leetcode.com/problems/linked-list-random-node/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param head The linked list's head. + Note that the head is guaranteed to be not null, so it contains at least one node. + * @param {ListNode} head + */ +var Solution = function(head) { + this.head = head; +}; + +/** + * Returns a random node's value. + * @return {number} + */ +Solution.prototype.getRandom = function() { + var ret = this.head.val; + var p = this.head.next; + var i = 2; + while (p !== null) { + var random = Math.ceil(Math.random() * i); + if (random === 1) { + ret = p.val; + } + i++; + p = p.next; + } + + return ret; +}; + +/** + * Your Solution object will be instantiated and called as such: + * var obj = Object.create(Solution).createNew(head) + * var param_1 = obj.getRandom() + */ +``` + + +### 383. [Ransom Note](https://leetcode.com/problems/ransom-note/description/) +```javascript +/** + * @param {string} ransomNote + * @param {string} magazine + * @return {boolean} + */ +var canConstruct = function(ransomNote, magazine) { + var map = {}; + var flag = true; + + magazine.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + ransomNote.split('').forEach(i => { + if(map[i] === undefined || map[i] === 0) { + flag = false; + } else { + map[i]--; + } + }); + + return flag; +}; +``` + + +### 384. [Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/description/) +```javascript +/** + * @param {number[]} nums + */ +var Solution = function(nums) { + this.nums = nums; +}; + +/** + * Resets the array to its original configuration and return it. + * @return {number[]} + */ +Solution.prototype.reset = function() { + return this.nums; +}; + +/** + * Returns a random shuffling of the array. + * @return {number[]} + */ + +/* Fisher–Yates shuffle +-- To shuffle an array a of n elements (indices 0..n-1): +for i from n−1 downto 1 do + j ← random integer such that 0 ≤ j ≤ i + exchange a[j] and a[i] +*/ +Solution.prototype.shuffle = function() { + var nums = this.nums.slice(); + var tmp, rand; + for (var i = nums.length - 1; i >= 0; i--) { + rand = Math.floor(Math.random() * (i + 1)); + tmp = nums[i]; + nums[i] = nums[rand]; + nums[rand] = tmp; + } + + return nums; +}; + +/** + * Your Solution object will be instantiated and called as such: + * var obj = Object.create(Solution).createNew(nums) + * var param_1 = obj.reset() + * var param_2 = obj.shuffle() + */ +``` + + +### 387. [First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ +var firstUniqChar = function(s) { + var map = {}; + + s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + for(var i = 0; i < s.length; i++) { + if(map[s[i]] === 1) { + return i; + } + } + + return -1; + +}; +``` + + +### 389. [Find the Difference](https://leetcode.com/problems/find-the-difference/description/) +```javascript +/** + * @param {string} s + * @param {string} t + * @return {character} + */ +var findTheDifference = function(s, t) { + if(!s) return t; + var sSum = s.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); + var tSum = t.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); + return String.fromCharCode(tSum - sSum); +}; +``` + + +### 392. [Is Subsequence](https://leetcode.com/problems/is-subsequence/description/) +```javascript +/** + * @param {string} s + * @param {string} t + * @return {boolean} + */ +var isSubsequence = function(s, t) { + var j = 0; + + for (var i = 0; i < t.length; i++) { + target = s[j]; + if(t[i] === target) { + j++; + } + if(j === s.length) { + break; + } + } + + if (j === s.length) { + return true; + } else { + return false; + } +}; +``` + + +### 394. [Decode String](https://leetcode.com/problems/decode-string/description/) +```python +class Solution(object): + def decodeString(self, s): + while '[' in s: + s = re.sub(r'(\d+)\[([a-z]*)\]', + lambda m: int(m.group(1)) * m.group(2), s) + return s + +``` + + +### 400. [Nth Digit](https://leetcode.com/problems/nth-digit/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var findNthDigit = function(n) { + var length = 1; + var count = 9; + var digits = 9; + + while (n > digits) { + length++; + count *= 10; + digits += length * count; + } + n = n - (digits - length * count); + + var position = Math.ceil(n / length); + var number = Math.pow(10, (length - 1)) + position - 1; + + if (n % length === 0) { + return number % 10; + } else { + return parseInt(String(number)[n % length - 1]); + } +}; + +``` + + +### 401. [Binary Watch](https://leetcode.com/problems/binary-watch/description/) +```javascript +/** + * @param {number} num + * @return {string[]} + */ + +var bitcount1 = function (num) { + return (num).toString(2).split('').filter(i => i === '1').length; +} +var formatTime = function(h, m) { + if (m < 10) { + return `${h}:0${m}` + } else { + return `${h}:${m}` + } +} + +var readBinaryWatch = function(num) { + var ret = []; + + for (var h = 0; h < 12; h++) { + for (var m = 0; m < 60; m++) { + if(bitcount1(h << 6 | m) === num) { + ret.push(formatTime(h, m)); + } + } + } + + return ret; +}; +``` + + +### 404. [Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var sumOfLeftLeaves = function(root) { + if(root === null) return 0; + + if(root.left !== null && root.left.left === null && root.left.right === null) { + return root.left.val + sumOfLeftLeaves(root.right); + } else { + return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right); + } +}; +``` + + +### 406. [Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/description/) +```javascript +/** + * @param {number[][]} people + * @return {number[][]} + */ +var reconstructQueue = function(people) { + if (people.length <= 1) return people; + people.sort((a, b) => { + if (a[0] !== b[0]) { + return b[0] - a[0]; + } else { + return a[1] - b[1]; + } + }); + + var ret = []; + ret.push(people[0]); + + for (var i = 1; i < people.length; i++) { + if (people[i][0] === people[0][0]) { + ret.push(people[i]); + continue; + } + + var count = 0, index = 0; + while (count < people[i][1]) { + if (ret[index][0] >= people[i][0]) count++; + index++; + } + ret.splice(index, 0, people[i]); + } + + return ret; +}; +``` + + +### 409. [Longest Palindrome](https://leetcode.com/problems/longest-palindrome/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ +var longestPalindrome = function(s) { + var map = {}; + var number = 0; + var hasOdd = false; + + s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + for(var i in map) { + if(map[i] % 2 === 0) { + number += map[i]; + } else if(map[i] > 2) { + number += map[i] - 1; + hasOdd = true; + } else { + hasOdd = true; + } + } + + if(hasOdd) number++; + + return number; +}; +``` + + +### 412. [Fizz Buzz](https://leetcode.com/problems/fizz-buzz/description/) +```javascript +/** + * @param {number} n + * @return {string[]} + */ +var fizzBuzz = function(n) { + var ret = []; + + for (var i = 1; i <= n; i++) { + if (i % 15 === 0) { + ret.push('FizzBuzz'); + } else if (i % 3 === 0) { + ret.push('Fizz'); + } else if (i % 5 === 0) { + ret.push('Buzz'); + } else { + ret.push(i + ''); + } + } + + return ret; +}; +``` + + +### 413. [Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/description/) +```javascript +/** + * @param {number[]} A + * @return {number} + */ +var count = function(len) { + return len < 3 ? 0 : (1+ len - 2) * (len - 2) / 2; +}; + +var numberOfArithmeticSlices = function(A) { + if (A.length < 3) return 0; + var len = 2; + var diff = A[1] - A[0]; + var ret = 0; + + for (var i = 1; i < A.length - 1; i++) { + if (diff === A[i + 1] - A[i]) { + len++ + } else { + ret += count(len); + diff = A[i + 1] - A[i]; + len = 2; + } + } + ret += count(len); + + return ret; +}; +``` + + +### 414. [Third Maximum Number](https://leetcode.com/problems/third-maximum-number/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var getMax = function(nums) { + return Math.max.apply(null, nums); +}; + +var removeItem = function(nums, item) { + return nums.filter((value) => value !== item); +}; + +var thirdMax = function(nums) { + var first = getMax(nums); + nums = removeItem(nums, first); + var second = getMax(nums); + nums = removeItem(nums, second); + + if (nums.length === 0) return first; + return getMax(nums); + +}; + +``` + + +### 415. [Add Strings](https://leetcode.com/problems/add-strings/description/) +```javascript +/** + * @param {string} num1 + * @param {string} num2 + * @return {string} + */ +var addStrings = function(num1, num2) { + var zeroString = Array(Math.abs(num1.length - num2.length) + 1).join(0); + if (num1.length > num2.length) { + num2 = zeroString + num2; + } else { + num1 = zeroString + num1; + } + + var d1 = num1.split(''); + var d2 = num2.split(''); + var ret = []; + var sum ; + var hasCarryOver = false; + + for(var i = d1.length - 1; i >= 0 ; i--) { + sum = parseInt(d1[i]) + parseInt(d2[i]); + if (hasCarryOver) { + sum++; + } + if(sum >= 10) { + sum -= 10; + hasCarryOver = true; + } else { + hasCarryOver = false; + } + ret.unshift(sum); + } + + if(hasCarryOver) { + ret.unshift(1); + } + + return ret.join(''); +}; + +``` + + +### 419. [Battleships in a Board](https://leetcode.com/problems/battleships-in-a-board/description/) +```javascript +/** + * @param {character[][]} board + * @return {number} + */ +var countBattleships = function(board) { + var m = board.length; + if (m === 0) return 0; + var n = board[0].length; + + var count = 0; + + for (var i = 0; i < m; i++) { + for (var j = 0; j < n; j++) { + if (board[i][j] === '.') continue; + if (i > 0 && board[i - 1][j] == 'X') continue; + if (j > 0 && board[i][j - 1] == 'X') continue; + count++; + } + } + + return count; +}; +``` + + +### 421. [Maximum XOR of Two Numbers in an Array](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var findMaximumXOR = function(nums) { + var max = 0; + var mask = 0; + for (var i = 31; i >= 0; i--) { + var set = {}; + mask = mask | (1 << i); + nums.forEach((num) => set[num & mask] = true); + + var candidate = max | (1 << i); + + for (var prefix in set) { + if (set[prefix ^ candidate]) { + max = candidate; + } + } + } + + return max; +}; + +``` + + +### 432. [All O`one Data Structure](https://leetcode.com/problems/all-oone-data-structure/description/) +```python +from collections import defaultdict + +class Node(object): + def __init__(self, frequence): + self.prev = self.next = None + self.set = set([]) + self.frequence = frequence + def add(self, key): + self.set.add(key) + def remove(self, key): + self.set.remove(key) + def count(self): + return len(self.set) + def is_empty(self): + return self.count() == 0 + def get_key(self): + if self.is_empty(): + return None + else: + return list(self.set)[0] + +class DoubleLinkList(object): + def __init__(self, Node): + self.Node = Node + self.head = Node('head') + self.tail = Node('tail') + self.head.next = self.tail + self.tail.prev = self.head + + def insert_after(self, node, frequence): + newNode = self.Node(frequence) + nextNode = node.next + + node.next = newNode + newNode.next = nextNode + nextNode.prev = newNode + newNode.prev = node + + return newNode + + def insert_before(self, node, frequence): + return self.insert_after(node.prev, frequence) + + def remove(self, node): + prevNode = node.prev + prevNode.next = node.next + node.next.prev = prevNode + return + + def get_head(self): + return self.head + def get_tail(self): + return self.tail + +class AllOne(object): + + def __init__(self): + self.node_list = DoubleLinkList(Node) + self.key_counter_dict = defaultdict(int) + self.freq_node_dict = {0: self.node_list.get_head()} + + # firstly, remove key from node + # secondly, if the node is empty, remove the node from node_list and remove the key from freq_node_dict + def remove_key(self, key, frquence): + node = self.freq_node_dict[frquence] + node.remove(key) + if node.count() == 0: + self.node_list.remove(node) + self.freq_node_dict.pop(frquence) + + + # cf means current frequence + # pf means last state of frequence + def inc(self, key): + self.key_counter_dict[key] += 1 + cf = self.key_counter_dict[key] + pf = self.key_counter_dict[key] - 1 + + # add key to the new node + if not cf in self.freq_node_dict: + node = self.node_list.insert_after(self.freq_node_dict[pf], cf) + self.freq_node_dict[cf] = node + self.freq_node_dict[cf].add(key) + + # delete key from the old node + if pf > 0: + self.remove_key(key, pf) + + def dec(self, key): + if key in self.key_counter_dict: + self.key_counter_dict[key] -= 1 + cf = self.key_counter_dict[key] + pf = self.key_counter_dict[key] + 1 + + # add key to the new node + if not cf in self.freq_node_dict: + node = self.node_list.insert_before(self.freq_node_dict[pf], cf) + self.freq_node_dict[cf] = node + self.freq_node_dict[cf].add(key) + + # delete key from the old node + self.remove_key(key, pf) + + def getMinKey(self): + if self.node_list.get_head().next != self.node_list.get_tail(): + return self.node_list.get_head().next.get_key() + else: + return '' + + + def getMaxKey(self): + if self.node_list.get_tail().prev != self.node_list.get_head(): + return self.node_list.get_tail().prev.get_key() + else: + return '' + +``` + + +### 434. [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ +/* +var countSegments = function(s) { + return s.split(' ').filter((item) => item !== '').length; +}; +*/ + +var countSegments = function(s) { + var count = 0; + for (var i = 0; i < s.length; i++) { + if (s[i] !== ' ' && (i === 0 || s[i - 1] === ' ')) count++; + } + + return count; +}; +``` + + +### 437. [Path Sum III](https://leetcode.com/problems/path-sum-iii/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} sum + * @return {number} + */ +var traversal = function(root, list, sum, cb) { + if (root === null) return; + cb(list, root.val); + var newList = list.map((item) => item - root.val).concat(sum); + + traversal(root.left, newList, sum, cb); + traversal(root.right, newList, sum, cb); +}; +var pathSum = function(root, sum) { + var count = 0; + var cb = function (list, val) { + list.forEach((item) => { + if (item === val) { + count++; + } + }); + } + + traversal(root, [sum], sum, cb); + return count; +}; + +``` + + +### 441. [Arranging Coins](https://leetcode.com/problems/arranging-coins/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var arrangeCoins = function(n) { + if (n === 0) {return 0;} + var start = 0; + var end = n; + var middle = parseInt((start + end + 1) / 2); + + while (start <= end) { + if ((1 + middle) * middle / 2 <= n && n < (2 + middle) * (middle + 1) / 2) { + return middle; + } else if ((2 + middle) * (middle + 1) / 2 <= n) { + start = middle + 1; + } else if ((1 + middle) * middle / 2 > n) { + end = middle - 1; + } + middle = parseInt((start + end) / 2); + } +}; + +``` + + +### 442. [Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[]} + */ +var findDuplicates = function(nums) { + var ret = []; + for (var i = 0; i < nums.length; i++) { + var index = Math.abs(nums[i]) - 1; + if (nums[index] < 0) { + ret.push(Math.abs(nums[i])); + } + nums[index] = -Math.abs(nums[index]); + } + + return ret; +}; +``` + + +### 445. [Add Two Numbers II](https://leetcode.com/problems/add-two-numbers-ii/description/) +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} l1 + * @param {ListNode} l2 + * @return {ListNode} + */ + +var getLengthList = function(head) { + var len = 0; + while (head !== null) { + len++; + head = head.next; + } + return len; +}; + +var reverseList = function(head) { + if (head === null || head.next === null) return head; + + var prev = head; + var p = head.next; + var tmp; + + head.next = null; + while (p !== null) { + tmp = p.next; + p.next = prev; + prev = p; + p = tmp; + } + + return prev; +}; +var addTwoNumbers = function(l1, l2) { + var len1 = getLengthList(l1); + var len2 = getLengthList(l2); + + var tmp; + if (len1 >= len2) { + l1 = reverseList(l1); + l2 = reverseList(l2); + } else { + tmp = l2; + l2 = reverseList(l1); + l1 = reverseList(tmp); + } + + var head = l1; + var val1, val2; + var isOverTen = false; + var prev; + while (l1 !== null) { + val1 = l1.val; + val2 = l2 !== null ? l2.val : 0; + + if (isOverTen) { + val1++; + isOverTen = false; + } + if (val1 + val2 >= 10) { + l1.val = val1 + val2 - 10; + isOverTen = true; + } else { + l1.val = val1 + val2; + } + + prev = l1; + l1 = l1.next; + if (l2 !== null) { + l2 = l2.next; + } + } + + if (isOverTen) { + prev.next = new ListNode(1); + } + + return reverseList(head); +}; + +``` + + +### 448. [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[]} + */ +var findDisappearedNumbers = function(nums) { + var map = {}; + var ret = []; + + nums.forEach(function(num) { + map[num] = true; + }); + + for (var i = 1; i <= nums.length; i++) { + if (map[i] === undefined) { + ret.push(i); + } + } + + return ret; +}; +``` + + +### 450. [Delete Node in a BST](https://leetcode.com/problems/delete-node-in-a-bst/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} key + * @return {TreeNode} + */ +var update = function(parent, direction) { + if (parent === null) { + return; + } + var deleteNode = parent[direction]; + if (deleteNode.right) { + parent[direction] = deleteNode.right; + + var leftIsNullNode = deleteNode.right; + while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; + leftIsNullNode.left = deleteNode.left; + return parent; + } + if(deleteNode.left) { + parent[direction] = deleteNode.left; + return parent; + } + parent[direction] = null; + return parent; +}; + +var search = function(root, direction, key, ret) { + var node = root[direction]; + if (node === null) { + return; + } + + if (node.val === key) { + ret.parent = root; + ret.direction = direction; + } else if (node.val > key) { + search(node, 'left', key, ret); + } else { + search(node, 'right', key, ret); + } +}; + +var deleteNode = function(root, key) { + if (root === null) { + return null; + } + + if (root.val === key) { + if (root.right) { + var leftIsNullNode = root.right; + while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; + + leftIsNullNode.left = root.left; + return root.right; + } + return root.left; + } + + var ret = { + parent: null, + direction: null, + }; + search(root, 'left', key, ret); + search(root, 'right', key, ret); + update(ret.parent, ret.direction); + + return root; +}; + +``` + + +### 451. [Sort Characters By Frequency](https://leetcode.com/problems/sort-characters-by-frequency/description/) +```javascript +/** +* @param {string} s +* @return {string} +*/ +var frequencySort = function(s) { + var charCountMap = {}; + + for (var i = 0; i < s.length; i++) { + if (charCountMap[s[i]] === undefined) { + charCountMap[s[i]] = 1; + } else { + charCountMap[s[i]]++; + } + } + + var list = []; + + for (var key in charCountMap) { + list.push({ + char: key, + count: charCountMap[key] + }); + } + + list.sort((a, b) => b.count- a.count); + + return list.reduce((p, c) => { + return p + c.char.repeat(c.count) + }, ''); +}; + +``` + + +### 453. [Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var minMoves = function(nums) { + var min = Math.min.apply(null, nums) + + return nums.reduce((p, c) => p + c - min, 0); +}; +``` + + +### 454. [4Sum II](https://leetcode.com/problems/4sum-ii/description/) +```javascript +/** + * @param {number[]} A + * @param {number[]} B + * @param {number[]} C + * @param {number[]} D + * @return {number} + */ +var fourSumCount = function(A, B, C, D) { + var AB = []; + var CD = []; + for (var i = 0; i < A.length; i++) { + for (var j = 0; j < B.length; j++) { + AB.push(A[i] + B[j]); + CD.push(C[i] + D[j]); + } + } + + AB = AB.sort((a, b) => a - b); + CD = CD.sort((a, b) => a - b); + + var count = 0; + var m = 1, n = 1; + + i = 0; j = CD.length - 1; + while (i < AB.length && j >= 0) { + if (AB[i] + CD[j] > 0) { + j--; + continue; + } + if (AB[i] + CD[j] < 0) { + i++; + continue; + } + while (i < AB.length && AB[i] === AB[i + 1]) { + i++; m++; + } + + while (j >= 0 && CD[j] === CD[j - 1]) { + j--; n++; + } + + count += m * n; + i++; j--; + m = 1; n = 1; + } + + return count; +}; + +``` + + +### 455. [Assign Cookies](https://leetcode.com/problems/assign-cookies/description/) +```javascript +/** + * @param {number[]} g + * @param {number[]} s + * @return {number} + */ +var findContentChildren = function(g, s) { + var compare = (a, b) => a - b; + g = g.sort(compare); + s = s.sort(compare); + + var i = s.length - 1; // person index + var j = g.length - 1; // cookie index + var count = 0; + + while (i >= 0 && j >= 0) { + if(s[i] >= g[j]) { + i--; + j--; + count++ + } else { + j--; + } + } + + return count; +}; +``` + + +### 459. [Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/description/) +```javascript +/** + * @param {string} s + * @return {boolean} + */ +/* +var repeatedSubstringPattern = function(s) { + if (s.length === 1) return false; + var ret = false; + + for (var i = 1; i <= parseInt((s.length + 1) / 2); i++) { + for (var j = i; j < s.length; j++) { + if (s[j % i] !== s[j]) break; + } + if (j === s.length && (j - 1) % i === i - 1) { + ret = true; + break; + } + } + + return ret; +}; +*/ + +var repeatedSubstringPattern = function(s) { + return /^(.+)\1+$/.test(s); +} +``` + + +### 460. [LFU Cache](https://leetcode.com/problems/lfu-cache/description/) +```python +from collections import defaultdict +import collections + +class Node(object): + def __init__(self, frequence): + self.prev = self.next = None + self.dict = collections.OrderedDict() + self.frequence = frequence + def add(self, key): + self.dict[key] = True + def pop(self): + if not self.is_empty(): + return self.dict.popitem(last = False) + def remove(self, key): + del self.dict[key] + def count(self): + return len(self.dict) + def is_empty(self): + return self.count() == 0 + +class DoubleLinkList(object): + def __init__(self, Node): + self.Node = Node + self.head = Node('head') + self.tail = Node('tail') + self.head.next = self.tail + self.tail.prev = self.head + def insert_after(self, node, frequence): + newNode = self.Node(frequence) + nextNode = node.next + + node.next = newNode + newNode.next = nextNode + nextNode.prev = newNode + newNode.prev = node + return newNode + def insert_before(self, node, frequence): + return self.insert_after(node.prev, frequence) + def remove(self, node): + prevNode = node.prev + nextNode = node.next + prevNode.next = nextNode + nextNode.prev = prevNode + return + def get_head(self): + return self.head + def get_tail(self): + return self.tail + +class LFUCache(object): + + def __init__(self, capacity): + self.node_list = DoubleLinkList(Node) + self.key_value_dict = {} + self.key_freq_dict = defaultdict(int) + self.freq_node_dict = {0: self.node_list.get_head()} + self.capacity = self.remain = capacity + + # firstly, remove key from node or remove the laste key in lowest frequence node + # secondly, if the node is empty, remove the node from node_list and remove the key from freq_node_dict + def remove_key(self, node, key = None): + frequence = node.frequence + ret = None + if key == None: + ret = node.pop() + else: + node.remove(key) + if node.count() == 0: + self.node_list.remove(node) + self.freq_node_dict.pop(frequence) + + if ret: + delete_key = ret[0] + return delete_key + + # cf means current frequence + # pf means previous frequence + # remove from previous frequence node + # add into the current frequence node + def _update_node(self, key): + self.key_freq_dict[key] += 1 + cf = self.key_freq_dict[key] + pf = cf - 1 + + if not cf in self.freq_node_dict: + node = self.node_list.insert_after(self.freq_node_dict[pf], cf) + node.add(key) + self.freq_node_dict[cf] = node + self.freq_node_dict[cf].add(key) + + if pf > 0: + self.remove_key(self.freq_node_dict[pf], key) + + def get(self, key): + if not key in self.key_value_dict: + return -1 + + ret = self.key_value_dict[key] + self._update_node(key) + return ret + + def put(self, key, value): + if self.capacity == 0: + return + if not key in self.key_value_dict: + self.remain -= 1 + + if self.remain < 0: + deleted_key = self.remove_key(self.node_list.get_head().next) + self.remain += 1 + del self.key_freq_dict[deleted_key] + del self.key_value_dict[deleted_key] + + self.key_value_dict[key] = value + self._update_node(key) + +``` + + +### 461. [Hamming Distance](https://leetcode.com/problems/hamming-distance/description/) +```javascript +/** + * @param {number} x + * @param {number} y + * @return {number} + */ + +// Number of 1 Bits +var hammingWeight = function(n) { + var ret = 0; + for(var power = 32; power >= 0; power--) { + var exponent = Math.pow(2, power); + if (n >= exponent) { + ret++; + n -= exponent; + } + } + return ret; +}; + +var hammingDistance = function(x, y) { + return hammingWeight(x ^ y); +}; +``` + + +### 462. [Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var minMoves2 = function(nums) { + nums = nums.sort((a, b) => a - b); + var median = nums[Math.floor((nums.length - 1) / 2)]; + + return nums.reduce((p, c) => { + return p + Math.abs(c - median); + }, 0); +}; + +``` + + +### 463. [Island Perimeter](https://leetcode.com/problems/island-perimeter/description/) +```javascript +/** + * @param {number[][]} grid + * @return {number} + */ +var islandPerimeter = function(grid) { + var perimeter = 4 * grid.reduce((p, c) => p.concat(c)).reduce((p, c) => p + c); + + for(var i = 0; i < grid.length; i++) { + for(var j = 0; j < grid[i].length; j++) { + if(grid[i][j] === 1) { + if(i + 1 < grid.length && grid[i+1][j] === 1) { + perimeter -= 2 ; + } + if(j + 1 < grid[i].length && grid[i][j+1] === 1) { + perimeter -= 2; + } + } + } + } + + return perimeter; +}; +``` + + +### 476. [Number Complement](https://leetcode.com/problems/number-complement/description/) +```javascript +/** + * @param {number} num + * @return {number} + +这道题给了我们一个数，让我们求补数。通过分析题目汇总的例子，我们知道需要做的就是每个位翻转一下就行了，但是翻转的起始位置上从最高位的1开始的，前面的0是不能被翻转的，所以我们从高往低遍历，如果遇到第一个1了后，我们的flag就赋值为true，然后就可以进行翻转了，翻转的方法就是对应位异或一个1即可，参见代码如下： + + + +解法一： + +复制代码 +class Solution { +public: + int findComplement(int num) { + bool start = false; + for (int i = 31; i >= 0; --i) { + if (num & (1 << i)) start = true; + if (start) num ^= (1 << i); + } + return num; + } +}; +复制代码 + + +由于位操作里面的取反符号～本身就可以翻转位，但是如果直接对num取反的话就是每一位都翻转了，而最高位1之前的0是不能翻转的，所以我们只要用一个mask来标记最高位1前面的所有0的位置，然后对mask取反后，与上对num取反的结果即可，参见代码如下： + + + +解法二： + +复制代码 +class Solution { +public: + int findComplement(int num) { + int mask = INT_MAX; + while (mask & num) mask <<= 1; + return ~mask & ~num; + } +}; +复制代码 + + +再来看一种迭代的写法，一行搞定碉堡了，思路就是每次都右移一位，并根据最低位的值先进行翻转，如果当前值小于等于1了，就不用再调用递归函数了，参见代码如下： + + + +解法三： + +class Solution { +public: + int findComplement(int num) { + return (1 - num % 2) + 2 * (num <= 1 ? 0 : findComplement(num / 2)); + } +}; + + */ + +var findComplement = function(num) { + var mask = ~0; + while (mask & num) mask <<= 1; + return ~mask & ~num; +}; +``` + + +### 482. [License Key Formatting](https://leetcode.com/problems/license-key-formatting/description/) +```javascript +/** + * @param {string} S + * @param {number} K + * @return {string} + */ +var format = function(chars, length, separator) { + if (chars.length <= length) { + return chars.join(''); + } + return format(chars.slice(0, chars.length - length), length, separator) + separator + chars.slice(-length).join(''); +}; +var licenseKeyFormatting = function(S, K) { + var chars = S.split('').filter((char) => { + return char !== '-'; + }); + + return format(chars, K, '-').toUpperCase(); + +}; +``` + + +### 485. [Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var findMaxConsecutiveOnes = function(nums) { + var max = 0; + var length = 0; + nums.forEach(function(num) { + if (num === 1) length++; + if (num === 0) { + if (length > max) max = length; + length = 0; + } + }); + if (length > max) max = length; + return max; +}; +``` + + +### 486. [Predict the Winner](https://leetcode.com/problems/predict-the-winner/description/) +```javascript +/** + * @param {number[]} nums + * @return {boolean} + */ +var PredictTheWinner = function(nums) { + var n = nums.length; + var dp = new Array(n).fill(undefined).map(() => []); + + nums.forEach((num, i) => dp[i][i] = num); + + for (var len = 1; len < n; len++) { + for (var i = 0; i < n - len; i++) { + var j = i + len; + dp[i][j] = Math.max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1]); + } + } + + return dp[0][n - 1] >= 0; + +}; + +``` + + +### 492. [Construct the Rectangle](https://leetcode.com/problems/construct-the-rectangle/description/) +```javascript +/** + * @param {number} area + * @return {number[]} + */ +var constructRectangle = function(area) { + var root = parseInt(Math.sqrt(area)); + var ret = []; + for (var i = root; i <= area; i++) { + if (area % i === 0) { + i > area / i ? ret.push(i, area / i) : ret.push(area / i, i); + break; + } + } + return ret; +}; +``` + + +### 494. [Target Sum](https://leetcode.com/problems/target-sum/description/) +```javascript + +var findTargetSumWays = function(nums, S) { + var count = 0; + var len = nums.length; + function find(index, sum) { + if (index === len) { + if (sum === S) count++; + } else { + find(index + 1, sum + nums[index]); + find(index + 1, sum - nums[index]); + } + } + find(0, 0); + + return count; +}; +``` + + +### 495. [Teemo Attacking](https://leetcode.com/problems/teemo-attacking/description/) +```javascript +/** + * @param {number[]} timeSeries + * @param {number} duration + * @return {number} + */ +var findPoisonedDuration = function(timeSeries, duration) { + if (timeSeries.length === 0) return 0; + + var time = 0; + for (var i = 0; i < timeSeries.length - 1; i++) { + if (timeSeries[i + 1] - timeSeries[i] < duration) { + time += timeSeries[i + 1] - timeSeries[i]; + } else { + time += duration; + } + } + time += duration; + + return time; +}; +``` + + +### 496. [Next Greater Element I](https://leetcode.com/problems/next-greater-element-i/description/) +```javascript +/** + * @param {number[]} findNums + * @param {number[]} nums + * @return {number[]} + */ +var nextGreaterElement = function(findNums, nums) { + var map = {}; + var stack = []; + nums.forEach(function(num) { + while(stack.length > 0 && stack[stack.length - 1] < num) { + map[stack.pop()] = num; + } + stack.push(num); + }); + + return findNums.map(function(num) { + return map[num] || -1; + }); +}; +``` + + +### 498. [Diagonal Traverse](https://leetcode.com/problems/diagonal-traverse/description/) +```javascript +/** + * @param {number[][]} matrix + * @return {number[]} + */ +function toggleDirection (direction) { + return direction === 'up' ? 'down' : 'up'; +} +var findDiagonalOrder = function(matrix) { + if (matrix.length === 0) return []; + var m = matrix.length; + var n = matrix[0].length; + var next = { + up: [-1, 1], + down: [1, -1] + }; + var direction = 'up'; + var x = 0, y = 0; + var ret = []; + + for (var i = 0; i < m * n; i++) { + ret.push(matrix[x][y]); + x += next[direction][0]; + y += next[direction][1]; + + if (x >= m) { + y += 2; + x -= 1; + direction = toggleDirection(direction); + } + if (y >= n) { + x += 2; + y -= 1; + direction = toggleDirection(direction); + } + if (x < 0) { + x = 0; + direction = toggleDirection(direction); + } + if (y < 0) { + y = 0; + direction = toggleDirection(direction); + } + } + + return ret; +}; + +``` + + +### 500. [Keyboard Row](https://leetcode.com/problems/keyboard-row/description/) +```javascript +/** + * @param {string[]} words + * @return {string[]} + */ +var findWords = function(words) { + return words.filter(function(str) { + return /^([qwertyuiop]*|[asdfghjkl]*|[zxcvbnm]*)$/.test(str.toLowerCase()); + }); +}; +``` + + +### 501. [Find Mode in Binary Search Tree](https://leetcode.com/problems/find-mode-in-binary-search-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ + +var traversal = function(root, func) { + if (root === null) { + return null; + } + traversal(root.left, func); + func(root.val); + traversal(root.right, func); +}; + +var findMode = function(root) { + if (root === null) return []; + + var ret; + var maxCount = Number.MIN_VALUE; + var prevValue; + var currentCount; + + traversal(root, function(val) { + if (prevValue === undefined) { + prevValue = val; + currentCount = 1; + } else { + if (prevValue === val) { + currentCount++; + } else { + currentCount = 1; + } + } + + if(currentCount > maxCount) { + ret = []; + ret.push(val); + maxCount = currentCount; + } else if (currentCount === maxCount) { + ret.push(val); + } + prevValue = val; + }); + + return ret; +}; +``` + + +### 503. [Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/description/) +```javascript +/** + * @param {number[]} nums + * @return {number[]} + */ +var nextGreaterElements = function(nums) { + var nextGreaterMap = {}; + var stack = []; + nums.concat(nums).forEach((item) => { + while (stack.length > 0 && stack[stack.length - 1] < item) { + var key = stack.pop(); + if (nextGreaterMap[key] === undefined) { + nextGreaterMap[key] = []; + } + nextGreaterMap[key].push(item); + } + stack.push(item); + }); + + return nums.map((item) => { + if (nextGreaterMap[item] && nextGreaterMap[item].length > 0) { + return nextGreaterMap[item].shift(); + } else { + return -1; + } + }); +}; + +``` + + +### 504. [Base 7](https://leetcode.com/problems/base-7/description/) +```javascript +/** + * @param {number} num + * @return {string} + */ +var convertToBase7 = function(num) { + if (num < 0) return '-' + convertToBase7(-num); + else if (num < 7) return String(num); + else return convertToBase7(parseInt(num / 7)) + num % 7; +}; +``` + + +### 506. [Relative Ranks](https://leetcode.com/problems/relative-ranks/description/) +```javascript +/** + * @param {number[]} nums + * @return {string[]} + */ +var findRelativeRanks = function(nums) { + var rank = 4; + var map = {}; + var sortNums = [].slice.call(nums).sort((a, b) => b - a); + for (var i = 0; i < sortNums.length; i++) { + if (i === 0) { + map[sortNums[i]] = 'Gold Medal'; + } else if (i === 1) { + map[sortNums[i]] = 'Silver Medal'; + } else if (i === 2) { + map[sortNums[i]] = 'Bronze Medal'; + } else { + map[sortNums[i]] = String(rank); + rank++; + } + } + + return nums.map((score) => { + return map[score]; + }); +}; +``` + + +### 508. [Most Frequent Subtree Sum](https://leetcode.com/problems/most-frequent-subtree-sum/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ +function getSum (root, map) { + if (root === null) return 0; + var left = getSum(root.left, map); + var right = getSum(root.right, map); + var sum = root.val + left + right; + + map[sum] === undefined ? map[sum] = 1 : map[sum]++; + return sum; +} +var findFrequentTreeSum = function(root) { + if (root === null) return []; + var valueCountMap = {}; + var max = -1; + var ret = []; + var key; + + getSum(root, valueCountMap); + for (key in valueCountMap) { + if (valueCountMap[key] > max) { + max = valueCountMap[key]; + } + } + + for (key in valueCountMap) { + if (valueCountMap[key] === max) { + ret.push(parseInt(key)); + } + } + + return ret; +}; +``` + + +### 513. [Find Bottom Left Tree Value](https://leetcode.com/problems/find-bottom-left-tree-value/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var findBottomLeftValue = function(root) { + var maxDepth = Number.MIN_SAFE_INTEGER; + var value; + + var traverse = function(root, depth) { + if (root === null) return; + if (depth > maxDepth) { + value = root.val; + maxDepth = depth; + } + traverse(root.left, depth + 1); + traverse(root.right, depth + 1); + }; + + traverse(root, 1); + return value; +}; + +``` + + +### 515. [Find Largest Value in Each Tree Row](https://leetcode.com/problems/find-largest-value-in-each-tree-row/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ +var largestValues = function(root) { + if (root === null) return []; + var left = largestValues(root.left); + var right = largestValues(root.right); + + var ret = []; + for(var i = 0; i < left.length || i < right.length; i++) { + if (left[i] === undefined) { + ret.push(right[i]); + } else if (right[i] === undefined) { + ret.push(left[i]); + } else { + ret.push(Math.max(right[i], left[i])); + } + } + ret.unshift(root.val); + + return ret; +}; +``` + + +### 520. [Detect Capital](https://leetcode.com/problems/detect-capital/description/) +```javascript +/** + * @param {string} word + * @return {boolean} + */ +var detectCapitalUse = function(word) { + return /^[A-Z]?([a-z]*|[A-Z]*)$/.test(word); +}; +``` + + +### 522. [Longest Uncommon Subsequence II](https://leetcode.com/problems/longest-uncommon-subsequence-ii/description/) +```javascript +function isSubStr(str, sub) { + var i = 0; + var j = 0; + while (i < str.length && j < sub.length) { + if (sub[j] === str[i]) { + j++; i++; + } else { + i++; + } + } + return j === sub.length; +} + +var findLUSlength = function(strs) { + var maxLen = strs[0].length; + var notUniqStrs = []; + var map = {}; + + for (var i = 0; i < strs.length; i++) { + if (map[strs[i]] === true) { + notUniqStrs.push(strs[i]); + } else { + map[strs[i]] = true; + } + } + + notUniqStrs.forEach((str) => { + strs = strs.filter((sub) => { + return !isSubStr(str, sub); + }); + }); + + return strs.length === 0 ? -1 : Math.max.apply(null, strs.map(i => i.length)); +} + +``` + + +### 526. [Beautiful Arrangement](https://leetcode.com/problems/beautiful-arrangement/description/) +```javascript +/** + * @param {number} N + * @return {number} + */ +var countArrangement = function(N) { + var position = []; + for (var i = 1; i <= N; i++) position.push(i); + var value = position.slice(); + + var ret = 0; + var count = function(position, value) { + if (position.length === 1 && value.length === 1) { + if (position[0] % value[0] === 0 || value[0] % position[0] === 0) { + ret++; + } + return + } + for (var i = 0; i < position.length; i++) { + if (position[i] % value[0] === 0 || value[0] % position[i] === 0) { + count(position.slice(0, i).concat(position.slice(i + 1)), value.slice(1)); + } + } + }; + count(position, value); + return ret; +}; + +``` + + +### 529. [Minesweeper](https://leetcode.com/problems/minesweeper/description/) +```javascript +function getMineCount(board, point) { + var m = board.length; + var n = board[0].length; + var x = point[0]; + var y = point[1]; + var count = 0; + for (var i = -1; i < 2; i++) { + for (var j = -1; j < 2; j++) { + var p = x + i; + var q = y + j; + if (p < 0 || p >= m || q < 0 || q >= n) continue; + if (board[p][q] === 'M' || board[p][q] === 'X') count++; + } + } + return count; +} + +function updateSquare(board, point, visited) { + var [x, y] = point; + if (visited[x][y]) return; + visited[x][y] = true; + + var m = board.length; + var n = board[0].length; + var count = getMineCount(board, point); + + if (count === 0) { + board[x][y] = 'B'; + for (var i = -1; i < 2; i++) { + for (var j = -1; j < 2; j++) { + var p = x + i; + var q = y + j; + if (p < 0 || p >= m || q < 0 || q >= n || (p === x && q === y)) continue; + + updateSquare(board, [p, q], visited); + } + } + } else { + board[x][y] = count; + } +} + +var updateBoard = function(board, click) { + var m = board.length; + var n = board[0].length; + var visited = []; + for (var k = 0; k < m; k++) visited.push(new Array(n).fill(false)); + + var [x, y] = click; + if (board[x][y] === 'M') { + board[x][y] = 'X'; + } else { + updateSquare(board, click, visited); + } + + return board; +}; + +``` + + +### 530. [Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var getMinimumDifference = function(root) { + var prev = null; + var min = Number.MAX_VALUE; + var traversal = function(root) { + if (root === null) return; + traversal(root.left); + if (prev !== null && root.val - prev < min) { + min = root.val - prev; + } + prev = root.val; + traversal(root.right); + }; + traversal(root); + + return min; +}; +``` + + +### 532. [K-diff Pairs in an Array](https://leetcode.com/problems/k-diff-pairs-in-an-array/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {number} + */ +var findPairs = function(nums, k) { + if (k < 0 || nums.length === 0) return 0; + var itemCountMap = {}; + var count = 0; + + nums.forEach((item, index) => { + itemCountMap[item] === undefined ? itemCountMap[item] = 1 : itemCountMap[item]++; + }); + + if (k === 0) { + for (var key in itemCountMap) { + if (itemCountMap[key] >= 2) { + count++; + } + } + } else { + for (var key in itemCountMap) { + if (itemCountMap[parseInt(key)+ k] !== undefined) { + count++; + } + } + } + + return count; +}; + +``` + + +### 538. [Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {TreeNode} + */ +var convertBST = function(root) { + var sum = 0; + function traverse (root) { + if (root === null) return; + traverse(root.right); + root.val = root.val + sum; + sum = root.val; + traverse(root.left); + } + + traverse(root); + return root; +}; +``` + + +### 539. [Minimum Time Difference](https://leetcode.com/problems/minimum-time-difference/description/) +```javascript +/** + * @param {string[]} timePoints + * @return {number} + */ +var findMinDifference = function(timePoints) { + var ret = Number.MAX_SAFE_INTEGER; + var hour, min; + var mins = timePoints.map(time => { + [hour, min] = time.split(':').map(i => parseInt(i)); + + return hour * 60 + min; + }); + + mins = mins.sort((a, b) => a - b); + for (var i = 0; i < mins.length - 1; i++) { + ret = Math.min(ret, mins[i + 1] - mins[i]); + } + + ret = Math.min(ret, 24 * 60 + mins[0]- mins[mins.length - 1]); + + return ret; +}; +``` + + +### 541. [Reverse String II](https://leetcode.com/problems/reverse-string-ii/description/) +```javascript +/** + * @param {string} s + * @param {number} k + * @return {string} + */ +var reverseStr = function(s, k) { + var arr = s.split(''); + var reverse = true; + var ret = ""; + + for(var i = 0; i < arr.length; i = i + k) { + if (reverse) { + for (var j = Math.min(arr.length, i + k) - 1; j >= i; j--) { + ret += arr[j]; + } + } else { + for (var j = i; j < Math.min(arr.length, i + k); j++) { + ret += arr[j]; + } + } + + reverse = !reverse; + } + + return ret; +}; +``` + + +### 542. [01 Matrix](https://leetcode.com/problems/01-matrix/description/) +```javascript +/** + * @param {number[][]} matrix + * @return {number[][]} + */ +var updateMatrix = function(matrix) { + var m = matrix.length; + var n = matrix[0].length; + var queue = []; + + for (var i = 0; i < m; i++) { + for (var j = 0; j < n; j++) { + if (matrix[i][j] === 0) { + queue.push([i, j]); + } else { + matrix[i][j] = undefined; + } + } + } + + while (queue.length > 0) { + var [x, y] = queue.shift(); + var range = [[-1,0], [1, 0], [0, -1], [0, 1]]; + range.forEach(([p, q]) => { + p += x; + q += y; + if (p < 0 || p >= m || q < 0 || q >= n) return; + if (matrix[p][q] !== undefined && matrix[p][q] < matrix[x][y] + 1) return; + matrix[p][q] = matrix[x][y] + 1; + queue.push([p, q]); + }); + } + + return matrix; +}; + +``` + + +### 543. [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var diameterOfBinaryTree = function(root) { + var maxDiameter = -1; + var getDepth = function(root) { + if (root === null) { + return 0; + } + var leftDepth = getDepth(root.left); + var rightDepth = getDepth(root.right); + + maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth); + maxDepth = Math.max(leftDepth, rightDepth) + 1; + return maxDepth; + }; + + if (root === null) return 0; + getDepth(root); + + return maxDiameter; +}; +``` + + +### 544. [Output Contest Matches](https://leetcode.com/problems/output-contest-matches/description/) +```javascript +/** + * @param {number} n + * @return {string} + */ +function getMatch (match) { + if (match.length === 1) return match; + var ret = []; + var start = 0; + var end = match.length - 1; + var value; + + while (start < end) { + value = `(${match[start]},${match[end]})`; + ret.push(value); + start++; + end--; + } + + return getMatch(ret); +} +var findContestMatch = function(n) { + var match = []; + for (var i = 1; i <= n; i++) match.push(i); + + return getMatch(match)[0]; +}; +``` + + +### 545. [Boundary of Binary Tree](https://leetcode.com/problems/boundary-of-binary-tree/description/) +```javascript +/** +* @param {TreeNode} root +* @return {number[]} +*/ + +function rightBorder(node) { + if (node === null) return []; + var ret = []; + + ret.push(node.val); + while (node.left || node.right) { + if (node.right) { + ret.push(node.right.val); + node = node.right; + continue; + } + ret.push(node.left.val); + node = node.left; + } + return ret.reverse(); +} +function leftBorder(node) { + if (node === null) return []; + var ret = []; + + ret.push(node.val); + while (node.left || node.right) { + if (node.left) { + ret.push(node.left.val); + node = node.left; + continue; + } + ret.push(node.right.val); + node = node.right; + } + return ret; +} + +var boundaryOfBinaryTree = function(root) { + if (root === null) return []; + if (root.left === null && root.right === null) return [root.val]; + var leaf = []; + + function traversal (root) { + if (root === null) return true; + var isLeftNull = traversal(root.left); + var isRightNull = traversal(root.right); + if (isLeftNull && isRightNull) { + leaf.push(root.val); + return false; + } + } + + var up = [root.val] + var left = leftBorder(root.left); + var right = rightBorder(root.right); + traversal(root); + + var ret = up + .concat(left.slice(0, left.length - 1)) + .concat(leaf) + .concat(right.slice(1)); + + return ret; +}; +``` + + +### 546. [Remove Boxes](https://leetcode.com/problems/remove-boxes/description/) +```javascript +/** +* @param {number[]} boxes +* @return {number} +*/ + +function get(boxes, memo, i, j, k) { + if (i > j) return 0; + + if (memo[i][j][k] !== undefined) { + return memo[i][j][k]; + } + + var max = get(boxes, memo, i, j - 1, 0) + (k + 1) * (k + 1); + for (var m = i; m < j; m++) { + if (boxes[j] === boxes[m]) { + max = Math.max( + max, + get(boxes, memo, i, m, k + 1) + get(boxes, memo, m + 1, j - 1, 0) + ); + } + } + memo[i][j][k] = max; + return memo[i][j][k]; +} + +var removeBoxes = function(boxes) { + var memo = []; + for (var i = 0; i < boxes.length; i++) { + memo[i] = new Array(boxes.length); + for (var j = 0; j < boxes.length; j++) { + memo[i][j] = new Array(boxes.length); + } + } + + return get(boxes, memo, 0, boxes.length - 1, 0); +}; +``` + + +### 547. [Friend Circles](https://leetcode.com/problems/friend-circles/description/) +```javascript +/** + * @param {number[][]} M + * @return {number} + */ + +function nextUnVisitedIndex(isVisted) { + for (var i = 0; i < isVisted.length; i++) { + if (isVisted[i] === false) { + return i; + } + } + return -1; +} +var findCircleNum = function(M) { + var isVisited = new Array(M.length).fill(false); + var queue = []; + var count = 0; + var next = nextUnVisitedIndex(isVisited); + + while (next !== -1) { + queue.push(next); + count++; + while (queue.length > 0) { + var cur = queue.shift(); + isVisited[cur] = true; + + for (var i = 0; i < M.length; i++) { + if (M[cur][i] === 1 && cur !== i && isVisited[i] === false) { + queue.push(i); + } + } + } + next = nextUnVisitedIndex(isVisited); + } + + return count; +}; + + +``` + + +### 548. [Split Array with Equal Sum](https://leetcode.com/problems/split-array-with-equal-sum/description/) +```javascript +/** + * @param {number[]} nums + * @return {boolean} + */ +function getSum(memo, m, n) { + if (memo[m][n] !== undefined) { + return memo[m][n]; + } else { + memo[m][n] = getSum(memo, m, n - 1) + memo[n][n] + return memo[m][n]; + } +} +var splitArray = function(nums) { + var newArr = []; + var prev; + for (var i = 0; i < nums.length; i++) { + if (nums[i] === 0 && prev === 0) { + continue; + } + newArr.push(nums[i]); + prev = nums[i]; + } + nums = newArr; + + if (nums.length < 7) return false; + + var memo = []; + var len = nums.length; + for (var i = 0; i < len; i++) { + memo.push(new Array(len)); + memo[i][i] = nums[i]; + } + + for (var i = 1; i < len - 5; i++) { + var sum1 = getSum(memo, 0, i - 1); + + for (var j = i + 2; j < len - 3; j++) { + var sum2 = getSum(memo, i + 1, j - 1); + + if (sum1 !== sum2) continue; + for (var k = j + 2; k < len - 1; k++) { + var sum3 = getSum(memo, j + 1, k - 1); + var sum4 = getSum(memo, k + 1, len - 1); + + if (sum1 === sum3 && sum1 === sum4) { + return true; + } + } + } + } + + + return false; +}; +``` + + +### 549. [Binary Tree Longest Consecutive Sequence II](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence-ii/description/) +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var longestConsecutive = function(root) { + function getLongest(root) { + if (root === null) { + return null; + } + + var left = getLongest(root.left); + var right = getLongest(root.right); + + if (left === null) { + left = {}; + left.d = [root.val]; + left.i = [root.val]; + } + if (right === null) { + right = {}; + right.d = [root.val]; + right.i = [root.val]; + } + + if (left.d[left.d.length - 1] === root.val + 1 && + right.i[right.i.length - 1] === root.val - 1 + ) { + max = Math.max(max, left.d.length + right.i.length + 1); + } + if (right.d[right.d.length - 1] === root.val + 1 && + left.i[left.i.length - 1] === root.val - 1 + ) { + max = Math.max(max, right.d.length + left.i.length + 1); + } + + if (left.d[left.d.length - 1] === root.val + 1) { + left.d.push(root.val); + } else { + left.d = [root.val]; + } + if (left.i[left.i.length - 1] === root.val - 1) { + left.i.push(root.val); + } else { + left.i = [root.val]; + } + + if (right.d[right.d.length - 1] === root.val + 1) { + right.d.push(root.val); + } else { + right.d = [root.val]; + } + if (right.i[right.i.length - 1] === root.val - 1) { + right.i.push(root.val); + } else { + right.i = [root.val]; + } + max = Math.max(max, left.d.length, left.i.length, right.i.length, right.d.length); + + var ret = {}; + ret.d = left.d.length >= right.d.length ? left.d : right.d; + ret.i = left.i.length >= right.i.length ? left.i : right.i; + return ret; + } + + var max = 0; + getLongest(root); + + return max; +}; +``` + + +### 551. [Student Attendance Record I](https://leetcode.com/problems/student-attendance-record-i/description/) +```javascript +/** + * @param {string} s + * @return {boolean} + */ +var checkRecord = function(s) { + var absent = 0; + + for (var i = 0; i < s.length; i++) { + if (s[i] === 'A') absent++; + if (absent >= 2) { + return false; + } + if (i < s.length - 2 && s[i] === 'L' && s[i + 1] === 'L' && s[i + 2] === 'L') { + return false; + } + } + + return true; +}; +``` + + +### 553. [Optimal Division](https://leetcode.com/problems/optimal-division/description/) +```javascript +/** + * @param {number[]} nums + * @return {string} + */ +var optimalDivision = function(nums) { + if (nums.length === 1) { + return String(nums[0]) + } else if (nums.length === 2) { + return nums.join('/'); + } else { + return nums.join('/').replace('/','/(') + ')'; + } +}; +``` + + +### 556. [Next Greater Element III](https://leetcode.com/problems/next-greater-element-iii/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ + function swap(a, i, j) { + var tmp = a[i]; + a[i] = a[j]; + a[j] = tmp; + } + var nextGreaterElement = function(n) { + if (n < 10) return -1; + var a = String(n).split(''); + var max = a[a.length - 1]; + var minIndex; + var ret; + + for (var i = a.length - 2; i >= 0; i--) { + if (a[i] < max) { + minIndex = i + 1; + for (var j = i + 2; j < a.length; j++) { + if (a[j] > a[i] && a[j] < a[minIndex]) { + minIndex = j; + } + } + swap(a, i, minIndex); + ret = a.slice(0, i + 1).concat(a.slice(i + 1).sort()).join(''); + ret = parseInt(ret); + if (ret > Math.pow(2, 31)) { + break; + } + return ret; + } + if (a[i] > max) { + max = a[i]; + } + } + + return -1; + }; +``` + + +### 560. [Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k/description/) +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {number} + */ +var subarraySum = function(nums, k) { + var len = nums.length; + var sum = 0; + var count = 0; + + for (var i = 0; i < len; i++) { + for (var j = i; j < len; j++) { + sum += nums[j]; + if (sum === k) { + count++ + } + } + sum = 0; + } + + return count; +}; +``` + + +### 561. [Array Partition I](https://leetcode.com/problems/array-partition-i/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var arrayPairSum = function(nums) { + nums = nums.sort((a, b) => a - b); + return nums.reduce((p, c, index) => { + return index % 2 === 0 ? p + c : p; + }); +}; +``` + + +### 562. [Longest Line of Consecutive One in Matrix](https://leetcode.com/problems/longest-line-of-consecutive-one-in-matrix/description/) +```javascript +/** + * @param {number[][]} M + * @return {number} + */ +var longestLine = function(M) { + if (M.length === 0) { + return 0; + } + var m = M.length; + var n = M[0].length; + var max = 0; + var dp = []; + for (var i = 0; i < m; i++) { + var tmp = []; + for (var j = 0; j < n; j++) { + tmp.push(new Array(4).fill(0)); + } + dp.push(tmp); + } + + for (var i = 0; i < m; i++) { + for (var j = 0; j < n; j++) { + if (M[i][j] === 0) { + continue; + } + for (var k = 0; k < 4; k++) { + dp[i][j][k] = 1; + } + if (j > 0) { + dp[i][j][0] = dp[i][j - 1][0] + 1; + } + if (i > 0) { + dp[i][j][1] = dp[i - 1][j][1] + 1; + } + if (i > 0 && j > 0) { + dp[i][j][2] = dp[i - 1][j - 1][2] + 1; + } + if (i > 0 && j < n - 1) { + dp[i][j][3] = dp[i - 1][j + 1][3] + 1; + } + max = Math.max(max, dp[i][j][0], dp[i][j][1], dp[i][j][2], dp[i][j][3]) + } + } + + return max; +}; +``` + + +### 617. [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) +```python +class Solution(object): + def mergeTrees(self, t1, t2): + if t1 and t2: + t1.val += t2.val + self.mergeChildTrees(t1, t2) + return t1 + elif t1: + return t1 + else: + return t2 + + def mergeChildTrees(self, t1, t2): + if t2 == None: + return + if t1.left and t2.left: + t1.left.val += t2.left.val + elif t2.left: + t1.left = t2.left + t2.left = None + + if t1.right and t2.right: + t1.right.val += t2.right.val + elif t2.right: + t1.right = t2.right + t2.right = None + + self.mergeChildTrees(t1.left, t2.left) + self.mergeChildTrees(t1.right, t2.right) +``` + + +### 646. [Maximum Length of Pair Chain](https://leetcode.com/problems/maximum-length-of-pair-chain/description/) +```javascript +/** + * @param {number[][]} pairs + * @return {number} + */ +var findLongestChain = function(pairs) { + pairs = pairs.sort((a, b) => a[0] - b[0]); + + var len = pairs.length; + var dp = Array(len).fill(1); + + for (var i = 1; i < len; i++) { + for (var j = 0; j < i; j++) { + if (pairs[i][0] > pairs[j][1]) { + dp[i] = Math.max(dp[i], dp[j] + 1); + } + } + } + + return Math.max.apply(null, dp); +}; +``` + + +### 647. [Palindromic Substrings](https://leetcode.com/problems/palindromic-substrings/description/) +```javascript +/** + * @param {string} s + * @return {number} + */ + +function isPalindromic(s) { + for (var i = 0, j = s.length - 1; i < j; i++, j--) { + if(s[i] !== s[j]) { + return false; + } + } + return true; +} +var countSubstrings = function(s) { + var count = 0; + var sub; + for(i = 0; i < s.length; i++) { + for(j = i + 1; j <= s.length; j++) { + sub = s.slice(i, j); + if (isPalindromic(sub)) { + count++; + } + } + } + return count; +}; +``` + + +### 650. [2 Keys Keyboard](https://leetcode.com/problems/2-keys-keyboard/description/) +```javascript +/** + * @param {number} n + * @return {number} + */ +var minSteps = function(n) { + if (n === 1) return 0; + var ret = 0; + for (var i = 2; i <= n; i++) { + while( n !== i) { + if (n % i === 0) { + n = n / i; + ret = ret + i; + } else { + break; + } + } + } + ret = ret + n; + return ret; +}; +``` + + +### 657. [Robot Return to Origin](https://leetcode.com/problems/robot-return-to-origin/description/) +```python +class Solution(object): + def judgeCircle(self, moves): + v = 0 + h = 0 + for i in moves: + if i == 'U': + v += 1 + elif i == 'D': + v -= 1 + elif i == 'L': + h -= 1 + elif i == 'R': + h += 1 + + return v == 0 and h == 0 +``` + + +### 681. [Next Closest Time](https://leetcode.com/problems/next-closest-time/description/) +```javascript +/** + * @param {string} time + * @return {string} + */ +var nextClosestTime = function(time) { + var cur = parseInt(time.slice(0, 2)) * 60 + parseInt(time.slice(3)); + var charMap = {}; + time.split('') + .filter(i => i != ':') + .forEach(key => charMap[key] = true); + + for (var i = 1; i <= 24 * 60; i++) { + var next = (cur + i) % (24 * 60); + var hour = parseInt(next / 60); + var min = next - hour * 60; + + var h1 = String(parseInt(hour / 10)); + var h2 = String(hour % 10); + var m1 = String(parseInt(min / 10)); + var m2 = String(parseInt(min % 10)); + + if (charMap[h1] && charMap[h2] && charMap[m1] && charMap[m2]) { + return h1 + h2 + ':' + m1 + m2; + } + } +}; +``` + + +### 686. [Repeated String Match](https://leetcode.com/problems/repeated-string-match/description/) +```python +class Solution(object): + def repeatedStringMatch(self, A, B): + count = 0 + target = '' + while (len(target) < len(B)): + target = target + A + count += 1 + if target.find(B) > -1: + return count + elif (target + A).find(B) > -1: + return count + 1 + else: + return -1 +``` + + +### 687. [Longest Univalue Path](https://leetcode.com/problems/longest-univalue-path/description/) +```python +# Definition for a binary tree node. +# class TreeNode(object): +# def __init__(self, x): +# self.val = x +# self.left = None +# self.right = None + +class Solution(object): + def longestUnivaluePath(self, root): + """ + :type root: TreeNode + :rtype: int + """ + if root == None: + return 0 + self.maxPath = 0 + self.find(root, root.val) + return self.maxPath + + def find(self, node, val): + if node == None: + return 0 + left = self.find(node.left, node.val) + right = self.find(node.right, node.val) + self.maxPath = max(self.maxPath, right + left) + if node.val == val: + return max(right, left) + 1 + else: + return 0 +``` + + +### 712. [Minimum ASCII Delete Sum for Two Strings](https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/description/) +```javascript +/** + * @param {string} s1 + * @param {string} s2 + * @return {number} + */ +var minimumDeleteSum = function(s1, s2) { + var dp = Array(s1.length + 1).fill(0).map(() => Array(s2.length + 1).fill(0)); + for (var i = 1; i <= s1.length; i++) { + dp[i][0] = s1[i - 1].charCodeAt() + dp[i - 1][0]; + } + for (var j = 1; j <= s2.length; j++) { + dp[0][j] = s2[j - 1].charCodeAt() + dp[0][j - 1]; + } + + for (var i = 1; i <= s1.length; i++) { + for (var j = 1; j <= s2.length; j++) { + if (s1[i - 1] === s2[j - 1]) { + dp[i][j] = dp[i - 1][j - 1]; + } else { + dp[i][j] = Math.min( + dp[i - 1][j] + s1[i - 1].charCodeAt(), + dp[i][j - 1] + s2[j - 1].charCodeAt(), + ); + } + } + } + + return dp[s1.length][s2.length]; + +}; +``` + + +### 733. [Flood Fill](https://leetcode.com/problems/flood-fill/description/) +```javascript +/** + * @param {number[][]} image + * @param {number} sr + * @param {number} sc + * @param {number} newColor + * @return {number[][]} + */ +var floodFill = function(image, sr, sc, newColor) { + if (image.length === 0) { + return; + } + if (image[0].length === 0) { + return; + } + + var queue = [[sr,sc]]; + var isVisited = {}; + var oldColor = image[sr][sc]; + var option = [[1, 0], [-1, 0], [0, 1], [0, -1]]; + + while(queue.length > 0) { + var point = queue.shift(); + + isVisited[point[0] + '_' + point[1]] = true; + image[point[0]][point[1]] = newColor; + + option.forEach((delta) => { + var dest = [point[0] + delta[0], point[1] + delta[1]]; + if (isVisited[dest[0] + '_' + dest[1]] === undefined && + dest[0] >= 0 && dest[0] < image.length && dest[1] >= 0 && dest[1] < image[0].length && + image[dest[0]][dest[1]] === oldColor + ) { + queue.push(dest); + } + }) + } + return image; +}; +``` + + +### 740. [Delete and Earn](https://leetcode.com/problems/delete-and-earn/description/) +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var deleteAndEarn = function(nums) { + if(nums.length === 0) return 0; + if(nums.length === 1) return nums[0]; + + + var max = Math.max.apply(null, nums) + var len = max + 1; + + var map = {}; + for (var i = 0; i < len; i++) { + map[i] = 0; + } + for (var i = 0; i < nums.length; i++) { + map[nums[i]] += nums[i]; + } + + var dp = Array(len).fill(0); + dp[1] = map[1]; + + for (var i = 2; i < len; i++) { + dp[i] = Math.max( + map[i] + dp[i - 2], + dp[i - 1] + ) + } + + return dp[len - 1]; +}; +``` + + +### 747. [Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/description/) +```python +class Solution(object): + def minCostClimbingStairs(self, cost): + """ + :type cost: List[int] + :rtype: int + """ + count = len(cost) + dp = [None] * count + dp[0] = cost[0] + dp[1] = cost[1] + for i in range(2, count): + dp[i] = min(dp[i - 1] + cost[i], dp[i - 2] + cost[i]) + + return min(dp[count - 1], dp[count - 2]) +``` + + +### 909. [Stone Game](https://leetcode.com/problems/stone-game/description/) +```javascript +/** + * @param {number[]} piles + * @return {boolean} + */ +var stoneGame = function(piles) { + var len = piles.length; + const dp = Array(len).fill(0).map(() => Array(len).fill(0)); + + for (var i = i; i < len; i++) dp[i][i] = piles[i]; + + for (var j = 1; j < len; j++) { + for (var i = 0; i < len - j; i++) { + dp[i][j] = Math.max( + piles[i] - dp[i - i][j], + piles[j] - dp[i][j - 1] + ) + } + } + + return dp[0][len - 1] > 0; +}; +``` + diff --git a/old(deprecated)/Algorithms/01 Matrix/README.md b/old(deprecated)/Algorithms/01 Matrix/README.md new file mode 100644 index 0000000..86b12f7 --- /dev/null +++ b/old(deprecated)/Algorithms/01 Matrix/README.md @@ -0,0 +1,73 @@ +# [01 Matrix](https://leetcode.com/problems/01-matrix/#/description) +###### No:`542` +###### Difficulty:`Medium` + + +### LeetCode Weekly Contest 24 +### 542. 01 Matrix +Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell. +The distance between two adjacent cells is 1. +#### Example 1 +Input: +``` +0 0 0 +0 1 0 +0 0 0 +``` +Output: +``` +0 0 0 +0 1 0 +0 0 0 +``` +#### Example 2 +Input: +``` +0 0 0 +0 1 0 +1 1 1 +``` +Output: +``` +0 0 0 +0 1 0 +1 2 1 +``` + +#### Solution +```js +/** + * @param {number[][]} matrix + * @return {number[][]} + */ +var updateMatrix = function(matrix) { + var m = matrix.length; + var n = matrix[0].length; + var queue = []; + + for (var i = 0; i < m; i++) { + for (var j = 0; j < n; j++) { + if (matrix[i][j] === 0) { + queue.push([i, j]); + } else { + matrix[i][j] = undefined; + } + } + } + + while (queue.length > 0) { + var [x, y] = queue.shift(); + var range = [[-1,0], [1, 0], [0, -1], [0, 1]]; + range.forEach(([p, q]) => { + p += x; + q += y; + if (p < 0 || p >= m || q < 0 || q >= n) return; + if (matrix[p][q] !== undefined && matrix[p][q] < matrix[x][y] + 1) return; + matrix[p][q] = matrix[x][y] + 1; + queue.push([p, q]); + }); + } + + return matrix; +}; +``` diff --git a/old(deprecated)/Algorithms/3Sum Closest/README.md b/old(deprecated)/Algorithms/3Sum Closest/README.md new file mode 100644 index 0000000..9a11268 --- /dev/null +++ b/old(deprecated)/Algorithms/3Sum Closest/README.md @@ -0,0 +1,44 @@ +# [3Sum Closest](https://leetcode.com/problems/3sum-closest/) +###### No:`16` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +var threeSumClosest = function(nums, target) { + var closet = Number.MAX_SAFE_INTEGER; + var closetTarget; + + nums = nums.sort((a, b) => a - b); + + for (var i = 0; i + 2 < nums.length; i++) { + if (i > 0 && nums[i] == nums[i - 1]) { + continue; + } + + var j = i + 1, k = nums.length - 1; + + while (j < k) { + if (Math.abs(nums[j] + nums[k] + nums[i] - target) < closet) { + closet = Math.abs(nums[j] + nums[k] + nums[i] - target); + closetTarget = nums[j] + nums[k] + nums[i]; + } + + if (nums[j] + nums[k] + nums[i] === target) { + return target; + } else if (nums[j] + nums[k] + nums[i] > target) { + k--; + } else { + j++; + } + } + } + + return closetTarget; +}; + +``` diff --git a/old(deprecated)/Algorithms/3Sum/README.md b/old(deprecated)/Algorithms/3Sum/README.md new file mode 100644 index 0000000..3523d60 --- /dev/null +++ b/old(deprecated)/Algorithms/3Sum/README.md @@ -0,0 +1,96 @@ +# [3Sum](https://leetcode.com/problems/3sum/) +###### No:`15` +###### Difficulty:`Medium` + + +### Solution 1 +Result: `timeout` +How: Use the data structure SumNode. Make sure the key is unique. +```javascript +/** + * @param {number[]} nums + * @return {number[][]} + */ +var SumNode = function(nums, i, j) { + this.i = i; + this.j = j; + this.sum = nums[i] + nums[j]; + + var max = Math.max(nums[i], nums[j], -this.sum); + var min = Math.min(nums[i], nums[j], -this.sum); + var mid = 0 - max - min; + this.key = [max, mid, min].join('_'); + this.isUsed = false; + +} + +var threeSum = function (nums) { + var ret = []; + var sumNodes = {}; + var node = null; + + for (var i = 0; i < nums.length; i++) { + for (var j = i + 1; j < nums.length; j++) { + node = new SumNode(nums, i, j); + sumNodes[node.key] = node; + } + } + + for (var key in sumNodes) { + node = sumNodes[key]; + for(var k = 0; k < nums.length; k++) { + if (k !== node.i && + k !== node.j && + node.sum + nums[k] === 0 && + !node.isUsed + ) { + delete sumNodes[key]; + node.isUsed = true; + ret.push([nums[k], nums[node.i], nums[node.j]]); + } + } + } + + return ret; +}; + +``` + +### Solution 2 +Result: timeout +```javascript +/** + * @param {number[]} nums + * @return {number[][]} + */ + +var threeSum = function(nums) { + var ret = []; + + nums = nums.sort((a, b) => a - b); + for (var i = 0; i + 2 < nums.length; i++) { + if (i > 0 && nums[i] == nums[i - 1]) { + continue; + } + + var j = i + 1, k = nums.length - 1; + var target = -nums[i]; + + while (j < k) { + if (nums[j] + nums[k] == target) { + ret.push([nums[i], nums[j], nums[k]]); + j++; + k--; + while (j < k && nums[j] == nums[j - 1]) j++; + while (j < k && nums[k] == nums[k + 1]) k--; + } else if (nums[j] + nums[k] > target) { + k--; + } else { + j++; + } + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Add Digits/README.md b/old(deprecated)/Algorithms/Add Digits/README.md new file mode 100644 index 0000000..1425167 --- /dev/null +++ b/old(deprecated)/Algorithms/Add Digits/README.md @@ -0,0 +1,35 @@ +# [Add Digits](https://leetcode.com/problems/add-digits/) +###### No:`258` +###### Difficulty:`Easy` + + +#### Solution 1: +```javascript +/** + * @param {number} num + * @return {number} + */ +var addDigits = function(num) { + if(num < 10) { + return num; + } else { + var arr = (num + '').split(''); + var ret = arr.reduce(function(prev, cur) { + return parseInt(prev, 10) + parseInt(cur, 10); + }); + return addDigits(ret); + } +}; +``` + + +#### Solution 2: +```javascript +/** + * @param {number} num + * @return {number} + */ +var addDigits = function(num) { + return 1 + (num - 1) % 9; +}; +``` diff --git a/old(deprecated)/Algorithms/Add Strings/README.md b/old(deprecated)/Algorithms/Add Strings/README.md new file mode 100644 index 0000000..4658de4 --- /dev/null +++ b/old(deprecated)/Algorithms/Add Strings/README.md @@ -0,0 +1,47 @@ +# [Add Strings](https://leetcode.com/problems/add-strings/) +###### No:`415` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} num1 + * @param {string} num2 + * @return {string} + */ +var addStrings = function(num1, num2) { + var zeroString = Array(Math.abs(num1.length - num2.length) + 1).join(0); + if (num1.length > num2.length) { + num2 = zeroString + num2; + } else { + num1 = zeroString + num1; + } + + var d1 = num1.split(''); + var d2 = num2.split(''); + var ret = []; + var sum ; + var hasCarryOver = false; + + for(var i = d1.length - 1; i >= 0 ; i--) { + sum = parseInt(d1[i]) + parseInt(d2[i]); + if (hasCarryOver) { + sum++; + } + if(sum >= 10) { + sum -= 10; + hasCarryOver = true; + } else { + hasCarryOver = false; + } + ret.unshift(sum); + } + + if(hasCarryOver) { + ret.unshift(1); + } + + return ret.join(''); +}; + +``` diff --git a/old(deprecated)/Algorithms/Arithmetic Slices/README.md b/old(deprecated)/Algorithms/Arithmetic Slices/README.md new file mode 100644 index 0000000..7dc61a4 --- /dev/null +++ b/old(deprecated)/Algorithms/Arithmetic Slices/README.md @@ -0,0 +1,35 @@ +# [Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/#/description) +###### No:`413` +###### Difficulty:`Medium` + + + +```js +/** + * @param {number[]} A + * @return {number} + */ +var count = function(len) { + return len < 3 ? 0 : (1+ len - 2) * (len - 2) / 2; +}; + +var numberOfArithmeticSlices = function(A) { + if (A.length < 3) return 0; + var len = 2; + var diff = A[1] - A[0]; + var ret = 0; + + for (var i = 1; i < A.length - 1; i++) { + if (diff === A[i + 1] - A[i]) { + len++ + } else { + ret += count(len); + diff = A[i + 1] - A[i]; + len = 2; + } + } + ret += count(len); + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Arranging Coins/README.md b/old(deprecated)/Algorithms/Arranging Coins/README.md new file mode 100644 index 0000000..712bcea --- /dev/null +++ b/old(deprecated)/Algorithms/Arranging Coins/README.md @@ -0,0 +1,30 @@ +# [Arranging Coins](https://leetcode.com/problems/arranging-coins/#/description) +###### No:`441` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} n + * @return {number} + */ +var arrangeCoins = function(n) { + if (n === 0) {return 0;} + var start = 0; + var end = n; + var middle = parseInt((start + end + 1) / 2); + + while (start <= end) { + if ((1 + middle) * middle / 2 <= n && n < (2 + middle) * (middle + 1) / 2) { + return middle; + } else if ((2 + middle) * (middle + 1) / 2 <= n) { + start = middle + 1; + } else if ((1 + middle) * middle / 2 > n) { + end = middle - 1; + } + middle = parseInt((start + end) / 2); + } +}; + +``` diff --git a/old(deprecated)/Algorithms/Assign Cookies/README.md b/old(deprecated)/Algorithms/Assign Cookies/README.md new file mode 100644 index 0000000..cfee914 --- /dev/null +++ b/old(deprecated)/Algorithms/Assign Cookies/README.md @@ -0,0 +1,33 @@ +# [Assign Cookies](https://leetcode.com/problems/assign-cookies/) +###### No:`455` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} g + * @param {number[]} s + * @return {number} + */ +var findContentChildren = function(g, s) { + var compare = (a, b) => a - b; + g = g.sort(compare); + s = s.sort(compare); + + var i = s.length - 1; // person index + var j = g.length - 1; // cookie index + var count = 0; + + while (i >= 0 && j >= 0) { + if(s[i] >= g[j]) { + i--; + j--; + count++ + } else { + j--; + } + } + + return count; +}; +``` diff --git a/old(deprecated)/Algorithms/Balanced Binary Tree/README.md b/old(deprecated)/Algorithms/Balanced Binary Tree/README.md new file mode 100644 index 0000000..10475e3 --- /dev/null +++ b/old(deprecated)/Algorithms/Balanced Binary Tree/README.md @@ -0,0 +1,44 @@ +# [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) +###### No:`110` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ +var maxDeepth = function(root) { + if(root === null) { + return 0; + } else { + return Math.max(maxDeepth(root.left), maxDeepth(root.right)) + 1; + } +} +var isBalanced = function(root) { + if(root === null) { + return true; + } + var leftDeepth = maxDeepth(root.left); + var rightDeepth = maxDeepth(root.right); + + if(Math.abs(leftDeepth - rightDeepth) <= 1 + && isBalanced(root.left) + && isBalanced(root.right) + ) { + return true; + } else { + return false; + } +}; +``` + +#### Description: +Calculate the deepth of the Binary Tree is also a problem in here: [https://leetcode.com/problems/maximum-depth-of-binary-tree](https://leetcode.com/problems/maximum-depth-of-binary-tree) diff --git a/old(deprecated)/Algorithms/Base 7/README.md b/old(deprecated)/Algorithms/Base 7/README.md new file mode 100644 index 0000000..b470ec3 --- /dev/null +++ b/old(deprecated)/Algorithms/Base 7/README.md @@ -0,0 +1,17 @@ +# [Base 7](https://leetcode.com/problems/base-7/#/description) +###### No:`504` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} num + * @return {string} + */ +var convertToBase7 = function(num) { + if (num < 0) return '-' + convertToBase7(-num); + else if (num < 7) return String(num); + else return convertToBase7(parseInt(num / 7)) + num % 7; +}; +``` diff --git a/old(deprecated)/Algorithms/Beautiful Arrangement/README.md b/old(deprecated)/Algorithms/Beautiful Arrangement/README.md new file mode 100644 index 0000000..4f0722b --- /dev/null +++ b/old(deprecated)/Algorithms/Beautiful Arrangement/README.md @@ -0,0 +1,35 @@ +# [Beautiful Arrangement](https://leetcode.com/problems/beautiful-arrangement/#/description) +###### No:`526` +###### Difficulty:`Medium` + + + +```js +/** + * @param {number} N + * @return {number} + */ +var countArrangement = function(N) { + var position = []; + for (var i = 1; i <= N; i++) position.push(i); + var value = position.slice(); + + var ret = 0; + var count = function(position, value) { + if (position.length === 1 && value.length === 1) { + if (position[0] % value[0] === 0 || value[0] % position[0] === 0) { + ret++; + } + return + } + for (var i = 0; i < position.length; i++) { + if (position[i] % value[0] === 0 || value[0] % position[i] === 0) { + count(position.slice(0, i).concat(position.slice(i + 1)), value.slice(1)); + } + } + }; + count(position, value); + return ret; +}; + +``` diff --git a/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock II/README.md b/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock II/README.md new file mode 100644 index 0000000..47071af --- /dev/null +++ b/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock II/README.md @@ -0,0 +1,36 @@ +# [Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/) +###### No:`122` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} prices + * @return {number} + */ +var maxProfit = function(prices) { + var minsum = 0; + var maxsum = 0; + var isUp; + var lastIsUp; + + for(var i = 0; i < prices.length - 1; i++) { + if(prices[i] < prices[i+1]) { + isUp = true; + } else { + isUp = false; + } + if(isUp && (i === 0 || lastIsUp === false)) { + minsum += prices[i]; + } + if(lastIsUp && isUp === false) { + maxsum += prices[i]; + } + if(isUp && i === prices.length - 2) { + maxsum += prices[i + 1]; + } + lastIsUp = isUp; + } + return maxsum - minsum; +}; +``` diff --git a/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock/README.md b/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock/README.md new file mode 100644 index 0000000..3d83f5c --- /dev/null +++ b/old(deprecated)/Algorithms/Best Time to Buy and Sell Stock/README.md @@ -0,0 +1,23 @@ +# [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/#/description) +###### No:`121` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} prices + * @return {number} + */ +var maxProfit = function(prices) { + var min = Number.MAX_VALUE; + var profit = 0; + + for(var i = 0; i < prices.length; i++) { + min = Math.min(min, prices[i]); + profit = Math.max(profit, prices[i] - min); + } + + return profit; +}; +``` diff --git a/old(deprecated)/Algorithms/Binary Tree Level Order Traversal II/README.md b/old(deprecated)/Algorithms/Binary Tree Level Order Traversal II/README.md new file mode 100644 index 0000000..22b3407 --- /dev/null +++ b/old(deprecated)/Algorithms/Binary Tree Level Order Traversal II/README.md @@ -0,0 +1,34 @@ +# [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/) +###### No:`107` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[][]} + */ +var traversal = function(ret, root, depth) { + if(root === null) { + return; + } + if(!Array.isArray(ret[depth])) { + ret[depth] = []; + } + ret[depth].push(root.val); + traversal(ret, root.left, depth + 1); + traversal(ret, root.right, depth + 1); +} +var levelOrderBottom = function(root) { + var ret = []; + traversal(ret, root, 0); + return ret.reverse(); +}; +``` diff --git a/old(deprecated)/Algorithms/Binary Tree Level Order Traversal/README.md b/old(deprecated)/Algorithms/Binary Tree Level Order Traversal/README.md new file mode 100644 index 0000000..691ec4f --- /dev/null +++ b/old(deprecated)/Algorithms/Binary Tree Level Order Traversal/README.md @@ -0,0 +1,35 @@ +# [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/) +###### No:`102` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[][]} + */ +var traversal = function(ret, root, depth) { + if(root === null) { + return; + } + if(!Array.isArray(ret[depth])) { + ret[depth] = []; + } + ret[depth].push(root.val); + traversal(ret, root.left, depth + 1); + traversal(ret, root.right, depth + 1); +} + +var levelOrder = function(root) { + var ret = []; + traversal(ret, root, 0); + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Binary Tree Paths/README.md b/old(deprecated)/Algorithms/Binary Tree Paths/README.md new file mode 100644 index 0000000..c93ac26 --- /dev/null +++ b/old(deprecated)/Algorithms/Binary Tree Paths/README.md @@ -0,0 +1,43 @@ +# [Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/) +###### No:`257` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {string[]} + */ +var binaryTreePaths = function(root) { + if(root === null) { + return []; + } + var ret = []; + var str = arguments[1] ? arguments[1] : ''; + if(str) { + str = str + '->' + root.val; + } else { + str = root.val + ''; + } + if(root.left === null && root.right === null) { + ret.push(str); + } + + if(root.left) { + var leftRet = binaryTreePaths(root.left, str); + Array.prototype.push.apply(ret, leftRet); + } + if(root.right) { + var rightRet = binaryTreePaths(root.right, str); + Array.prototype.push.apply(ret, rightRet); + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Binary Tree Preorder Traversal/README.md b/old(deprecated)/Algorithms/Binary Tree Preorder Traversal/README.md new file mode 100644 index 0000000..ce02dd9 --- /dev/null +++ b/old(deprecated)/Algorithms/Binary Tree Preorder Traversal/README.md @@ -0,0 +1,34 @@ +# [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) +###### No:`144` +###### Difficulty:`Medium` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ + +var preorderTraversal = function(root) { + if(root === null) return []; + var ret = []; + + function pre(root) { + if(root) { + ret.push(root.val); + pre(root.left); + pre(root.right); + } + } + + pre(root); + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Binary Watch/README.md b/old(deprecated)/Algorithms/Binary Watch/README.md new file mode 100644 index 0000000..78699b3 --- /dev/null +++ b/old(deprecated)/Algorithms/Binary Watch/README.md @@ -0,0 +1,36 @@ +# [Binary Watch](https://leetcode.com/problems/binary-watch/) +###### No:`401` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} num + * @return {string[]} + */ + +var bitcount1 = function (num) { + return (num).toString(2).split('').filter(i => i === '1').length; +} +var formatTime = function(h, m) { + if (m < 10) { + return `${h}:0${m}` + } else { + return `${h}:${m}` + } +} + +var readBinaryWatch = function(num) { + var ret = []; + + for (var h = 0; h < 12; h++) { + for (var m = 0; m < 60; m++) { + if(bitcount1(h << 6 | m) === num) { + ret.push(formatTime(h, m)); + } + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Bulb Switcher/README.md b/old(deprecated)/Algorithms/Bulb Switcher/README.md new file mode 100644 index 0000000..276441f --- /dev/null +++ b/old(deprecated)/Algorithms/Bulb Switcher/README.md @@ -0,0 +1,42 @@ +# [Add Digits](https://leetcode.com/problems/add-digits/) +###### No:`319` +###### Difficulty:`Medium` + + +#### Solution 1: +refer: https://leetcode.com/discuss/91371/share-my-o-1-solution-with-explanation +```js +/** + * @param {number} n + * @return {number} + */ +var bulbSwitch = function(n) { + return parseInt(Math.sqrt(n)); +}; +``` + + +#### Solution 2: +#### Time Limit Exceeded. Input: 9999999 +```js +/** + * @param {number} n + * @return {number} + */ +var bulbSwitch = function(n) { + var bulbs = new Array(n).fill(0); + for(i = 1; i <= n; i++) { + for(var j = i; j <= n; j = j + i) { + bulbs[j-1] = 1 - bulbs[j-1]; + } + } + var sum = 0; + + for(var i = 0; i < bulbs.length; i++) { + if(bulbs[i] == 1) { + sum++; + } + } + return sum; +}; +``` diff --git a/old(deprecated)/Algorithms/Climbing Stairs/README.md b/old(deprecated)/Algorithms/Climbing Stairs/README.md new file mode 100644 index 0000000..73d87cb --- /dev/null +++ b/old(deprecated)/Algorithms/Climbing Stairs/README.md @@ -0,0 +1,24 @@ +# [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/) +###### No:`70` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return + * + * s[n] = s[n-1] + s[n] + * s[1] = 1; + * s[2] = 2; + */ +var climbStairs = function(n) { + var s = {}; + s[1] = 1; + s[2] = 2; + for(var i = 3; i<=n; i++) { + s[i] = s[i-1] + s[i-2]; + } + return s[n]; +}; +``` diff --git a/old(deprecated)/Algorithms/Compare Version Numbers/README.md b/old(deprecated)/Algorithms/Compare Version Numbers/README.md new file mode 100644 index 0000000..7164fa4 --- /dev/null +++ b/old(deprecated)/Algorithms/Compare Version Numbers/README.md @@ -0,0 +1,31 @@ +# [Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/) +###### No:`165` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} version1 + * @param {string} version2 + * @return {number} + */ +var compareVersion = function(version1, version2) { + var arr1 = version1.split('.').map(function(item) { + return parseInt(item); + }); + var arr2 = version2.split('.').map(function(item) { + return parseInt(item); + }); + var a, b; + for(var i = 0; i < arr1.length || i < arr2.length; i++) { + a = i >= arr1.length ? 0 : arr1[i]; + b = i >= arr2.length ? 0 : arr2[i]; + if(a > b) { + return 1; + } else if(a < b) { + return -1; + } + } + return 0; +}; +``` diff --git a/old(deprecated)/Algorithms/Construct the Rectangle/README.md b/old(deprecated)/Algorithms/Construct the Rectangle/README.md new file mode 100644 index 0000000..4049f65 --- /dev/null +++ b/old(deprecated)/Algorithms/Construct the Rectangle/README.md @@ -0,0 +1,23 @@ +# [Construct the Rectangle](https://leetcode.com/problems/construct-the-rectangle/#/description) +###### No:`492` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} area + * @return {number[]} + */ +var constructRectangle = function(area) { + var root = parseInt(Math.sqrt(area)); + var ret = []; + for (var i = root; i <= area; i++) { + if (area % i === 0) { + i > area / i ? ret.push(i, area / i) : ret.push(area / i, i); + break; + } + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Contains Duplicate II/README.md b/old(deprecated)/Algorithms/Contains Duplicate II/README.md new file mode 100644 index 0000000..5038eb4 --- /dev/null +++ b/old(deprecated)/Algorithms/Contains Duplicate II/README.md @@ -0,0 +1,37 @@ +# [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) +###### No:`219` +###### Difficulty:`Easy` + + +#### Solution 1: (slower) +```javascript +var containsNearbyDuplicate = function(nums, k) { + for(var i = 0; i < nums.length; i++) { + for(var j = i + 1; j < nums.length && j - i <= k; j++) { + if(nums[i] === nums[j]) { + return true; + } + } + } + return false; +}; +``` + +#### Solution 2: (faster) +```javascript +var containsNearbyDuplicate = function(nums, k) { + var index = {}; + var value; + for(var i = 0; i < nums.length; i++) { + value = nums[i]; + if(index[value] === undefined) { + index[value] = [i]; + } else if(i - index[value][index[value].length - 1] <= k){ + return true; + } else { + index[value].push(i); + } + } + return false; +} +``` diff --git a/old(deprecated)/Algorithms/Contains Duplicate/README.md b/old(deprecated)/Algorithms/Contains Duplicate/README.md new file mode 100644 index 0000000..ebc9fa4 --- /dev/null +++ b/old(deprecated)/Algorithms/Contains Duplicate/README.md @@ -0,0 +1,21 @@ +# [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) +###### No:`217` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {boolean} + */ +var containsDuplicate = function(nums) { + for(var i = 0; i < nums.length; i++) { + for(var j = i + 1 ; j < nums.length; j++) { + if(nums[i] == nums[j]) { + return true; + } + } + } + return false; +}; +``` diff --git a/old(deprecated)/Algorithms/Convert BST to Greater Tree/README.md b/old(deprecated)/Algorithms/Convert BST to Greater Tree/README.md new file mode 100644 index 0000000..b199004 --- /dev/null +++ b/old(deprecated)/Algorithms/Convert BST to Greater Tree/README.md @@ -0,0 +1,49 @@ +# [Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/#/description) +###### No:`538` +###### Difficulty:`Medium` + + +### LeetCode Weekly Contest 24 +### 538. Convert BST to Greater Tree +Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST. + +#### Example +``` +Input: The root of a Binary Search Tree like this: + 5 + / \ + 2 13 + +Output: The root of a Greater Tree like this: + 18 + / \ + 20 13 +``` +#### Solution +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {TreeNode} + */ +var convertBST = function(root) { + var sum = 0; + function traverse (root) { + if (root === null) return; + traverse(root.right); + root.val = root.val + sum; + sum = root.val; + traverse(root.left); + } + + traverse(root); + return root; +}; +``` + diff --git a/old(deprecated)/Algorithms/Convert Sorted Array to Binary Search Tree/README.md b/old(deprecated)/Algorithms/Convert Sorted Array to Binary Search Tree/README.md new file mode 100644 index 0000000..a2c02ff --- /dev/null +++ b/old(deprecated)/Algorithms/Convert Sorted Array to Binary Search Tree/README.md @@ -0,0 +1,51 @@ +# [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/#/description) +###### No:`108` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {number[]} nums + * @return {TreeNode} + */ + +var sortedArrayToBST = function(nums) { + if (nums.length === 0) {return null;} + var start = 0; + var end = nums.length - 1; + var middle = parseInt((start + end) / 2); + + var root, node1, node2, node3; + + if (nums.length <= 3) { + node1 = new TreeNode(nums[0]); + if (nums.length === 1) { + return node1; + } + + node2 = new TreeNode(nums[1]); + node2.left = node1; + if (nums.length === 2) { + return node2; + } + + node3 = new TreeNode(nums[2]); + node2.right = node3; + return node2; + + } else { + root = new TreeNode(nums[middle]); + root.left = sortedArrayToBST(nums.slice(0, middle)); + root.right = sortedArrayToBST(nums.slice(middle + 1)); + } + return root; +}; +``` diff --git a/old(deprecated)/Algorithms/Copy List with Random Pointer/README.md b/old(deprecated)/Algorithms/Copy List with Random Pointer/README.md new file mode 100644 index 0000000..18df542 --- /dev/null +++ b/old(deprecated)/Algorithms/Copy List with Random Pointer/README.md @@ -0,0 +1,82 @@ +# [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/#/description) +###### No:`138` +###### Difficulty:`Medium` + + + +```js +/** + * Definition for singly-linked list with a random pointer. + * function RandomListNode(label) { + * this.label = label; + * this.next = this.random = null; + * } + */ + +/** + * @param {RandomListNode} head + * @return {RandomListNode} + */ + +var copyLinkList = function(head) { + if (head === null) { + return null; + } + + var new_head = new RandomListNode(head.label); + var new_current = new_head; + var node; + + head = head.next; + while(head !== null) { + node = new RandomListNode(head.label); + new_current.next = node; + new_current = node; + head = head.next; + } + + return new_head; +}; + +var copyRandomList = function(head) { + if (head === null) { + return null; + } + + var new_head = copyLinkList(head); + var new_list = []; + var old_list = []; + + var new_curr = new_head; + var old_curr = head; + while (new_curr !== null) { + new_list.push(new_curr); + old_list.push(old_curr); + new_curr = new_curr.next; + old_curr = old_curr.next; + } + + for (var i = 0; i < new_list.length; i++) { + new_list[i].random = old_list[i]; + old_list[i].next = new_list[i]; + } + + for (i = 0; i < new_list.length; i++) { + if (old_list[i].random === null) { + new_list[i].random = null; + } else { + new_list[i].random = old_list[i].random.next; + } + } + + for (i = 0; i < old_list.length - 1; i++) { + old_list[i].next = old_list[i + 1]; + } + old_list[old_list.length - 1].next = null; + + + return new_head; +}; + + +``` diff --git a/old(deprecated)/Algorithms/Count Primes/README.md b/old(deprecated)/Algorithms/Count Primes/README.md new file mode 100644 index 0000000..310ad9c --- /dev/null +++ b/old(deprecated)/Algorithms/Count Primes/README.md @@ -0,0 +1,36 @@ +# [Count Primes](https://leetcode.com/problems/count-primes/#/description) +###### No:`204` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} n + * @return {number} + */ +var countPrimes = function(n) { + var isPrime = []; + for (var i = 2; i < n; i++) { + isPrime[i] = true; + } + + for (var i = 2; i * i < n; i++) { + if (isPrime[i]) { + for (var j = i * i; j < n; j += i) { + isPrime[j] = false; + } + } + } + + var count = 0; + for (var i = 2; i < n; i++) { + if (isPrime[i]) { + count++; + } + } + + return count; +}; + +``` diff --git a/old(deprecated)/Algorithms/Count and Say/README.md b/old(deprecated)/Algorithms/Count and Say/README.md new file mode 100644 index 0000000..2feb67e --- /dev/null +++ b/old(deprecated)/Algorithms/Count and Say/README.md @@ -0,0 +1,33 @@ +# [Count and Say](https://leetcode.com/problems/count-and-say/#/description) +###### No:`38` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {number} n + * @return {string} + */ + +var countAndSay = function(n) { + if (n === 1) return '1'; + + var last = countAndSay(n - 1); + var digit = last[0]; + var count = 0; + var ret = ''; + + for (var i = 0; i < last.length; i++) { + if (last[i] !== digit) { + ret += count + digit; + digit = last[i]; + count = 0; + } + count++; + } + ret += count + digit; + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Counting Bits/README.md b/old(deprecated)/Algorithms/Counting Bits/README.md new file mode 100644 index 0000000..7da8c2a --- /dev/null +++ b/old(deprecated)/Algorithms/Counting Bits/README.md @@ -0,0 +1,25 @@ +# [Counting Bits](https://leetcode.com/problems/counting-bits/) +###### No:`338` +###### Difficulty:`Medium` + + +```javascript +var countBits = function(num) { + var ret = [0]; + var j = 1; + for(var i = 1; i <= num; i++) { + if(i == 1) {ret.push(1);continue;} + if(i == Math.pow(2, j+1)) j++; + ret.push(ret[i - Math.pow(2, j)] + 1); + } + return ret; +}; +``` + +#### How to solve? +DP: +countBits[0] = 0; +countBits[1] = 1; + +condition: max(j) && n>= Math.pow(2, j) +countBits[n] = countBits[n - Math.pow(2, j)] + 1; diff --git a/old(deprecated)/Algorithms/Delete Node in a BST/README.md b/old(deprecated)/Algorithms/Delete Node in a BST/README.md new file mode 100644 index 0000000..cc5c58e --- /dev/null +++ b/old(deprecated)/Algorithms/Delete Node in a BST/README.md @@ -0,0 +1,84 @@ +# [Delete Node in a BST](https://leetcode.com/problems/delete-node-in-a-bst/#/description) +###### No:`450` +###### Difficulty:`Medium` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} key + * @return {TreeNode} + */ +var update = function(parent, direction) { + if (parent === null) { + return; + } + var deleteNode = parent[direction]; + if (deleteNode.right) { + parent[direction] = deleteNode.right; + + var leftIsNullNode = deleteNode.right; + while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; + leftIsNullNode.left = deleteNode.left; + return parent; + } + if(deleteNode.left) { + parent[direction] = deleteNode.left; + return parent; + } + parent[direction] = null; + return parent; +}; + +var search = function(root, direction, key, ret) { + var node = root[direction]; + if (node === null) { + return; + } + + if (node.val === key) { + ret.parent = root; + ret.direction = direction; + } else if (node.val > key) { + search(node, 'left', key, ret); + } else { + search(node, 'right', key, ret); + } +}; + +var deleteNode = function(root, key) { + if (root === null) { + return null; + } + + if (root.val === key) { + if (root.right) { + var leftIsNullNode = root.right; + while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; + + leftIsNullNode.left = root.left; + return root.right; + } + return root.left; + } + + var ret = { + parent: null, + direction: null, + }; + search(root, 'left', key, ret); + search(root, 'right', key, ret); + update(ret.parent, ret.direction); + + return root; +}; + +``` diff --git a/old(deprecated)/Algorithms/Delete Node in a Linked List/README.md b/old(deprecated)/Algorithms/Delete Node in a Linked List/README.md new file mode 100644 index 0000000..ade4793 --- /dev/null +++ b/old(deprecated)/Algorithms/Delete Node in a Linked List/README.md @@ -0,0 +1,22 @@ +# [Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/) +###### No:`237` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} node + * @return {void} Do not return anything, modify node in-place instead. + */ +var deleteNode = function(node) { + node.val = node.next.val; + node.next = node.next.next; +}; +``` diff --git a/old(deprecated)/Algorithms/Detect Capital/README.md b/old(deprecated)/Algorithms/Detect Capital/README.md new file mode 100644 index 0000000..e6b21bc --- /dev/null +++ b/old(deprecated)/Algorithms/Detect Capital/README.md @@ -0,0 +1,15 @@ +# [Detect Capital](https://leetcode.com/problems/detect-capital/#/description) +###### No:`520` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string} word + * @return {boolean} + */ +var detectCapitalUse = function(word) { + return /^[A-Z]?([a-z]*|[A-Z]*)$/.test(word); +}; +``` diff --git a/old(deprecated)/Algorithms/Diameter of Binary Tree/README.md b/old(deprecated)/Algorithms/Diameter of Binary Tree/README.md new file mode 100644 index 0000000..e6da936 --- /dev/null +++ b/old(deprecated)/Algorithms/Diameter of Binary Tree/README.md @@ -0,0 +1,39 @@ +# [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/#/description) +###### No:`543` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var diameterOfBinaryTree = function(root) { + var maxDiameter = -1; + var getDepth = function(root) { + if (root === null) { + return 0; + } + var leftDepth = getDepth(root.left); + var rightDepth = getDepth(root.right); + + maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth); + maxDepth = Math.max(leftDepth, rightDepth) + 1; + return maxDepth; + }; + + if (root === null) return 0; + getDepth(root); + + return maxDiameter; +}; +``` diff --git a/old(deprecated)/Algorithms/Divide Two Integers/README.md b/old(deprecated)/Algorithms/Divide Two Integers/README.md new file mode 100644 index 0000000..5a68b07 --- /dev/null +++ b/old(deprecated)/Algorithms/Divide Two Integers/README.md @@ -0,0 +1,29 @@ +# [Divide Two Integers](https://leetcode.com/problems/divide-two-integers/#/description) +###### No:`29` +###### Difficulty:`Medium` +## JavaScript + + +```java +class Solution { +public: + int divide(int dividend, int divisor) { + if (!divisor || (dividend == INT_MIN && divisor == -1)) + return INT_MAX; + int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1; + long long dvd = labs(dividend); + long long dvs = labs(divisor); + int res = 0; + while (dvd >= dvs) { + long long temp = dvs, multiple = 1; + while (dvd >= (temp << 1)) { + temp <<= 1; + multiple <<= 1; + } + dvd -= temp; + res += multiple; + } + return sign == 1 ? res : -res; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Evaluate Reverse Polish Notation/README.md b/old(deprecated)/Algorithms/Evaluate Reverse Polish Notation/README.md new file mode 100644 index 0000000..56ec469 --- /dev/null +++ b/old(deprecated)/Algorithms/Evaluate Reverse Polish Notation/README.md @@ -0,0 +1,34 @@ +# [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) +###### No:`150` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {string[]} tokens + * @return {number} + */ + var evalRPN = function(tokens) { + var stack = []; + var a, b, result; + for(var i = 0; i < tokens.length; i++) { + if(Number.isNaN(parseInt(tokens[i]))) { + b = stack.pop(); + a = stack.pop(); + if(tokens[i] == '+') { + result = a + b; + } else if(tokens[i] == '-') { + result = a - b; + } else if(tokens[i] == '*') { + result = a * b; + } else if(tokens[i] == '/') { + result = a / b; + } + stack.push(parseInt(result, 10)); + } else { + stack.push(parseInt(tokens[i], 10)); + } + } + return stack.pop(); +}; +``` diff --git a/old(deprecated)/Algorithms/Excel Sheet Column Number/README.md b/old(deprecated)/Algorithms/Excel Sheet Column Number/README.md new file mode 100644 index 0000000..9532661 --- /dev/null +++ b/old(deprecated)/Algorithms/Excel Sheet Column Number/README.md @@ -0,0 +1,21 @@ +# [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) +###### No:`171` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {number} + */ +var titleToNumber = function(s) { + var arr = s.split(''); + var digit; + var sum = 0; + for(var i = arr.length - 1, j = 0; i >= 0; i--, j++) { + digit = arr[i].charCodeAt(0) - 64; + sum += digit * Math.pow(26, j) + } + return sum; +}; +``` diff --git a/old(deprecated)/Algorithms/Excel Sheet Column Title/README.md b/old(deprecated)/Algorithms/Excel Sheet Column Title/README.md new file mode 100644 index 0000000..813aab6 --- /dev/null +++ b/old(deprecated)/Algorithms/Excel Sheet Column Title/README.md @@ -0,0 +1,20 @@ +# [Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/) +###### No:`168` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {string} + */ +var convertToTitle = function(n) { + var ret = '' + while(n > 0) { + n--; + ret = String.fromCharCode(65 + n % 26) + ret; + n = Math.floor(n / 26); + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Factorial Trailing Zeroes/README.md b/old(deprecated)/Algorithms/Factorial Trailing Zeroes/README.md new file mode 100644 index 0000000..846e866 --- /dev/null +++ b/old(deprecated)/Algorithms/Factorial Trailing Zeroes/README.md @@ -0,0 +1,29 @@ +# [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) +###### No:`172` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {number} + */ +var trailingZeroes = function(n) { + var sum = 0; + var divisor = 5; + while(n >= divisor) { + sum += Math.floor(n / divisor); + divisor *= 5; + } + return sum; +}; +``` + +### How to solve? +Only 2 * 5 can make 0. +4, 6, 8 can represent as 2 * 2， 2 * 3， 2 * 2 * 2. So 2 is more then 5.You need only count the number 5. +5 catains one 5; +25 contains two 5; +125.. + +So count the number 5 is the answer. diff --git a/old(deprecated)/Algorithms/Find All Duplicates in an Array/README.md b/old(deprecated)/Algorithms/Find All Duplicates in an Array/README.md new file mode 100644 index 0000000..e22fd9c --- /dev/null +++ b/old(deprecated)/Algorithms/Find All Duplicates in an Array/README.md @@ -0,0 +1,24 @@ +# [Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/#/description) +###### No:`442` +###### Difficulty:`Medium` + + + +```js +/** + * @param {number[]} nums + * @return {number[]} + */ +var findDuplicates = function(nums) { + var ret = []; + for (var i = 0; i < nums.length; i++) { + var index = Math.abs(nums[i]) - 1; + if (nums[index] < 0) { + ret.push(Math.abs(nums[i])); + } + nums[index] = -Math.abs(nums[index]); + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Find All Numbers Disappeared in an Array/README.md b/old(deprecated)/Algorithms/Find All Numbers Disappeared in an Array/README.md new file mode 100644 index 0000000..d517d7d --- /dev/null +++ b/old(deprecated)/Algorithms/Find All Numbers Disappeared in an Array/README.md @@ -0,0 +1,28 @@ +# [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/#/description) +###### No:`448` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @return {number[]} + */ +var findDisappearedNumbers = function(nums) { + var map = {}; + var ret = []; + + nums.forEach(function(num) { + map[num] = true; + }); + + for (var i = 1; i <= nums.length; i++) { + if (map[i] === undefined) { + ret.push(i); + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Find Bottom Left Tree Value/README.md b/old(deprecated)/Algorithms/Find Bottom Left Tree Value/README.md new file mode 100644 index 0000000..49fe8c7 --- /dev/null +++ b/old(deprecated)/Algorithms/Find Bottom Left Tree Value/README.md @@ -0,0 +1,38 @@ +# [Find Bottom Left Tree Value](https://leetcode.com/problems/find-bottom-left-tree-value/#/description) +###### No:`513` +###### Difficulty:`Medium` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var findBottomLeftValue = function(root) { + var maxDepth = Number.MIN_SAFE_INTEGER; + var value; + + var traverse = function(root, depth) { + if (root === null) return; + if (depth > maxDepth) { + value = root.val; + maxDepth = depth; + } + traverse(root.left, depth + 1); + traverse(root.right, depth + 1); + }; + + traverse(root, 1); + return value; +}; + +``` diff --git a/old(deprecated)/Algorithms/Find Largest Value in Each Tree Row/README.md b/old(deprecated)/Algorithms/Find Largest Value in Each Tree Row/README.md new file mode 100644 index 0000000..c3b5104 --- /dev/null +++ b/old(deprecated)/Algorithms/Find Largest Value in Each Tree Row/README.md @@ -0,0 +1,38 @@ +# [Find Largest Value in Each Tree Row](https://leetcode.com/problems/find-largest-value-in-each-tree-row/#/description) +###### No:`515` +###### Difficulty:`Medium` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ +var largestValues = function(root) { + if (root === null) return []; + var left = largestValues(root.left); + var right = largestValues(root.right); + + var ret = []; + for(var i = 0; i < left.length || i < right.length; i++) { + if (left[i] === undefined) { + ret.push(right[i]); + } else if (right[i] === undefined) { + ret.push(left[i]); + } else { + ret.push(Math.max(right[i], left[i])); + } + } + ret.unshift(root.val); + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Find Mode in Binary Search Tree/README.md b/old(deprecated)/Algorithms/Find Mode in Binary Search Tree/README.md new file mode 100644 index 0000000..75d4e18 --- /dev/null +++ b/old(deprecated)/Algorithms/Find Mode in Binary Search Tree/README.md @@ -0,0 +1,61 @@ +# [Find Mode in Binary Search Tree](https://leetcode.com/problems/find-mode-in-binary-search-tree/#/description) +###### No:`501` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ + +var traversal = function(root, func) { + if (root === null) { + return null; + } + traversal(root.left, func); + func(root.val); + traversal(root.right, func); +}; + +var findMode = function(root) { + if (root === null) return []; + + var ret; + var maxCount = Number.MIN_VALUE; + var prevValue; + var currentCount; + + traversal(root, function(val) { + if (prevValue === undefined) { + prevValue = val; + currentCount = 1; + } else { + if (prevValue === val) { + currentCount++; + } else { + currentCount = 1; + } + } + + if(currentCount > maxCount) { + ret = []; + ret.push(val); + maxCount = currentCount; + } else if (currentCount === maxCount) { + ret.push(val); + } + prevValue = val; + }); + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Find the Difference/README.md b/old(deprecated)/Algorithms/Find the Difference/README.md new file mode 100644 index 0000000..9ddd28e --- /dev/null +++ b/old(deprecated)/Algorithms/Find the Difference/README.md @@ -0,0 +1,18 @@ +# [Find the Difference](https://leetcode.com/problems/find-the-difference/) +###### No:`389` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @param {string} t + * @return {character} + */ +var findTheDifference = function(s, t) { + if(!s) return t; + var sSum = s.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); + var tSum = t.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); + return String.fromCharCode(tSum - sSum); +}; +``` diff --git a/old(deprecated)/Algorithms/First Bad Version/README.md b/old(deprecated)/Algorithms/First Bad Version/README.md new file mode 100644 index 0000000..3f7d81d --- /dev/null +++ b/old(deprecated)/Algorithms/First Bad Version/README.md @@ -0,0 +1,51 @@ +# [First Bad Version](https://leetcode.com/problems/first-bad-version/#/description) +###### No:`278` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for isBadVersion() + * + * @param {integer} version number + * @return {boolean} whether the version is bad + * isBadVersion = function(version) { + * ... + * }; + */ + +/** + * @param {function} isBadVersion() + * @return {function} + */ +var solution = function(isBadVersion) { + /** + * @param {integer} n Total versions + * @return {integer} The first bad version + */ + return function(n) { + var start = 1; + var end = n; + var middle; + while (start <= end) { + middle = start + Math.floor((end - start) / 2); + if (middle + 1 <= n && !isBadVersion(middle) && isBadVersion(middle + 1)) { + return middle + 1; + } + if (middle - 1 > 0 && !isBadVersion(middle - 1) && isBadVersion(middle)) { + return middle + } + if (middle === 1 && isBadVersion(middle)) { + return middle; + } + if (isBadVersion(middle)) { + end = middle - 1; + } else { + start = middle + 1; + } + } + return 'null'; + }; +}; +``` diff --git a/old(deprecated)/Algorithms/First Unique Character in a String/README.md b/old(deprecated)/Algorithms/First Unique Character in a String/README.md new file mode 100644 index 0000000..1a1ca53 --- /dev/null +++ b/old(deprecated)/Algorithms/First Unique Character in a String/README.md @@ -0,0 +1,25 @@ +# [First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/) +###### No:`387` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {number} + */ +var firstUniqChar = function(s) { + var map = {}; + + s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + for(var i = 0; i < s.length; i++) { + if(map[s[i]] === 1) { + return i; + } + } + + return -1; + +}; +``` diff --git a/old(deprecated)/Algorithms/Fizz Buzz/README.md b/old(deprecated)/Algorithms/Fizz Buzz/README.md new file mode 100644 index 0000000..eb00e59 --- /dev/null +++ b/old(deprecated)/Algorithms/Fizz Buzz/README.md @@ -0,0 +1,28 @@ +# [Fizz Buzz](https://leetcode.com/problems/fizz-buzz/) +###### No:`412` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {string[]} + */ +var fizzBuzz = function(n) { + var ret = []; + + for (var i = 1; i <= n; i++) { + if (i % 15 === 0) { + ret.push('FizzBuzz'); + } else if (i % 3 === 0) { + ret.push('Fizz'); + } else if (i % 5 === 0) { + ret.push('Buzz'); + } else { + ret.push(i + ''); + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Generate Parentheses/README.md b/old(deprecated)/Algorithms/Generate Parentheses/README.md new file mode 100644 index 0000000..516fd6f --- /dev/null +++ b/old(deprecated)/Algorithms/Generate Parentheses/README.md @@ -0,0 +1,32 @@ +# [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/) +###### No:`22` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number} n + * @return {string[]} + */ +var generateParenthesis = function(n) { + if(n === 0) { + return []; + } else if(n === 1){ + return ['()']; + } else { + var parenthesis = generateParenthesis(n - 1); + var retObj = {}; + + parenthesis.forEach(p => { + for(var i = 0; i < p.length + 1; i++) { + var charArr = p.split(''); + + charArr.splice(i, 0, '()'); + retObj[charArr.join('')] = true; + } + }); + + return Object.keys(retObj); + } +}; +``` diff --git a/old(deprecated)/Algorithms/Guess Number Higher or Lower/README.md b/old(deprecated)/Algorithms/Guess Number Higher or Lower/README.md new file mode 100644 index 0000000..0c1ca15 --- /dev/null +++ b/old(deprecated)/Algorithms/Guess Number Higher or Lower/README.md @@ -0,0 +1,32 @@ +# [Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/#/description) +###### No:`374` +###### Difficulty:`Easy` + + + +```js +/* The guess API is defined in the parent class GuessGame. + @param num, your guess + @return -1 if my number is lower, 1 if my number is higher, otherwise return 0 + int guess(int num); */ + +public class Solution extends GuessGame { + public int guessNumber(int n) { + int start = 1; + int end = n; + int middle; + + while (start <= end) { + middle = (end - start) / 2 + start; + if (guess(middle) == 0) { + return middle; + } else if (guess(middle) > 0) { + start = middle + 1; + } else { + end = middle - 1; + } + } + return 0; + } +} +``` diff --git a/old(deprecated)/Algorithms/Hamming Distance/README.md b/old(deprecated)/Algorithms/Hamming Distance/README.md new file mode 100644 index 0000000..f0a55a9 --- /dev/null +++ b/old(deprecated)/Algorithms/Hamming Distance/README.md @@ -0,0 +1,30 @@ +# [Hamming Distance](https://leetcode.com/problems/hamming-distance/#/description) +###### No:`461` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} x + * @param {number} y + * @return {number} + */ + +// Number of 1 Bits +var hammingWeight = function(n) { + var ret = 0; + for(var power = 32; power >= 0; power--) { + var exponent = Math.pow(2, power); + if (n >= exponent) { + ret++; + n -= exponent; + } + } + return ret; +}; + +var hammingDistance = function(x, y) { + return hammingWeight(x ^ y); +}; +``` diff --git a/old(deprecated)/Algorithms/Happy Number/README.md b/old(deprecated)/Algorithms/Happy Number/README.md new file mode 100644 index 0000000..ad2cc7d --- /dev/null +++ b/old(deprecated)/Algorithms/Happy Number/README.md @@ -0,0 +1,29 @@ +# [Happy Number](https://leetcode.com/problems/happy-number/) +###### No:`202` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {boolean} + */ + +var isHappy = function(n) { + var nums = []; + var ret = n; + + var squire = x => Math.pow(parseInt(x), 2); + var add = (prev, cur) => prev + cur; + while(ret !== 1) { + if(nums.indexOf(ret) > -1) { + return false; + } else { + nums.push(ret); + } + digits = ret.toString().split('').map(squire); + ret = digits.reduce(add); + } + return true; +} +``` diff --git a/old(deprecated)/Algorithms/House Robber/README.md b/old(deprecated)/Algorithms/House Robber/README.md new file mode 100644 index 0000000..f8805d7 --- /dev/null +++ b/old(deprecated)/Algorithms/House Robber/README.md @@ -0,0 +1,35 @@ +# [House Robber](https://leetcode.com/problems/house-robber/) +###### No:`198` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var rob = function(nums) { + if(nums.length === 0) { + return 0; + } + if(nums.length === 1) { + return nums[0]; + } + + var max = {}; + max[0] = nums[0]; + max[1] = Math.max(nums[0], nums[1]); + for(var i = 2; i < nums.length; i++) { + max[i] = Math.max(max[i - 2] + nums[i], max[i -1]); + } + return max[nums.length - 1]; +}; +``` + +``` +### How to solve? +``` +##### Using DP. +max[0] = nums[0]; +max[1] = Math.max(nums[0], nums[1]); +max[n] = Math.max(max[n] + max[n - 2], max[n -1]); diff --git a/old(deprecated)/Algorithms/Implement Queue using Stacks/README.md b/old(deprecated)/Algorithms/Implement Queue using Stacks/README.md new file mode 100644 index 0000000..f3a0938 --- /dev/null +++ b/old(deprecated)/Algorithms/Implement Queue using Stacks/README.md @@ -0,0 +1,58 @@ +# [Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/) +###### No:`232` +###### Difficulty:`Easy` + + +```javascript +/** + * @constructor + */ +var Queue = function() { + this.stack1 = []; + this.stack2 =[]; +}; + +/** + * @param {number} x + * @returns {void} + */ +Queue.prototype.push = function(x) { + this.stack1.push(x); +}; + +/** + * @returns {void} + */ +Queue.prototype.pop = function() { + if(this.stack2.length > 0) { + return this.stack2.pop(); + } + if(this.stack1.length > 0) { + while(this.stack1.length > 0) { + this.stack2.push(this.stack1.pop()); + } + return this.stack2.pop(); + } + return null; +}; + +/** + * @returns {number} + */ +Queue.prototype.peek = function() { + if(this.stack2.length > 0) { + return this.stack2[this.stack2.length - 1]; + } + if(this.stack1.length > 0) { + return this.stack1[0]; + } + return null; +}; + +/** + * @returns {boolean} + */ +Queue.prototype.empty = function() { + return this.stack1.length === 0 && this.stack2.length === 0; +}; +``` diff --git a/old(deprecated)/Algorithms/Implement strStr()/README.md b/old(deprecated)/Algorithms/Implement strStr()/README.md new file mode 100644 index 0000000..9d31c36 --- /dev/null +++ b/old(deprecated)/Algorithms/Implement strStr()/README.md @@ -0,0 +1,25 @@ +# [Implement strStr()](https://leetcode.com/problems/implement-strstr) +###### No:`28` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} haystack + * @param {string} needle + * @return {number} + */ + +var strStr = function(haystack, needle) { + if (needle === '') return 0; + for(var i = 0;; i++) { + for(var j = 0;; j++) { + if (j == needle.length) return i; + if (i + j >= haystack.length) return -1; + if (haystack[i + j] != needle[j]) break; + } + } + return -1; +}; + +``` diff --git a/old(deprecated)/Algorithms/Integer Break/README.md b/old(deprecated)/Algorithms/Integer Break/README.md new file mode 100644 index 0000000..2667c91 --- /dev/null +++ b/old(deprecated)/Algorithms/Integer Break/README.md @@ -0,0 +1,32 @@ +# [Integer Break](https://leetcode.com/problems/integer-break/) +###### No:`343` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number} n + * @return {number} + */ +var integerBreak = function(n) { + var maxArr = { + 1: 1, + 2: 1, + }; + var maxValue = null; + var value = null; + + for(var i = 3; i <= n; i++) { + maxValue = Number.MIN_SAFE_INTEGER; + for(var j = 1; j <= i / 2; j++) { + value = Math.max(j, maxArr[j]) * Math.max(i - j, maxArr[i - j]); + if(value > maxValue) { + maxValue = value; + } + } + maxArr[i] = maxValue; + } + + return maxArr[n]; +}; +``` diff --git a/old(deprecated)/Algorithms/Integer to Roman/README.md b/old(deprecated)/Algorithms/Integer to Roman/README.md new file mode 100644 index 0000000..9314d53 --- /dev/null +++ b/old(deprecated)/Algorithms/Integer to Roman/README.md @@ -0,0 +1,24 @@ +# [Integer to Roman](https://leetcode.com/problems/integer-to-roman/) +###### No:`12` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number} num + * @return {string} + */ +var intToRoman = function(num) { + var M = ["", "M", "MM", "MMM"]; + var C = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]; + var X = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]; + var I = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]; + + return [ + M[parseInt(num / 1000)], + C[parseInt((num % 1000) / 100)], + X[parseInt((num % 100) / 10)], + I[num % 10] + ].join(''); +}; +``` diff --git a/old(deprecated)/Algorithms/Intersection of Two Arrays II/README.md b/old(deprecated)/Algorithms/Intersection of Two Arrays II/README.md new file mode 100644 index 0000000..c02ad6b --- /dev/null +++ b/old(deprecated)/Algorithms/Intersection of Two Arrays II/README.md @@ -0,0 +1,27 @@ +# [Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) +###### No:`350` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums1 + * @param {number[]} nums2 + * @return {number[]} + */ +var intersect = function(nums1, nums2) { + var map = {}; + var ret = []; + + nums1.forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + nums2.forEach(i => { + if(map[i] !== undefined && map[i] > 0) { + ret.push(i); + map[i]--; + } + }); + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Intersection of Two Arrays/README.md b/old(deprecated)/Algorithms/Intersection of Two Arrays/README.md new file mode 100644 index 0000000..8d7fb90 --- /dev/null +++ b/old(deprecated)/Algorithms/Intersection of Two Arrays/README.md @@ -0,0 +1,25 @@ +# [Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) +###### No:`349` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums1 + * @param {number[]} nums2 + * @return {number[]} + */ + +var intersection = function (nums1, nums2) { + var ret = []; + for (var i = 0; i < nums1.length; i++) { + for (var j = 0; j < nums2.length; j++) { + if (nums1[i] == nums2[j] && ret.indexOf(nums1[i]) === -1) { + ret.push(nums1[i]); + break; + } + } + } + return ret; +} +``` diff --git a/old(deprecated)/Algorithms/Intersection of Two Linked Lists/README.md b/old(deprecated)/Algorithms/Intersection of Two Linked Lists/README.md new file mode 100644 index 0000000..c2340b3 --- /dev/null +++ b/old(deprecated)/Algorithms/Intersection of Two Linked Lists/README.md @@ -0,0 +1,54 @@ +# [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) +###### No:`160` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ + +/** + * @param {ListNode} headA + * @param {ListNode} headB + * @return {ListNode} + */ +var getIntersectionNode = function(headA, headB) { + if(headA === null || headB === null) { + return null; + } + var pointA = headA; + var pointB = headB; + var i = 0; + var j = 0; + var k = 0; + while(pointA.next !== null) { + pointA = pointA.next; + i++; + } + while(pointB.next !== null) { + pointB = pointB.next; + j++; + } + if(pointB != pointA) { + return null; + } + pointA = headA; + pointB = headB; + + if(i > j) { + while(k < i - j){pointA = pointA.next;k++;} + } else { + while(k < j - i){pointB = pointB.next;k++;} + } + while(pointA != pointB) { + pointA = pointA.next; + pointB = pointB.next; + } + return pointA; +}; +``` diff --git a/old(deprecated)/Algorithms/Invert Binary Tree/README.md b/old(deprecated)/Algorithms/Invert Binary Tree/README.md new file mode 100644 index 0000000..ba13916 --- /dev/null +++ b/old(deprecated)/Algorithms/Invert Binary Tree/README.md @@ -0,0 +1,30 @@ +# [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) +###### No:`226` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {TreeNode} + */ +var invertTree = function(root) { + if(root !== null) { + var tmp; + tmp = root.left; + root.left = root.right; + root.right = tmp; + + invertTree(root.left); + invertTree(root.right); + } + return root; +}; +``` diff --git a/old(deprecated)/Algorithms/Island Perimeter/README.md b/old(deprecated)/Algorithms/Island Perimeter/README.md new file mode 100644 index 0000000..f6317db --- /dev/null +++ b/old(deprecated)/Algorithms/Island Perimeter/README.md @@ -0,0 +1,29 @@ +# [Add Digits](https://leetcode.com/problems/island-perimeter/) +###### No:`463` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[][]} grid + * @return {number} + */ +var islandPerimeter = function(grid) { + var perimeter = 4 * grid.reduce((p, c) => p.concat(c)).reduce((p, c) => p + c); + + for(var i = 0; i < grid.length; i++) { + for(var j = 0; j < grid[i].length; j++) { + if(grid[i][j] === 1) { + if(i + 1 < grid.length && grid[i+1][j] === 1) { + perimeter -= 2 ; + } + if(j + 1 < grid[i].length && grid[i][j+1] === 1) { + perimeter -= 2; + } + } + } + } + + return perimeter; +}; +``` diff --git a/old(deprecated)/Algorithms/Isomorphic Strings/README.md b/old(deprecated)/Algorithms/Isomorphic Strings/README.md new file mode 100644 index 0000000..ebfee03 --- /dev/null +++ b/old(deprecated)/Algorithms/Isomorphic Strings/README.md @@ -0,0 +1,32 @@ +# [Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/#/description) +###### No:`205` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string} s + * @param {string} t + * @return {boolean} + */ +var isIsomorphic = function(s, t) { + if (s.length !== t.length) return false; + + var smap = {}; + var tmap = {}; + + for (var i = 0; i < s.length; i++) { + if (smap[s[i]] === undefined && tmap[t[i]] === undefined) { + smap[s[i]] = t[i]; + tmap[t[i]] = s[i]; + } + + if (smap[s[i]] !== t[i] || tmap[t[i]] !== s[i] ){ + return false; + } + } + + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/K-diff Pairs in an Array/README.md b/old(deprecated)/Algorithms/K-diff Pairs in an Array/README.md new file mode 100644 index 0000000..f8afdbb --- /dev/null +++ b/old(deprecated)/Algorithms/K-diff Pairs in an Array/README.md @@ -0,0 +1,39 @@ +# [K-diff Pairs in an Array](https://leetcode.com/problems/k-diff-pairs-in-an-array/#/description) +###### No:`532` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @param {number} k + * @return {number} + */ +var findPairs = function(nums, k) { + if (k < 0 || nums.length === 0) return 0; + var itemCountMap = {}; + var count = 0; + + nums.forEach((item, index) => { + itemCountMap[item] === undefined ? itemCountMap[item] = 1 : itemCountMap[item]++; + }); + + if (k === 0) { + for (var key in itemCountMap) { + if (itemCountMap[key] >= 2) { + count++; + } + } + } else { + for (var key in itemCountMap) { + if (itemCountMap[parseInt(key)+ k] !== undefined) { + count++; + } + } + } + + return count; +}; + +``` diff --git a/old(deprecated)/Algorithms/Keyboard Row/README.md b/old(deprecated)/Algorithms/Keyboard Row/README.md new file mode 100644 index 0000000..d15b890 --- /dev/null +++ b/old(deprecated)/Algorithms/Keyboard Row/README.md @@ -0,0 +1,17 @@ +# [Keyboard Row](https://leetcode.com/problems/keyboard-row/#/description) +###### No:`500` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string[]} words + * @return {string[]} + */ +var findWords = function(words) { + return words.filter(function(str) { + return /^([qwertyuiop]*|[asdfghjkl]*|[zxcvbnm]*)$/.test(str.toLowerCase()); + }); +}; +``` diff --git a/old(deprecated)/Algorithms/Largest Number/README.md b/old(deprecated)/Algorithms/Largest Number/README.md new file mode 100644 index 0000000..3c732d5 --- /dev/null +++ b/old(deprecated)/Algorithms/Largest Number/README.md @@ -0,0 +1,56 @@ +# [Largest Number](https://leetcode.com/problems/largest-number/) +###### No:`179` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @return {string} + */ +var largestNumber = function(nums) { + var retStr = nums.sort(function(num1, num2) { + var arr1 = num1 + ''.split(); + var arr2 = num2 + ''.split(); + var len1 = arr1.length; + var len2 = arr2.length; + var a, b; + + for (var i = 0; i < len1 || i < len2; i++) { + a = i >= arr1.length ? arr1[i % len1] : arr1[i]; + b = i >= arr2.length ? arr2[i % len2] : arr2[i]; + if (a != b) { + return b - a; + } + } + + // [121,12] 12 > 121; [212,21] 212 > 21 + var isRise; + var checkArr = len1 > len2 ? arr1 : arr2; + for (var j = 0; j < checkArr.length - 1; j++) { + if (checkArr[j] != checkArr[j + 1]) { + if (checkArr[j] > checkArr[j + 1]) { + isRise = false; + break; + } else { + isRise = true; + break; + } + } + } + if (isRise) { + return len1 - len2; + } else { + return len2 - len1; + } + + + }).join(''); + + if (retStr[0] == '0') { + return '0'; + } else { + return retStr; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Length of Last Word/README.md b/old(deprecated)/Algorithms/Length of Last Word/README.md new file mode 100644 index 0000000..3f99375 --- /dev/null +++ b/old(deprecated)/Algorithms/Length of Last Word/README.md @@ -0,0 +1,15 @@ +# [Length of Last Word](https://leetcode.com/problems/length-of-last-word/#/description) +###### No:`58` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {string} s + * @return {number} + */ +var lengthOfLastWord = function(s) { + return s.trim().split(' ').pop().length; +}; +``` diff --git a/old(deprecated)/Algorithms/Letter Combinations of a Phone Number/README.md b/old(deprecated)/Algorithms/Letter Combinations of a Phone Number/README.md new file mode 100644 index 0000000..e2f2d66 --- /dev/null +++ b/old(deprecated)/Algorithms/Letter Combinations of a Phone Number/README.md @@ -0,0 +1,41 @@ +# [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/) +###### No:`17` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {string} digits + * @return {string[]} + */ +var letterCombinations = function(digits) { + var map = { + 2: ['a', 'b', 'c'], + 3: ['d', 'e', 'f'], + 4: ['g', 'h', 'i'], + 5: ['j', 'k', 'l'], + 6: ['m', 'n', 'o'], + 7: ['p', 'q', 'r', 's'], + 8: ['t', 'u', 'v'], + 9: ['w', 'x', 'y', 'z'], + }; + + if(digits.length === 0) { + return []; + } else if(digits.length === 1) { + return map[digits]; + } else { + var front = map[digits.slice(0, 1)]; + var back = letterCombinations(digits.slice(1)); + var ret = []; + + front.forEach(f => { + back.forEach(b => { + ret.push(f + b); + }); + }); + + return ret; + } +}; +``` diff --git a/old(deprecated)/Algorithms/License Key Formatting/README.md b/old(deprecated)/Algorithms/License Key Formatting/README.md new file mode 100644 index 0000000..c36281e --- /dev/null +++ b/old(deprecated)/Algorithms/License Key Formatting/README.md @@ -0,0 +1,27 @@ +# [License Key Formatting](https://leetcode.com/problems/license-key-formatting/#/description) +###### No:`482` +###### Difficulty:`Medium` + + + +```js +/** + * @param {string} S + * @param {number} K + * @return {string} + */ +var format = function(chars, length, separator) { + if (chars.length <= length) { + return chars.join(''); + } + return format(chars.slice(0, chars.length - length), length, separator) + separator + chars.slice(-length).join(''); +}; +var licenseKeyFormatting = function(S, K) { + var chars = S.split('').filter((char) => { + return char !== '-'; + }); + + return format(chars, K, '-').toUpperCase(); + +}; +``` diff --git a/old(deprecated)/Algorithms/Linked List Cycle/README.md b/old(deprecated)/Algorithms/Linked List Cycle/README.md new file mode 100644 index 0000000..b331cad --- /dev/null +++ b/old(deprecated)/Algorithms/Linked List Cycle/README.md @@ -0,0 +1,33 @@ +# [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/#/description) +###### No:`141` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ + +/** + * @param {ListNode} head + * @return {boolean} + */ +var hasCycle = function(head) { + if (head === null) {return false;} + var fast = head; + var slow = head; + + while(slow.next !== null && slow.next.next !== null) { + fast = fast.next; + slow = slow.next.next; + if (slow === fast) return true; + } + + return false; +}; +``` diff --git a/old(deprecated)/Algorithms/Linked List Random Node/README.md b/old(deprecated)/Algorithms/Linked List Random Node/README.md new file mode 100644 index 0000000..2258879 --- /dev/null +++ b/old(deprecated)/Algorithms/Linked List Random Node/README.md @@ -0,0 +1,48 @@ +# [Linked List Random Node](https://leetcode.com/problems/linked-list-random-node/#/description) +###### No:`382` +###### Difficulty:`Medium` + + +```js +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param head The linked list's head. + Note that the head is guaranteed to be not null, so it contains at least one node. + * @param {ListNode} head + */ +var Solution = function(head) { + this.head = head; +}; + +/** + * Returns a random node's value. + * @return {number} + */ +Solution.prototype.getRandom = function() { + var ret = this.head.val; + var p = this.head.next; + var i = 2; + while (p !== null) { + var random = Math.ceil(Math.random() * i); + if (random === 1) { + ret = p.val; + } + i++; + p = p.next; + } + + return ret; +}; + +/** + * Your Solution object will be instantiated and called as such: + * var obj = Object.create(Solution).createNew(head) + * var param_1 = obj.getRandom() + */ +``` diff --git a/old(deprecated)/Algorithms/Longest Common Prefix/README.md b/old(deprecated)/Algorithms/Longest Common Prefix/README.md new file mode 100644 index 0000000..5816c4b --- /dev/null +++ b/old(deprecated)/Algorithms/Longest Common Prefix/README.md @@ -0,0 +1,38 @@ +# [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/#/description) +###### No:`14` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {string[]} strs + * @return {string} + */ +var longestCommonPrefix = function(strs) { + if (strs.length === 0) return ''; + if (strs.length === 0) return strs[1]; + + var ret = ''; + var isBreak = false; + var isCommon = true; + var char; + + for (var j = 0; j < strs[0].length; j++) { + char = strs[0][j]; + + for (var i = 1; i < strs.length; i++) { + if (strs[i].length <= j || strs[i][j] !== char) { + isBreak = true; + break; + } + } + if (isBreak) { + break; + } + ret += strs[0][j]; + } + return ret; +}; + +``` diff --git a/old(deprecated)/Algorithms/Longest Palindrome/README.md b/old(deprecated)/Algorithms/Longest Palindrome/README.md new file mode 100644 index 0000000..944cc57 --- /dev/null +++ b/old(deprecated)/Algorithms/Longest Palindrome/README.md @@ -0,0 +1,33 @@ +# [Longest Palindrome](https://leetcode.com/problems/longest-palindrome/) +###### No:`409` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {number} + */ +var longestPalindrome = function(s) { + var map = {}; + var number = 0; + var hasOdd = false; + + s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + + for(var i in map) { + if(map[i] % 2 === 0) { + number += map[i]; + } else if(map[i] > 2) { + number += map[i] - 1; + hasOdd = true; + } else { + hasOdd = true; + } + } + + if(hasOdd) number++; + + return number; +}; +``` diff --git a/old(deprecated)/Algorithms/Lowest Common Ancestor of a Binary Search Tree/README.md b/old(deprecated)/Algorithms/Lowest Common Ancestor of a Binary Search Tree/README.md new file mode 100644 index 0000000..85140b2 --- /dev/null +++ b/old(deprecated)/Algorithms/Lowest Common Ancestor of a Binary Search Tree/README.md @@ -0,0 +1,36 @@ +# [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree) +###### No:`235` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {TreeNode} p + * @param {TreeNode} q + * @return {TreeNode} + */ +var lowestCommonAncestor = function(root, p, q) { + var tmp; + if(p > q) { + tmp = p; + p = q; + q = tmp; + } + if(root.val >= p.val && root.val <= q.val) { + return root; + }else if(p.val < root.val & q.val < root.val) { + return lowestCommonAncestor(root.left, p, q); + } else if(p.val > root.val && q.val > root.val){ + return lowestCommonAncestor(root.right, p, q); + } + +}; +``` diff --git a/old(deprecated)/Algorithms/Majority Element/README.md b/old(deprecated)/Algorithms/Majority Element/README.md new file mode 100644 index 0000000..435c558 --- /dev/null +++ b/old(deprecated)/Algorithms/Majority Element/README.md @@ -0,0 +1,28 @@ +# [Majority Element](https://leetcode.com/problems/majority-element/) +###### No:`169` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var majorityElement = function(nums) { + var count = 1; + var item = nums[0]; + for(var i = 1; i < nums.length; i++) { + if(count === 0) { + count = 1; + item = nums[i]; + } else { + if(nums[i] == item) { + count++; + } else { + count--; + } + } + } + return item; +}; +``` diff --git a/old(deprecated)/Algorithms/Max Consecutive Ones/README.md b/old(deprecated)/Algorithms/Max Consecutive Ones/README.md new file mode 100644 index 0000000..3223d8e --- /dev/null +++ b/old(deprecated)/Algorithms/Max Consecutive Ones/README.md @@ -0,0 +1,25 @@ +# [Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/#/description) +###### No:`485` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @return {number} + */ +var findMaxConsecutiveOnes = function(nums) { + var max = 0; + var length = 0; + nums.forEach(function(num) { + if (num === 1) length++; + if (num === 0) { + if (length > max) max = length; + length = 0; + } + }); + if (length > max) max = length; + return max; +}; +``` diff --git a/old(deprecated)/Algorithms/Max Points on a Line/README.md b/old(deprecated)/Algorithms/Max Points on a Line/README.md new file mode 100644 index 0000000..1ec3aa4 --- /dev/null +++ b/old(deprecated)/Algorithms/Max Points on a Line/README.md @@ -0,0 +1,54 @@ +# [Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/) +###### No:`149` +###### Difficulty:`Hard` +## CPP + +```cpp +/** + * Definition for a point. + * struct Point { + * int x; + * int y; + * Point() : x(0), y(0) {} + * Point(int a, int b) : x(a), y(b) {} + * }; + */ +class Solution { +public: + int maxPoints(vector &points) { + if(points.size() < 3) { + return points.size(); + } + int maxPoints = 0; //the max point in line + int size = points.size(); + map count; + map::iterator iter; + for(int i = 0; i < size; i++ ) { + int x1 = points[i].x; + int y1 = points[i].y; + int coincideCount = 0; //number of duplicate points + count.clear(); + count[(double)INT_MIN] = 0; + for(int j = i + 1; j < size; j++) { + int x2 = points[j].x; + int y2 = points[j].y; + if(x1 == x2 && y1 == y2) { + coincideCount++; + } else if(x1 == x2){ + count[(double)INT_MIN]++; + } else { + double slope = 1.0*(y1-y2)/(x1-x2); + count[slope]++; + } + } + for(iter = count.begin(); iter != count.end(); iter++) { + if(iter->second + coincideCount > maxPoints) { + maxPoints = iter->second + coincideCount; + } + } + } + maxPoints = maxPoints + 1; + return maxPoints; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Maximum Depth of Binary Tree/README.md b/old(deprecated)/Algorithms/Maximum Depth of Binary Tree/README.md new file mode 100644 index 0000000..0d240df --- /dev/null +++ b/old(deprecated)/Algorithms/Maximum Depth of Binary Tree/README.md @@ -0,0 +1,25 @@ +# [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) +###### No:`104` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var maxDepth = function(root) { + if(root == null) { + return 0; + } else { + return Math.max(maxDepth(root.left), maxDepth(root.right)) +1; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Maximum Subarray/README.md b/old(deprecated)/Algorithms/Maximum Subarray/README.md new file mode 100644 index 0000000..dd4c476 --- /dev/null +++ b/old(deprecated)/Algorithms/Maximum Subarray/README.md @@ -0,0 +1,25 @@ +# [Maximum Subarray](https://leetcode.com/problems/maximum-subarray/#/description) +###### No:`53` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {number[]} nums + * @return {number} + */ + // https://discuss.leetcode.com/topic/6413/dp-solution-some-thoughts +var maxSubArray = function(nums) { + var max = nums[0]; + var dp = {}; + dp[0] = nums[0]; + + for (var i = 1; i < nums.length; i++) { + dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i] : nums[i]; + max = Math.max(max, dp[i]); + } + + return max; +}; +``` diff --git a/old(deprecated)/Algorithms/Merge Sorted Array/README.md b/old(deprecated)/Algorithms/Merge Sorted Array/README.md new file mode 100644 index 0000000..7934313 --- /dev/null +++ b/old(deprecated)/Algorithms/Merge Sorted Array/README.md @@ -0,0 +1,25 @@ +# [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/) +###### No:`88` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums1 + * @param {number} m + * @param {number[]} nums2 + * @param {number} n + * @return {void} Do not return anything, modify nums1 in-place instead. + */ +var merge = function(nums1, m, nums2, n) { + while(n > 0) { + if(m <= 0 || nums1[m - 1] <= nums2[n -1]) { + nums1[m + n - 1] = nums2[n - 1]; + n--; + } else { + nums1[m + n - 1] = nums1[m - 1]; + m--; + } + } +}; +``` diff --git a/old(deprecated)/Algorithms/Merge Two Sorted Lists/README.md b/old(deprecated)/Algorithms/Merge Two Sorted Lists/README.md new file mode 100644 index 0000000..153d896 --- /dev/null +++ b/old(deprecated)/Algorithms/Merge Two Sorted Lists/README.md @@ -0,0 +1,51 @@ +# [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/) +###### No:`21` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} l1 + * @param {ListNode} l2 + * @return {ListNode} + */ +var mergeTwoLists = function(l1, l2) { + if(!l1) return l2; + if(!l2) return l1; + var head = null + if(l1.val < l2.val) { + head = l1; + l1 = l1.next; + } else { + head = l2; + l2 = l2.next; + } + + var newlist = head; + + while(l1 && l2) { + if(l1.val < l2.val) { + newlist.next = l1; + l1 = l1.next; + } else { + newlist.next = l2; + l2 = l2.next; + } + newlist = newlist.next; + } + if(!l1) { + newlist.next = l2; + } else { + newlist.next = l1; + } + + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Min Stack/README.md b/old(deprecated)/Algorithms/Min Stack/README.md new file mode 100644 index 0000000..4a28b34 --- /dev/null +++ b/old(deprecated)/Algorithms/Min Stack/README.md @@ -0,0 +1,53 @@ +# [Min Stack](https://leetcode.com/problems/min-stack/) +###### No:`155` +###### Difficulty:`Easy` + + +```javascript +/** + * @constructor + */ +var MinStack = function() { + this.stack = []; + this.min = Number.MAX_SAFE_INTEGER; +}; + +/** + * @param {number} x + * @returns {void} + */ +MinStack.prototype.push = function(x) { + if(x < this.min) { + this.min = x; + } + this.stack.push(x); +}; + +/** + * @returns {void} + */ +MinStack.prototype.pop = function() { + var number = this.stack.pop(); + if(number == this.min) { + this.min = Math.min.apply(null, this.stack); + } +}; + +/** + * @returns {number} + */ +MinStack.prototype.top = function() { + if(this.stack.length > 0) { + return this.stack[this.stack.length - 1]; + } else { + return undefined; + } +}; + +/** + * @returns {number} + */ +MinStack.prototype.getMin = function() { + return this.min; +}; +``` diff --git a/old(deprecated)/Algorithms/Minesweeper/README.md b/old(deprecated)/Algorithms/Minesweeper/README.md new file mode 100644 index 0000000..399c4a6 --- /dev/null +++ b/old(deprecated)/Algorithms/Minesweeper/README.md @@ -0,0 +1,76 @@ +# [Minesweeper](https://leetcode.com/problems/minesweeper/#/description) +###### No:`529` +###### Difficulty:`Medium` + + + +```js +/** + * @param {character[][]} board + * @param {number[]} click + * @return {character[][]} + */ +var getMineCount = function(board, point) { + var m = board.length; + var n = board[0].length; + var x = point[0]; + var y = point[1]; + var count = 0; + for (var i = -1; i < 2; i++) { + for (var j = -1; j < 2; j++) { + var p = x + i; + var q = y + j; + if (p < 0 || p >= m || q < 0 || q >= n) continue; + if (board[p][q] === 'M' || board[p][q] === 'X') count++; + } + } + return count; +}; + +var updateBoard = function(board, click) { + var m = board.length; + var n = board[0].length; + var visited = []; + for (var k = 0; k < m; k++) visited.push(new Array(n).fill(false)); + + var queue = []; + queue.push(click); + + while(queue.length > 0) { + var point = queue.shift(); + var x = point[0]; + var y = point[1]; + + if (visited[x][y]) { + continue; + } else { + visited[x][y] = true; + } + + if (board[x][y] === 'M') { + board[x][y] = 'X'; + } else { + var count = getMineCount(board, point); + + if (count === 0) { + board[x][y] = 'B'; + for (var i = -1; i < 2; i++) { + for (var j = -1; j < 2; j++) { + var p = x + i; + var q = y + j; + if (p < 0 || p >= m || q < 0 || q >= n || (p === x && q === y)) continue; + if (board[p][q] === 'E'){ + queue.push([p, q]); + } + } + } + } else { + board[x][y] = count + ''; + } + } + } + + return board; +}; + +``` diff --git a/old(deprecated)/Algorithms/Minimum Absolute Difference in BST/README.md b/old(deprecated)/Algorithms/Minimum Absolute Difference in BST/README.md new file mode 100644 index 0000000..c0260f0 --- /dev/null +++ b/old(deprecated)/Algorithms/Minimum Absolute Difference in BST/README.md @@ -0,0 +1,36 @@ +# [Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/#/description) +###### No:`530` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ + +var getMinimumDifference = function(root) { + var prev = null; + var min = Number.MAX_VALUE; + var traversal = function(root) { + if (root === null) return; + traversal(root.left); + if (prev !== null && root.val - prev < min) { + min = root.val - prev; + } + prev = root.val; + traversal(root.right); + }; + traversal(root); + + return min; +}; +``` diff --git a/old(deprecated)/Algorithms/Minimum Depth of Binary Tree/README.md b/old(deprecated)/Algorithms/Minimum Depth of Binary Tree/README.md new file mode 100644 index 0000000..0a3e565 --- /dev/null +++ b/old(deprecated)/Algorithms/Minimum Depth of Binary Tree/README.md @@ -0,0 +1,37 @@ +# [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/) +###### No:`111` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var minDepth = function(root) { + if(root === null) { + return 0; + } + var leftDepth = minDepth(root.left); + var rightDepth = minDepth(root.right); + + /* + * As a shot, the follow can be write: + * return (leftDepth == 0 || rightDepth == 0) ? leftDepth + rightDepth + 1: Math.min(leftDepth,rightDepth) + 1; + */ + if(leftDepth !== 0 && rightDepth !== 0) { + return Math.min(leftDepth, rightDepth) + 1; + } else if(leftDepth === 0) { + return rightDepth + 1; + } else { + return leftDepth + 1; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Minimum Moves to Equal Array Elements/README.md b/old(deprecated)/Algorithms/Minimum Moves to Equal Array Elements/README.md new file mode 100644 index 0000000..c9e1c47 --- /dev/null +++ b/old(deprecated)/Algorithms/Minimum Moves to Equal Array Elements/README.md @@ -0,0 +1,17 @@ +# [Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/#/description) +###### No:`453` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @return {number} + */ +var minMoves = function(nums) { + var min = Math.min.apply(null, nums) + + return nums.reduce((p, c) => p + c - min, 0); +}; +``` diff --git a/old(deprecated)/Algorithms/Missing Number/README.md b/old(deprecated)/Algorithms/Missing Number/README.md new file mode 100644 index 0000000..a314aa1 --- /dev/null +++ b/old(deprecated)/Algorithms/Missing Number/README.md @@ -0,0 +1,28 @@ +# [Missing Number](https://leetcode.com/problems/missing-number/) +###### No:`268` +###### Difficulty:`Medium` + +#### Solution 1 +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var missingNumber = function(nums) { + return (0 + nums.length) * (nums.length + 1) / 2 - nums.reduce((p, c) => p + c, 0); +}; +``` + +#### Solution 2 +Any number XOR itself will be 0. +e.g.[0,1,3] +ret = （0 ^ 1 ^ 3） ^ (0 ^ 1 ^ 2 ^ 3) // will get 2 +```js +/** + * @param {number[]} nums + * @return {number} + */ +var missingNumber = function(nums) { + return nums.reduce((p, c, i) => p ^ c ^ i, 0) ^ nums.length; +}; +``` diff --git a/old(deprecated)/Algorithms/Most Frequent Subtree Sum/README.md b/old(deprecated)/Algorithms/Most Frequent Subtree Sum/README.md new file mode 100644 index 0000000..cff7a2f --- /dev/null +++ b/old(deprecated)/Algorithms/Most Frequent Subtree Sum/README.md @@ -0,0 +1,50 @@ +# [Most Frequent Subtree Sum](https://leetcode.com/problems/most-frequent-subtree-sum/#/description) +###### No:`508` +###### Difficulty:`Medium` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number[]} + */ +function getSum (root, map) { + if (root === null) return 0; + var left = getSum(root.left, map); + var right = getSum(root.right, map); + var sum = root.val + left + right; + + map[sum] === undefined ? map[sum] = 1 : map[sum]++; + return sum; +} +var findFrequentTreeSum = function(root) { + if (root === null) return []; + var valueCountMap = {}; + var max = -1; + var ret = []; + var key; + + getSum(root, valueCountMap); + for (key in valueCountMap) { + if (valueCountMap[key] > max) { + max = valueCountMap[key]; + } + } + + for (key in valueCountMap) { + if (valueCountMap[key] === max) { + ret.push(parseInt(key)); + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Move Zeroes/README.md b/old(deprecated)/Algorithms/Move Zeroes/README.md new file mode 100644 index 0000000..6471621 --- /dev/null +++ b/old(deprecated)/Algorithms/Move Zeroes/README.md @@ -0,0 +1,21 @@ +# [Move Zeroes](https://leetcode.com/problems/move-zeroes/) +###### No:`283` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {void} Do not return anything, modify nums in-place instead. + */ +var moveZeroes = function(nums) { + var sum = 0; + for(var i = nums.length - 1; i >=0; i--) { + if(nums[i] === 0) { + nums.splice(i,1); + sum++; + } + } + [].push.apply(nums, new Array(sum).fill(0)) +}; +``` diff --git a/old(deprecated)/Algorithms/Next Greater Element I/README.md b/old(deprecated)/Algorithms/Next Greater Element I/README.md new file mode 100644 index 0000000..adc1c10 --- /dev/null +++ b/old(deprecated)/Algorithms/Next Greater Element I/README.md @@ -0,0 +1,27 @@ +# [Next Greater Element I](https://leetcode.com/problems/next-greater-element-i/#/description) +###### No:`496` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} findNums + * @param {number[]} nums + * @return {number[]} + */ +var nextGreaterElement = function(findNums, nums) { + var map = {}; + var stack = []; + nums.forEach(function(num) { + while(stack.length > 0 && stack[stack.length - 1] < num) { + map[stack.pop()] = num; + } + stack.push(num); + }); + + return findNums.map(function(num) { + return map[num] || -1; + }); +}; +``` diff --git a/old(deprecated)/Algorithms/Next Greater Element II/README.md b/old(deprecated)/Algorithms/Next Greater Element II/README.md new file mode 100644 index 0000000..a2dbce0 --- /dev/null +++ b/old(deprecated)/Algorithms/Next Greater Element II/README.md @@ -0,0 +1,35 @@ +# [Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/#/description) +###### No:`503` +###### Difficulty:`Medium` + + + +```js +/** + * @param {number[]} nums + * @return {number[]} + */ +var nextGreaterElements = function(nums) { + var nextGreaterMap = {}; + var stack = []; + nums.concat(nums).forEach((item) => { + while (stack.length > 0 && stack[stack.length - 1] < item) { + var key = stack.pop(); + if (nextGreaterMap[key] === undefined) { + nextGreaterMap[key] = []; + } + nextGreaterMap[key].push(item); + } + stack.push(item); + }); + + return nums.map((item) => { + if (nextGreaterMap[item] && nextGreaterMap[item].length > 0) { + return nextGreaterMap[item].shift(); + } else { + return -1; + } + }); +}; + +``` diff --git a/old(deprecated)/Algorithms/Next Permutation/README.md b/old(deprecated)/Algorithms/Next Permutation/README.md new file mode 100644 index 0000000..ba0b25d --- /dev/null +++ b/old(deprecated)/Algorithms/Next Permutation/README.md @@ -0,0 +1,41 @@ +# [Next Permutation](https://leetcode.com/problems/next-permutation/#/description) +###### No:`31` +###### Difficulty:`Medium` +## JavaScript + + +```js +var nextPermutation = function(nums) { + if (nums.length <= 1) { + return; + } + + var i = nums.length - 2; + var j = nums.length - 1; + while (nums[i] >= nums[i + 1] && i > -1) { + i--; + } + if (i >= 0) { + while (nums[j] <= nums[i]) { + j--; + } + + var temp; + temp = nums[i]; + nums[i] = nums[j]; + nums[j] = temp; + } + + var start = i + 1; + var end = nums.length - 1; + + while (start < end) { + temp = nums[start]; + nums[start] = nums[end]; + nums[end] = temp; + start++; + end--; + } + +}; +``` diff --git a/old(deprecated)/Algorithms/Nim Game/README.md b/old(deprecated)/Algorithms/Nim Game/README.md new file mode 100644 index 0000000..5428ebb --- /dev/null +++ b/old(deprecated)/Algorithms/Nim Game/README.md @@ -0,0 +1,14 @@ +# [Nim Game](https://leetcode.com/problems/nim-game/) +###### No:`292` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var canWinNim = function(n) { + return !(n !== 0 && n%4 === 0); +}; +``` diff --git a/old(deprecated)/Algorithms/Nth Digit/README.md b/old(deprecated)/Algorithms/Nth Digit/README.md new file mode 100644 index 0000000..9a62d82 --- /dev/null +++ b/old(deprecated)/Algorithms/Nth Digit/README.md @@ -0,0 +1,34 @@ +# [Nth Digit](https://leetcode.com/problems/nth-digit/#/description) +###### No:`400` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} n + * @return {number} + */ +var findNthDigit = function(n) { + var length = 1; + var count = 9; + var digits = 9; + + while (n > digits) { + length++; + count *= 10; + digits += length * count; + } + n = n - (digits - length * count); + + var position = Math.ceil(n / length); + var number = Math.pow(10, (length - 1)) + position - 1; + + if (n % length === 0) { + return number % 10; + } else { + return parseInt(String(number)[n % length - 1]); + } +}; + +``` diff --git a/old(deprecated)/Algorithms/Number Complement/README.md b/old(deprecated)/Algorithms/Number Complement/README.md new file mode 100644 index 0000000..10fa230 --- /dev/null +++ b/old(deprecated)/Algorithms/Number Complement/README.md @@ -0,0 +1,71 @@ +# [Number Complement](https://leetcode.com/problems/number-complement/#/description) +###### No:`476` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} num + * @return {number} + +这道题给了我们一个数，让我们求补数。通过分析题目汇总的例子，我们知道需要做的就是每个位翻转一下就行了，但是翻转的起始位置上从最高位的1开始的，前面的0是不能被翻转的，所以我们从高往低遍历，如果遇到第一个1了后，我们的flag就赋值为true，然后就可以进行翻转了，翻转的方法就是对应位异或一个1即可，参见代码如下： + + + +解法一： + +复制代码 +class Solution { +public: + int findComplement(int num) { + bool start = false; + for (int i = 31; i >= 0; --i) { + if (num & (1 << i)) start = true; + if (start) num ^= (1 << i); + } + return num; + } +}; +复制代码 + + +由于位操作里面的取反符号～本身就可以翻转位，但是如果直接对num取反的话就是每一位都翻转了，而最高位1之前的0是不能翻转的，所以我们只要用一个mask来标记最高位1前面的所有0的位置，然后对mask取反后，与上对num取反的结果即可，参见代码如下： + + + +解法二： + +复制代码 +class Solution { +public: + int findComplement(int num) { + int mask = INT_MAX; + while (mask & num) mask <<= 1; + return ~mask & ~num; + } +}; +复制代码 + + +再来看一种迭代的写法，一行搞定碉堡了，思路就是每次都右移一位，并根据最低位的值先进行翻转，如果当前值小于等于1了，就不用再调用递归函数了，参见代码如下： + + + +解法三： + +class Solution { +public: + int findComplement(int num) { + return (1 - num % 2) + 2 * (num <= 1 ? 0 : findComplement(num / 2)); + } +}; + + */ + +var findComplement = function(num) { + var mask = ~0; + while (mask & num) mask <<= 1; + return ~mask & ~num; +}; +``` diff --git a/old(deprecated)/Algorithms/Number of 1 Bits/README.md b/old(deprecated)/Algorithms/Number of 1 Bits/README.md new file mode 100644 index 0000000..dc6cfc9 --- /dev/null +++ b/old(deprecated)/Algorithms/Number of 1 Bits/README.md @@ -0,0 +1,43 @@ +# [Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/) +###### No:`191` +###### Difficulty:`Easy` +#### Solution 1 +```js +/** + * @param {number} n - a positive integer + * @return {number} + */ +var hammingWeight = function(n) { + var count = 0; + while (n) { + n = n & (n - 1); + count++; + } + + return count; +}; +``` +#### Solution 2 +```javascript +/** + * @param {number} n - a positive integer + * @return {number} + */ +var hammingWeight = function(n) { + var ret = 0; + const base = 2; + const bitnum = 32; + var power = bitnum -1; + + for(var i = 0; i < bitnum; i++) { + if(n >= Math.pow(base, power)) { + ret++; + n -= Math.pow(base, power); + } + power--; + } + + return ret; +}; + +``` diff --git a/old(deprecated)/Algorithms/Number of Boomerangs/README.md b/old(deprecated)/Algorithms/Number of Boomerangs/README.md new file mode 100644 index 0000000..9c21791 --- /dev/null +++ b/old(deprecated)/Algorithms/Number of Boomerangs/README.md @@ -0,0 +1,43 @@ +# [Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs/) +###### No:`447` +###### Difficulty:`Easy` + + +### Solution: +Get each 2 points' distance. For one point, save the distance as the key and count as the value into a map. The Boomerangs which contains this point will be count * (count - 1). + +```javascript +/** + * @param {number[][]} points + * @return {number} + */ + +var getDistance = function(a, b) { + var dx = a[0] - b[0]; + var dy = a[1] - b[1]; + + return dx * dx + dy * dy; +} + +var numberOfBoomerangs = function(points) { + var map; + var distance; + var ret = 0; + + for(var i = 0; i < points.length; i++) { + map = {}; + for(var j = 0; j < points.length; j++) { + if(i !== j) { + distance = getDistance(points[i], points[j]); + map[distance] === undefined ? map[distance] = 1 : map[distance] += 1; + } + } + + for(var d in map) { + ret += map[d] * (map[d] - 1); + } + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Number of Segments in a String/README.md b/old(deprecated)/Algorithms/Number of Segments in a String/README.md new file mode 100644 index 0000000..036be85 --- /dev/null +++ b/old(deprecated)/Algorithms/Number of Segments in a String/README.md @@ -0,0 +1,26 @@ +# [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/#/description) +###### No:`434` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string} s + * @return {number} + */ +/* +var countSegments = function(s) { + return s.split(' ').filter((item) => item !== '').length; +}; +*/ + +var countSegments = function(s) { + var count = 0; + for (var i = 0; i < s.length; i++) { + if (s[i] !== ' ' && (i === 0 || s[i - 1] === ' ')) count++; + } + + return count; +}; +``` diff --git a/old(deprecated)/Algorithms/Odd Even Linked List/README.md b/old(deprecated)/Algorithms/Odd Even Linked List/README.md new file mode 100644 index 0000000..3cc9445 --- /dev/null +++ b/old(deprecated)/Algorithms/Odd Even Linked List/README.md @@ -0,0 +1,37 @@ +# [Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) +###### No:`328` +###### Difficulty:`Medium` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var oddEvenList = function(head) { + if(head === null) { + return null; + } + var second = head.next; + + var odd = head; + var even = head.next; + while(odd && odd.next && odd.next.next) { + odd.next = even.next; + odd = odd.next; + if(odd) { + even.next = odd.next; + even = even.next; + } + } + odd.next = second; + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Output Contest Matches/README.md b/old(deprecated)/Algorithms/Output Contest Matches/README.md new file mode 100644 index 0000000..0168e02 --- /dev/null +++ b/old(deprecated)/Algorithms/Output Contest Matches/README.md @@ -0,0 +1,50 @@ +# [Output Contest Matches](https://leetcode.com/problems/output-contest-matches/) +###### No:`544` +###### Difficulty:`Medium` + + +### LeetCode Weekly Contest 24 +### 544. Output Contest Matches +During the NBA playoffs, we always arrange the rather strong team to play with the rather weak team, like make the rank 1 team play with the rank nth team, which is a good strategy to make the contest more interesting. Now, you're given n teams, you need to output their final contest matches in the form of a string. + +The n teams are given in the form of positive integers from 1 to n, which represents their initial rank. (Rank 1 is the strongest team and Rank n is the weakest team.) We'll use parentheses('(', ')') and commas(',') to represent the contest team pairing - parentheses('(' , ')') for pairing and commas(',') for partition. During the pairing process in each round, you always need to follow the strategy of making the rather strong one pair with the rather weak one. + +#### Example +``` +Input: 2 +Output: (1,2) +Input: 4 +Output: ((1,4),(2,3)) +Input: 8 +Output: (((1,8),(4,5)),((2,7),(3,6))) +``` + +#### Solution +```js +/** + * @param {number} n + * @return {string} + */ +function getMatch (match) { + if (match.length === 1) return match; + var ret = []; + var start = 0; + var end = match.length - 1; + var value; + + while (start < end) { + value = `(${match[start]},${match[end]})`; + ret.push(value); + start++; + end--; + } + + return getMatch(ret); +} +var findContestMatch = function(n) { + var match = []; + for (var i = 1; i <= n; i++) match.push(i); + + return getMatch(match)[0]; +}; +``` diff --git a/old(deprecated)/Algorithms/Palindrome Linked List/README.md b/old(deprecated)/Algorithms/Palindrome Linked List/README.md new file mode 100644 index 0000000..47adfe3 --- /dev/null +++ b/old(deprecated)/Algorithms/Palindrome Linked List/README.md @@ -0,0 +1,56 @@ +# [Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/) +###### No:`234` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {boolean} + */ +var isPalindrome = function(head) { + function reverseList(head) { + if(!head) { + return head; + } + var prev = null; + var next = null; + while(head) { + next = head.next; + head.next = prev; + prev = head; + head = next; + } + return prev; + } + if(!head || !head.next ) { + return true; + } + var slow = head; + var fast = head; + while(fast && fast.next && fast.next.next) { + slow = slow.next; + fast = fast.next.next; + } + + slow.next = reverseList(slow.next); + slow = slow.next; + + while(slow) { + if(head.val !== slow.val) { + return false; + } + head = head.next; + slow = slow.next; + } + + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Palindrome Number/README.md b/old(deprecated)/Algorithms/Palindrome Number/README.md new file mode 100644 index 0000000..ea0aae2 --- /dev/null +++ b/old(deprecated)/Algorithms/Palindrome Number/README.md @@ -0,0 +1,24 @@ +# [Palindrome Number](https://leetcode.com/problems/palindrome-number/) +###### No:`9` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} x + * @return {boolean} + */ +var isPalindrome = function(x) { + x += ''; + var i = 0; + var j = x.length - 1; + while(i < j) { + if(x[i] != x[j]) { + return false + } + i++; + j--; + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Pascal's Triangle II/README.md b/old(deprecated)/Algorithms/Pascal's Triangle II/README.md new file mode 100644 index 0000000..f89764b --- /dev/null +++ b/old(deprecated)/Algorithms/Pascal's Triangle II/README.md @@ -0,0 +1,22 @@ +# [Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/) +###### No:`119` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} rowIndex + * @return {number[]} + */ +var getRow = function(rowIndex) { + var ret = []; + ret[0] = 1; + for(var i = 1; i <= rowIndex; i++ ) { + ret[i] = 1; + for(j = i - 1; j > 0; j--) { + ret[j] = ret[j] + ret[j - 1]; + } + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Pascal's Triangle/README.md b/old(deprecated)/Algorithms/Pascal's Triangle/README.md new file mode 100644 index 0000000..964c1e9 --- /dev/null +++ b/old(deprecated)/Algorithms/Pascal's Triangle/README.md @@ -0,0 +1,30 @@ +# [Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/) +###### No:`118` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} numRows + * @return {number[][]} + */ +var generate = function(numRows) { + if(numRows === 0) { + return []; + } + if(numRows === 1) { + return [[1]]; + } + + var ret = [[1]]; + for(var i = 1; i < numRows; i++) { + ret.push([]); + for(var j = 0; j < ret[i - 1].length - 1; j++) { + ret[i].push(ret[i-1][j] + ret[i-1][j + 1]); + } + ret[i].unshift(1); + ret[i].push(1); + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Path Sum III/README.md b/old(deprecated)/Algorithms/Path Sum III/README.md new file mode 100644 index 0000000..55eaac5 --- /dev/null +++ b/old(deprecated)/Algorithms/Path Sum III/README.md @@ -0,0 +1,42 @@ +# [Path Sum III](https://leetcode.com/problems/path-sum-iii/#/description) +###### No:`437` +###### Difficulty:`Easy` + + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} sum + * @return {number} + */ +var traversal = function(root, list, sum, cb) { + if (root === null) return; + cb(list, root.val); + var newList = list.map((item) => item - root.val).concat(sum); + + traversal(root.left, newList, sum, cb); + traversal(root.right, newList, sum, cb); +}; +var pathSum = function(root, sum) { + var count = 0; + var cb = function (list, val) { + list.forEach((item) => { + if (item === val) { + count++; + } + }); + } + + traversal(root, [sum], sum, cb); + return count; +}; + +``` diff --git a/old(deprecated)/Algorithms/Path Sum/README.md b/old(deprecated)/Algorithms/Path Sum/README.md new file mode 100644 index 0000000..7bec17f --- /dev/null +++ b/old(deprecated)/Algorithms/Path Sum/README.md @@ -0,0 +1,32 @@ +# [Path Sum](https://leetcode.com/problems/path-sum/) +###### No:`112` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @param {number} sum + * @return {boolean} + */ +var hasPathSum = function(root, sum) { + if(root == null) { + return false; + } + if(root.left == null && root.right == null && sum == root.val) { + return true; + } + if(hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val)) { + return true; + } else { + return false; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Permutations/README.md b/old(deprecated)/Algorithms/Permutations/README.md new file mode 100644 index 0000000..8796ab8 --- /dev/null +++ b/old(deprecated)/Algorithms/Permutations/README.md @@ -0,0 +1,32 @@ +# [Permutations](https://leetcode.com/problems/permutations/) +###### No:`46` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @return {number[][]} + */ +var permute = function(nums) { + var ret = []; + if(nums.length == 1) { + ret.push(nums); + return ret; + } + + var item, item_copy; + var head = nums.shift(); + var pre_ret = permute(nums); + + for(var i = 0; i < pre_ret.length; i++ ) { + item = pre_ret[i]; + for(var j = 0; j <= item.length; j++) { + item_copy = [].slice.call(item); + item_copy.splice(j, 0, head); + ret.push(item_copy); + } + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Plus One/README.md b/old(deprecated)/Algorithms/Plus One/README.md new file mode 100644 index 0000000..a3343fb --- /dev/null +++ b/old(deprecated)/Algorithms/Plus One/README.md @@ -0,0 +1,29 @@ +# [Plus One](https://leetcode.com/problems/plus-one/) +###### No:`66` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} digits + * @return {number[]} + */ +var plusOne = function(digits) { + digits.unshift(0); + var tail = digits.length - 1; + digits[tail]++; + while(tail > 0) { + if(digits[tail] == 10) { + digits[tail] = 0; + tail--; + digits[tail]++; + } else { + tail--; + } + } + if(digits[0] == 0) { + digits.shift(); + } + return digits; +}; +``` diff --git a/old(deprecated)/Algorithms/Power of Four/README.md b/old(deprecated)/Algorithms/Power of Four/README.md new file mode 100644 index 0000000..dc9c210 --- /dev/null +++ b/old(deprecated)/Algorithms/Power of Four/README.md @@ -0,0 +1,24 @@ +# [Power of Four](https://leetcode.com/problems/power-of-four/#/description) +###### No:`342` +###### Difficulty:`Easy` + + + +```js +var isPowerOfFour = function(num) { + if (num < 1) { + return false; + } else if (num === 1) { + return true; + } else if (num % 4 !== 0) { + return false; + } else { + return isPowerOfFour(num / 4); + } +}; +``` +```js +var isPowerOfFour = function(num) { + return num > 0 && (num & (num - 1)) === 0 && (num & 0x55555555) !== 0; +}; +``` diff --git a/old(deprecated)/Algorithms/Power of Three/README.md b/old(deprecated)/Algorithms/Power of Three/README.md new file mode 100644 index 0000000..dc607a5 --- /dev/null +++ b/old(deprecated)/Algorithms/Power of Three/README.md @@ -0,0 +1,27 @@ +# [Power of Three](https://leetcode.com/problems/power-of-three/) +###### No:`326` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var isPowerOfThree = function(n) { + while(true) { + if(n === 1) { + return true; + } + if(n === 0 || n === 2) { + return false; + } + if(n % 3 !== 0) { + return false; + } else { + n = n / 3; + } + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Power of Two/README.md b/old(deprecated)/Algorithms/Power of Two/README.md new file mode 100644 index 0000000..632ea69 --- /dev/null +++ b/old(deprecated)/Algorithms/Power of Two/README.md @@ -0,0 +1,23 @@ +# [Power of Two](https://leetcode.com/problems/power-of-two/) +###### No:`231` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} n + * @return {boolean} + */ +var isPowerOfTwo = function(n) { + if(n === 0) return false; + while(n !== 1) { + if(n % 2 === 0) { + n = n / 2; + } else { + return false; + } + } + return true; +}; +``` + diff --git a/old(deprecated)/Algorithms/Product of Array Except Self/README.md b/old(deprecated)/Algorithms/Product of Array Except Self/README.md new file mode 100644 index 0000000..b7a3ae9 --- /dev/null +++ b/old(deprecated)/Algorithms/Product of Array Except Self/README.md @@ -0,0 +1,30 @@ +# [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/) +###### No:`238` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @return {number[]} + */ +var productExceptSelf = function(nums) { + var zeroCount = 0; + var products = nums + .filter((num) => { + if(num === 0) zeroCount++; + return num !== 0; + }) + .reduce((prev, curr) => prev * curr, 1); + return nums.map((num) => { + if(zeroCount >= 2) { + return 0; + } + if(zeroCount === 1) { + return num === 0 ? products : 0; + } + return products / num; + + }); +}; +``` diff --git a/old(deprecated)/Algorithms/Queue Reconstruction by Height/README.md b/old(deprecated)/Algorithms/Queue Reconstruction by Height/README.md new file mode 100644 index 0000000..a04efa9 --- /dev/null +++ b/old(deprecated)/Algorithms/Queue Reconstruction by Height/README.md @@ -0,0 +1,41 @@ +# [Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/#/description) +###### No:`406` +###### Difficulty:`Medium` + + + +```js +/** + * @param {number[][]} people + * @return {number[][]} + */ +var reconstructQueue = function(people) { + if (people.length <= 1) return people; + people.sort((a, b) => { + if (a[0] !== b[0]) { + return b[0] - a[0]; + } else { + return a[1] - b[1]; + } + }); + + var ret = []; + ret.push(people[0]); + + for (var i = 1; i < people.length; i++) { + if (people[i][0] === people[0][0]) { + ret.push(people[i]); + continue; + } + + var count = 0, index = 0; + while (count < people[i][1]) { + if (ret[index][0] >= people[i][0]) count++; + index++; + } + ret.splice(index, 0, people[i]); + } + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Ransom Note/README.md b/old(deprecated)/Algorithms/Ransom Note/README.md new file mode 100644 index 0000000..6fee5f3 --- /dev/null +++ b/old(deprecated)/Algorithms/Ransom Note/README.md @@ -0,0 +1,27 @@ +# [Ransom Note](https://leetcode.com/problems/ransom-note/) +###### No:`383` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} ransomNote + * @param {string} magazine + * @return {boolean} + */ +var canConstruct = function(ransomNote, magazine) { + var map = {}; + var flag = true; + + magazine.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); + ransomNote.split('').forEach(i => { + if(map[i] === undefined || map[i] === 0) { + flag = false; + } else { + map[i]--; + } + }); + + return flag; +}; +``` diff --git a/old(deprecated)/Algorithms/Rectangle Area/README.md b/old(deprecated)/Algorithms/Rectangle Area/README.md new file mode 100644 index 0000000..18f17be --- /dev/null +++ b/old(deprecated)/Algorithms/Rectangle Area/README.md @@ -0,0 +1,34 @@ +# [Rectangle Area](https://leetcode.com/problems/rectangle-area/) +###### No:`223` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} A + * @param {number} B + * @param {number} C + * @param {number} D + * @param {number} E + * @param {number} F + * @param {number} G + * @param {number} H + * @return {number} + */ +var computeArea = function(A, B, C, D, E, F, G, H) { + var areaA = (C-A) * (D-B); + var areaB = (G-E) * (H-F); + + var left = Math.max(A, E); + var right = Math.min(G, C); + var bottom = Math.max(F, B); + var top = Math.min(D, H); + + var overlap = 0; + + if(right > left && top > bottom) { + overlap = (right - left) * (top - bottom); + } + return areaA + areaB - overlap; +}; +``` diff --git a/old(deprecated)/Algorithms/Relative Ranks/README.md b/old(deprecated)/Algorithms/Relative Ranks/README.md new file mode 100644 index 0000000..74e6188 --- /dev/null +++ b/old(deprecated)/Algorithms/Relative Ranks/README.md @@ -0,0 +1,33 @@ +# [Relative Ranks](https://leetcode.com/problems/relative-ranks/#/description) +###### No:`506` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @return {string[]} + */ +var findRelativeRanks = function(nums) { + var rank = 4; + var map = {}; + var sortNums = [].slice.call(nums).sort((a, b) => b - a); + for (var i = 0; i < sortNums.length; i++) { + if (i === 0) { + map[sortNums[i]] = 'Gold Medal'; + } else if (i === 1) { + map[sortNums[i]] = 'Silver Medal'; + } else if (i === 2) { + map[sortNums[i]] = 'Bronze Medal'; + } else { + map[sortNums[i]] = String(rank); + rank++; + } + } + + return nums.map((score) => { + return map[score]; + }); +}; +``` diff --git a/old(deprecated)/Algorithms/Remove Duplicates from Sorted Array/README.md b/old(deprecated)/Algorithms/Remove Duplicates from Sorted Array/README.md new file mode 100644 index 0000000..89ece2f --- /dev/null +++ b/old(deprecated)/Algorithms/Remove Duplicates from Sorted Array/README.md @@ -0,0 +1,25 @@ +# [Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/) +###### No:`26` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var removeDuplicates = function(nums) { + var i = 0; + var j = 0; + while(j < nums.length) { + if(nums[i] == nums[j]) { + j++; + } else { + i++; + nums[i] = nums[j]; + j++; + } + } + return i + 1; +}; +``` diff --git a/old(deprecated)/Algorithms/Remove Duplicates from Sorted List/README.md b/old(deprecated)/Algorithms/Remove Duplicates from Sorted List/README.md new file mode 100644 index 0000000..dc0b19a --- /dev/null +++ b/old(deprecated)/Algorithms/Remove Duplicates from Sorted List/README.md @@ -0,0 +1,29 @@ +# [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) +###### No:`83` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var deleteDuplicates = function(head) { + var iter = head; + while(iter) { + if(iter.next && iter.val === iter.next.val) { + iter.next = iter.next.next; + } else { + iter = iter.next; + } + } + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Remove Element/README.md b/old(deprecated)/Algorithms/Remove Element/README.md new file mode 100644 index 0000000..f5bf0ef --- /dev/null +++ b/old(deprecated)/Algorithms/Remove Element/README.md @@ -0,0 +1,31 @@ +# [Remove Element](https://leetcode.com/problems/remove-element/) +###### No:`27` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @param {number} val + * @return {number} + */ +var removeElement = function(nums, val) { + var head = 0; + var tail = nums.length - 1; + while(head <= tail) { + if(nums[head] != val) { + head++; + continue; + } + + if(nums[tail] == val) { + tail--; + continue; + } + + nums[head] = nums[tail]; + tail--; + } + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Remove Linked List Elements/README.md b/old(deprecated)/Algorithms/Remove Linked List Elements/README.md new file mode 100644 index 0000000..773160c --- /dev/null +++ b/old(deprecated)/Algorithms/Remove Linked List Elements/README.md @@ -0,0 +1,42 @@ +# [Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/) +###### No:`203` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} val + * @return {ListNode} + */ +var removeElements = function(head, val) { + while(head && head.val == val) { + head = head.next; + } + + if(!head) { + return head; + } + + var prev = head; + var iter = head.next; + + while(iter) { + if(iter.val == val) { + prev.next = iter.next; + } else { + prev = iter; + } + iter = iter.next; + } + + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Remove Nth Node From End of List/README.md b/old(deprecated)/Algorithms/Remove Nth Node From End of List/README.md new file mode 100644 index 0000000..f014c26 --- /dev/null +++ b/old(deprecated)/Algorithms/Remove Nth Node From End of List/README.md @@ -0,0 +1,38 @@ +# [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/) +###### No:`19` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} n + * @return {ListNode} + */ +var removeNthFromEnd = function(head, n) { + var front = head; + var end = head; + for(var i = 0; i <= n && front; i++) { + front = front.next; + } + + // delete first node + if(i < n + 1) { + return head.next; + } + + while(front) { + front = front.next; + end = end.next; + } + end.next = end.next.next; + return head; +}; +``` diff --git a/old(deprecated)/Algorithms/Repeated Substring Pattern/README.md b/old(deprecated)/Algorithms/Repeated Substring Pattern/README.md new file mode 100644 index 0000000..34805d9 --- /dev/null +++ b/old(deprecated)/Algorithms/Repeated Substring Pattern/README.md @@ -0,0 +1,34 @@ +# [Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/#/description) +###### No:`459` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string} s + * @return {boolean} + */ +/* +var repeatedSubstringPattern = function(s) { + if (s.length === 1) return false; + var ret = false; + + for (var i = 1; i <= parseInt((s.length + 1) / 2); i++) { + for (var j = i; j < s.length; j++) { + if (s[j % i] !== s[j]) break; + } + if (j === s.length && (j - 1) % i === i - 1) { + ret = true; + break; + } + } + + return ret; +}; +*/ + +var repeatedSubstringPattern = function(s) { + return /^(.+)\1+$/.test(s); +} +``` diff --git a/old(deprecated)/Algorithms/Reverse Integer/README.md b/old(deprecated)/Algorithms/Reverse Integer/README.md new file mode 100644 index 0000000..9626fc5 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse Integer/README.md @@ -0,0 +1,27 @@ +# [Reverse Integer](https://leetcode.com/problems/reverse-integer/) +###### No:`7` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} x + * @return {number} + */ +var reverse = function(x) { + var flag = (x < 0 ? true : false); + x = Math.abs(x); + var reverse = parseInt((x + '').split('').reverse().join(''), 10); + if(reverse > Math.pow(2, 31)) { + return 0; + } + if(flag) { + return 0 - reverse; + } else { + return reverse; + } +}; +``` +###### PS: +Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases? +For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows. diff --git a/old(deprecated)/Algorithms/Reverse Linked List II/README.md b/old(deprecated)/Algorithms/Reverse Linked List II/README.md new file mode 100644 index 0000000..c11dd06 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse Linked List II/README.md @@ -0,0 +1,78 @@ +# [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/) +###### No:`92` +###### Difficulty:`Medium` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @param {number} m + * @param {number} n + * @return {ListNode} + */ + +var reverseBetween = function(head, m, n) { + function reverseList(head) { + if(!head) { + return head; + } + var prev = null; + var next = null; + while(head) { + next = head.next; + head.next = prev; + prev = head; + head = next; + } + return prev; + } + if(m === n) { + return head; + } + var middleLeft = null; + var middleRight = null; + var left = null; + var right = null; + + var i = 1; + var point = head; + while(point) { + if(i + 1 === m) { + left = point; + } + if(i === m) { + middleLeft = point; + } + if(i === n) { + middleRight = point; + } + if(i === n + 1) { + right = point; + } + i++; + point = point.next; + } + if(left) { + left.next = null; + } + + middleRight.next = null; + reverseList(middleLeft); + middleLeft.next = right; + + if(left) { + left.next = middleRight; + return head; + } else { + return middleRight; + } +}; + +``` diff --git a/old(deprecated)/Algorithms/Reverse Linked List/README.md b/old(deprecated)/Algorithms/Reverse Linked List/README.md new file mode 100644 index 0000000..1a9aec0 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse Linked List/README.md @@ -0,0 +1,32 @@ +# [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) +###### No:`206` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var reverseList = function(head) { + if(!head) { + return head; + } + var prev = null; + var next = null; + while(head) { + next = head.next; + head.next = prev; + prev = head; + head = next; + } + return prev; +}; +``` diff --git a/old(deprecated)/Algorithms/Reverse String/README.md b/old(deprecated)/Algorithms/Reverse String/README.md new file mode 100644 index 0000000..2959562 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse String/README.md @@ -0,0 +1,14 @@ +# [Reverse String](https://leetcode.com/problems/reverse-string/) +###### No:`344` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {string} + */ +var reverseString = function(s) { + return s.split('').reverse().join(''); +}; +``` diff --git a/old(deprecated)/Algorithms/Reverse Vowels of a String/README.md b/old(deprecated)/Algorithms/Reverse Vowels of a String/README.md new file mode 100644 index 0000000..4fbf546 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse Vowels of a String/README.md @@ -0,0 +1,29 @@ +# [Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/#/description) +###### No:`345` +###### Difficulty:`Easy` + + + +```js +/** + * @param {string} s + * @return {string} + */ +var reverseVowels = function(s) { + s = s.split(''); + var vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']; + var start = -1; + var end = s.length; + var temp; + + while (start < end) { + while (start < end && vowels.indexOf(s[++start]) === -1); + while (start < end && vowels.indexOf(s[--end]) === -1); + temp = s[start]; + s[start] = s[end]; + s[end] = temp; + } + + return s.join(''); +}; +``` diff --git a/old(deprecated)/Algorithms/Reverse Words in a String/README.md b/old(deprecated)/Algorithms/Reverse Words in a String/README.md new file mode 100644 index 0000000..1b565f4 --- /dev/null +++ b/old(deprecated)/Algorithms/Reverse Words in a String/README.md @@ -0,0 +1,17 @@ +# [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/) +###### No:`151` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} str + * @returns {string} + */ +var reverseWords = function(str) { + return str.split(' ').reverse().filter(function(item) { + return '' != item; + }).join(' ').trim(); +}; + +``` diff --git a/old(deprecated)/Algorithms/Roman to Integer/README.md b/old(deprecated)/Algorithms/Roman to Integer/README.md new file mode 100644 index 0000000..af02a17 --- /dev/null +++ b/old(deprecated)/Algorithms/Roman to Integer/README.md @@ -0,0 +1,49 @@ +# [Roman to Integer](https://leetcode.com/problems/roman-to-integer/) +###### No:`13` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {number} + * + * Symbol Value + * I 1 + * V 5 + * X 10 + * L 50 + * C 100 + * D 500 + * M 1,000 + + */ +var romanToInt = function(s) { + var map = { + 'I':1, + 'V':5, + 'X':10, + 'L':50, + 'C':100, + 'D':500, + 'M':1000 + }; + + var sum = 0; + var right = 'I'; + + for(var i = s.length - 1; i >=0; i--) { + if(i < s.length - 1) { + right = s[i + 1]; + } + if(map[s[i]] < map[right]) { + sum -= map[s[i]]; + } else { + sum += map[s[i]]; + right = s[i]; + } + } + return sum; +}; + +``` diff --git a/old(deprecated)/Algorithms/Rotate Array/README.md b/old(deprecated)/Algorithms/Rotate Array/README.md new file mode 100644 index 0000000..939d490 --- /dev/null +++ b/old(deprecated)/Algorithms/Rotate Array/README.md @@ -0,0 +1,17 @@ +# [Rotate Array](https://leetcode.com/problems/rotate-array/) +###### No:`189` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {void} Do not return anything, modify nums in-place instead. + */ +var rotate = function(nums, k) { + for(var i = 0; i < k; i++) { + nums.unshift(nums.pop()); + } +}; +``` diff --git a/old(deprecated)/Algorithms/Same Tree/README.md b/old(deprecated)/Algorithms/Same Tree/README.md new file mode 100644 index 0000000..44d45d5 --- /dev/null +++ b/old(deprecated)/Algorithms/Same Tree/README.md @@ -0,0 +1,29 @@ +# [Same Tree](https://leetcode.com/problems/same-tree/) +###### No:`100` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} p + * @param {TreeNode} q + * @return {boolean} + */ +var isSameTree = function(p, q) { + if(p == null || q == null) { + return p == q; + } + if(p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right)) { + return true; + } else { + return false; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Search Insert Position/README.md b/old(deprecated)/Algorithms/Search Insert Position/README.md new file mode 100644 index 0000000..be12e74 --- /dev/null +++ b/old(deprecated)/Algorithms/Search Insert Position/README.md @@ -0,0 +1,37 @@ +# [Search Insert Position](https://leetcode.com/problems/search-insert-position/#/description) +###### No:`35` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +var searchInsert = function(nums, target) { + var start = 0; + var end = nums.length - 1; + var middle = parseInt((start + end) / 2); + + while(start <= end) { + if (target === nums[middle]) { + return middle; + } else if (target > nums[middle]) { + start = middle + 1; + } else if (target < nums[middle] ) { + end = middle - 1; + } + if (start > end) { + if (target < nums[middle]) { + return middle; + } else { + return middle + 1; + } + } else { + middle = parseInt((start + end) / 2); + } + } +}; +``` diff --git a/old(deprecated)/Algorithms/Search in Rotated Sorted Array/README.md b/old(deprecated)/Algorithms/Search in Rotated Sorted Array/README.md new file mode 100644 index 0000000..ad7af47 --- /dev/null +++ b/old(deprecated)/Algorithms/Search in Rotated Sorted Array/README.md @@ -0,0 +1,47 @@ +# [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/#/description) +###### No:`33` +###### Difficulty:`Medium` +## JavaScript + + +```js +/** + * @param {number[]} nums + * @param {number} target + * @return {number} + */ +function binarySearch(nums, target) { + var end = nums.length - 1; + var start = 0; + var middle = parseInt((start + end) / 2); + + while (end >= start) { + if (nums[middle] == target) { + return middle; + } else if(nums[middle] > target) { + end = middle - 1; + } else if(nums[middle] < target) { + start = middle + 1; + } + middle = parseInt((start + end) / 2); + } + return -1; +} + +var search = function(nums, target) { + var i = 0; + while(nums[i] <= nums[i+1]) { + i++; + } + + if (nums[0] <= target && target <= nums[i]) { + return binarySearch(nums.slice(0, i + 1), target); + } else if (nums[i + 1] <= target && target <= nums[nums.length - 1]){ + var ret = binarySearch(nums.slice(i + 1), target); + return ret == -1 ? -1 : i + 1 + ret; + } else { + return -1; + } +}; + +``` diff --git a/old(deprecated)/Algorithms/Set Matrix Zeroes/README.md b/old(deprecated)/Algorithms/Set Matrix Zeroes/README.md new file mode 100644 index 0000000..418c0cd --- /dev/null +++ b/old(deprecated)/Algorithms/Set Matrix Zeroes/README.md @@ -0,0 +1,34 @@ +# [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) +###### No:`73` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[][]} matrix + * @return {void} Do not return anything, modify matrix in-place instead. + */ +var setZeroes = function(matrix) { + var hasZeroFirstCol = false; + for(var i = 0; i < matrix.length; i++) { + if(matrix[i][0] === 0) { + hasZeroFirstCol = true; + } + for(var j = 1; j < matrix[i].length; j++) { + if(matrix[i][j] === 0) { + matrix[0][j] = matrix[i][0] = 0; + } + } + } + for(var y = matrix.length - 1; y >= 0; y--) { + for(var x = matrix[y].length - 1; x >= 1; x--) { + if(matrix[0][x] === 0 || matrix[y][0] === 0) { + matrix[y][x] = 0; + } + } + if(hasZeroFirstCol) { + matrix[y][0] = 0; + } + } +}; +``` diff --git a/old(deprecated)/Algorithms/Single Number/README.md b/old(deprecated)/Algorithms/Single Number/README.md new file mode 100644 index 0000000..cb4a38b --- /dev/null +++ b/old(deprecated)/Algorithms/Single Number/README.md @@ -0,0 +1,20 @@ +# [Single Number](https://leetcode.com/problems/single-number/) +###### No:`136` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @return {number} + */ +var singleNumber = function(nums) { + return nums.reduce(function(prev, cur) { + return prev ^ cur; + }); +}; +``` + +#### Description: +Any number that XOR itselt will be 0; + diff --git a/old(deprecated)/Algorithms/Sort List/README.md b/old(deprecated)/Algorithms/Sort List/README.md new file mode 100644 index 0000000..2a2d19a --- /dev/null +++ b/old(deprecated)/Algorithms/Sort List/README.md @@ -0,0 +1,75 @@ +# [Sort List](https://leetcode.com/problems/sort-list/) +###### No:`148` +###### Difficulty:`Medium` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var sortList = function(head) { + function merge(l1, l2) { + if(!l1) return l2; + if(!l2) return l1; + var head = null + if(l1.val < l2.val) { + head = l1; + l1 = l1.next; + } else { + head = l2; + l2 = l2.next; + } + var newlist = head; + while(l1 && l2) { + if(l1.val < l2.val) { + newlist.next = l1; + l1 = l1.next; + } else { + newlist.next = l2; + l2 = l2.next; + } + newlist = newlist.next; + } + if(!l1) { + newlist.next = l2; + } else { + newlist.next = l1; + } + return head; + } + + if(!head || !head.next) { + return head; + } + + var p1 = head; + var p2 = head; + + // p1 go step 1 + // p2 go step 2 + while(p1 && p2) { + p2 = p2.next; + if(p2) { + p2 = p2.next; + } + if(!p2) { + break; + } + p1 = p1.next; + } + + var right = p1.next; + p1.next = null; + var left = head; + + return merge(sortList(left), sortList(right)); +} +``` diff --git a/old(deprecated)/Algorithms/Spiral Matrix/README.md b/old(deprecated)/Algorithms/Spiral Matrix/README.md new file mode 100644 index 0000000..73ca55d --- /dev/null +++ b/old(deprecated)/Algorithms/Spiral Matrix/README.md @@ -0,0 +1,35 @@ +# [Spiral Matrix](https://leetcode.com/problems/spiral-matrix/#/description) +###### No:`54` +###### Difficulty:`Medium` +## JavaScript + + +```js +/** + * @param {number[][]} matrix + * @return {number[]} + */ +var spiralOrder = function(matrix) { + if (matrix.length == 0) {return [];} + var n = matrix.length; + var m = matrix[0].length; + var up = 0, right = m - 1, down = n - 1, left = 0; + var ret = []; + + while(true) { + for(var r = left; r <= right; r++) ret.push(matrix[up][r]); + if (++up > down) break; + + for(var d = up; d <= down; d++) ret.push(matrix[d][right]); + if (--right < left) break; + + for(var l = right; l >= left; l--) ret.push(matrix[down][l]); + if (--down < up) break; + + for(var u = down; u >= up; u--) ret.push(matrix[u][left]); + if (++left > right) break; + } + return ret; +}; + +``` diff --git a/old(deprecated)/Algorithms/Sqrt(x)/README.md b/old(deprecated)/Algorithms/Sqrt(x)/README.md new file mode 100644 index 0000000..277ec32 --- /dev/null +++ b/old(deprecated)/Algorithms/Sqrt(x)/README.md @@ -0,0 +1,31 @@ +# [Sqrt(x)](https://leetcode.com/problems/sqrtx/#/description) +###### No:`69` +###### Difficulty:`Easy` +## JavaScript + + +```js +/** + * @param {number} x + * @return {number} + */ +var mySqrt = function(x) { + var start = 1; + var end = x; + var middle; + + while (start <= end) { + middle = start + parseInt((end - start) / 2); + if (x / middle === middle) { + return middle; + } else if (x / middle > middle) { + start = middle + 1; + } else { + end = middle - 1; + } + } + + return end; +}; + +``` diff --git a/old(deprecated)/Algorithms/String to Integer (atoi)/README.md b/old(deprecated)/Algorithms/String to Integer (atoi)/README.md new file mode 100644 index 0000000..cff1434 --- /dev/null +++ b/old(deprecated)/Algorithms/String to Integer (atoi)/README.md @@ -0,0 +1,24 @@ +# [String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/) +###### No:`8` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} str + * @return {number} + */ +var myAtoi = function(str) { + var ret = parseInt(str, 10); + if(Number.isNaN(ret)) { + return 0; + } + if(ret > 2147483647) { + return 2147483647; + } else if(ret < -2147483648) { + return -2147483648; + } else { + return ret; + } +}; +``` diff --git a/old(deprecated)/Algorithms/Sum of Left Leaves/README.md b/old(deprecated)/Algorithms/Sum of Left Leaves/README.md new file mode 100644 index 0000000..ac2ff0c --- /dev/null +++ b/old(deprecated)/Algorithms/Sum of Left Leaves/README.md @@ -0,0 +1,27 @@ +# [Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) +###### No:`404` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {number} + */ +var sumOfLeftLeaves = function(root) { + if(root === null) return 0; + + if(root.left !== null && root.left.left === null && root.left.right === null) { + return root.left.val + sumOfLeftLeaves(root.right); + } else { + return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right); + } +}; +``` diff --git a/old(deprecated)/Algorithms/Summary Ranges/README.md b/old(deprecated)/Algorithms/Summary Ranges/README.md new file mode 100644 index 0000000..080e0f2 --- /dev/null +++ b/old(deprecated)/Algorithms/Summary Ranges/README.md @@ -0,0 +1,37 @@ +# [Summary Ranges](https://leetcode.com/problems/summary-ranges/) +###### No:`228` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @return {string[]} + */ +var summaryRanges = function(nums) { + if(nums.length === 0) { + return nums; + } + + var ret = []; + var start = 0; + + for(var i = 1; i < nums.length; i++) { + if(nums[i] - nums[i-1] != 1) { + ret.push(nums.slice(start, i)); + start = i; + } + } + ret.push(nums.slice(start)); + + ret = ret.map(function(item) { + if(item.length > 1) { + return item[0] + '->' + item[item.length - 1]; + } else { + return item[0] + ''; + } + }); + + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Swap Nodes in Pairs/README.md b/old(deprecated)/Algorithms/Swap Nodes in Pairs/README.md new file mode 100644 index 0000000..68ee3a7 --- /dev/null +++ b/old(deprecated)/Algorithms/Swap Nodes in Pairs/README.md @@ -0,0 +1,43 @@ +# [Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/) +###### No:`24` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for singly-linked list. + * function ListNode(val) { + * this.val = val; + * this.next = null; + * } + */ +/** + * @param {ListNode} head + * @return {ListNode} + */ +var swapPairs = function(head) { + if(head === null || head.next === null) { + return head; + } + + var newhead = null; + var tmp1 = head.next; + var tmp2 = head.next.next; + head.next.next = head; + head.next = tmp2; + + newhead = tmp1; + + var p = head; + while(p && p.next && p.next.next) { + tmp1 = p.next.next; + tmp2 = p.next.next.next; + p.next.next.next = p.next; + p.next.next = tmp2; + p.next = tmp1; + p = p.next.next; + } + + return newhead; +}; +``` diff --git a/old(deprecated)/Algorithms/Symmetric Tree/README.md b/old(deprecated)/Algorithms/Symmetric Tree/README.md new file mode 100644 index 0000000..7d62f44 --- /dev/null +++ b/old(deprecated)/Algorithms/Symmetric Tree/README.md @@ -0,0 +1,39 @@ +# [Symmetric Tree](https://leetcode.com/problems/symmetric-tree/) +###### No:`101` +###### Difficulty:`Easy` + + +```javascript +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ + +var isSymmetric = function(root) { + function isSymmetricNode(left, right) { + if(!left && !right) { + return true; + } + if((left && !right) || (!left && right)) { + return false; + } + return (left.val == right.val) + && isSymmetricNode(left.left, right.right) + && isSymmetricNode(left.right, right.left); + } + if(root === null) { + return true; + } + var left = root.left; + var right = root.right; + return isSymmetricNode(left, right); +}; + +``` diff --git a/old(deprecated)/Algorithms/Teemo Attacking/README.md b/old(deprecated)/Algorithms/Teemo Attacking/README.md new file mode 100644 index 0000000..1f0b01a --- /dev/null +++ b/old(deprecated)/Algorithms/Teemo Attacking/README.md @@ -0,0 +1,28 @@ +# [Teemo Attacking](https://leetcode.com/problems/teemo-attacking/#/description) +###### No:`495` +###### Difficulty:`Medium` +## JavaScript + + +```js +/** + * @param {number[]} timeSeries + * @param {number} duration + * @return {number} + */ +var findPoisonedDuration = function(timeSeries, duration) { + if (timeSeries.length === 0) return 0; + + var time = 0; + for (var i = 0; i < timeSeries.length - 1; i++) { + if (timeSeries[i + 1] - timeSeries[i] < duration) { + time += timeSeries[i + 1] - timeSeries[i]; + } else { + time += duration; + } + } + time += duration; + + return time; +}; +``` diff --git a/old(deprecated)/Algorithms/Third Maximum Number/README.md b/old(deprecated)/Algorithms/Third Maximum Number/README.md new file mode 100644 index 0000000..34ca21e --- /dev/null +++ b/old(deprecated)/Algorithms/Third Maximum Number/README.md @@ -0,0 +1,31 @@ +# [Third Maximum Number](https://leetcode.com/problems/third-maximum-number/#/description) +###### No:`414` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number[]} nums + * @return {number} + */ +var getMax = function(nums) { + return Math.max.apply(null, nums); +}; + +var removeItem = function(nums, item) { + return nums.filter((value) => value !== item); +}; + +var thirdMax = function(nums) { + var first = getMax(nums); + nums = removeItem(nums, first); + var second = getMax(nums); + nums = removeItem(nums, second); + + if (nums.length === 0) return first; + return getMax(nums); + +}; + +``` diff --git a/old(deprecated)/Algorithms/Top K Frequent Elements/README.md b/old(deprecated)/Algorithms/Top K Frequent Elements/README.md new file mode 100644 index 0000000..69f986b --- /dev/null +++ b/old(deprecated)/Algorithms/Top K Frequent Elements/README.md @@ -0,0 +1,64 @@ +# [Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) +###### No:`347` +###### Difficulty:`Medium` + + +```javascript +/** + * @param {number[]} nums + * @param {number} k + * @return {number[]} + */ + +function SortNumber(size) { + this.size = size; + this.container = []; +} +SortNumber.prototype.setCompare = function(compare) { + this.compare = compare; +} +SortNumber.prototype.getMax = function() { + return this.max; +} +SortNumber.prototype.getMin = function() { + return this.min; +} +SortNumber.prototype.getAll = function() { + return this.container; +} +SortNumber.prototype.setBigNumber = function(num) { + if (this.container.length < this.size) { + this.container.push(num); + } else if (this.compare(this.min, num) < 0) { + this.container.shift(); + this.container.push(num); + } else { + return; + } + + this.container.sort(this.compare); + this.max = this.container[this.container.length - 1]; + this.min = this.container[0]; +} + +var topKFrequent = function(nums, k) { + var topNumber = new SortNumber(k); + topNumber.setCompare((a, b) => a.count - b.count); + var showTimes = {}; + nums.map((num) => { + if(showTimes[num]) { + showTimes[num]++; + } else { + showTimes[num] = 1; + } + }); + for(var num in showTimes) { + topNumber.setBigNumber({ + value: num, + count: showTimes[num], + }); + } + + return topNumber.getAll().map((item) => parseInt(item.value)); +}; +``` diff --git a/old(deprecated)/Algorithms/Two Sum/README.md b/old(deprecated)/Algorithms/Two Sum/README.md new file mode 100644 index 0000000..da17064 --- /dev/null +++ b/old(deprecated)/Algorithms/Two Sum/README.md @@ -0,0 +1,24 @@ +# [Two Sum](https://leetcode.com/problems/two-sum/) +###### No:`1` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number[]} nums + * @param {number} target + * @return {number[]} + */ +var twoSum = function(nums, target) { + var ret = []; + for(var i = 0; i < nums.length; i++) { + for(var j = i + 1; j < nums.length; j++) { + if(nums[i] + nums[j] === target) { + ret.push(i); + ret.push(j); + } + } + } + return ret; +}; +``` diff --git a/old(deprecated)/Algorithms/Ugly Number/README.md b/old(deprecated)/Algorithms/Ugly Number/README.md new file mode 100644 index 0000000..e9f9e04 --- /dev/null +++ b/old(deprecated)/Algorithms/Ugly Number/README.md @@ -0,0 +1,20 @@ +# [Ugly Number](https://leetcode.com/problems/ugly-number/) +###### No:`263` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {number} num + * @return {boolean} + */ +var isUgly = function(num) { + if(num <= 0) { + return false; + } + while(num % 2 === 0) {num /= 2;} + while(num % 3 === 0) {num /= 3;} + while(num % 5 === 0) {num /= 5;} + return num === 1 ? true : false; +}; +``` diff --git a/old(deprecated)/Algorithms/Valid Anagram/README.md b/old(deprecated)/Algorithms/Valid Anagram/README.md new file mode 100644 index 0000000..2ceaf86 --- /dev/null +++ b/old(deprecated)/Algorithms/Valid Anagram/README.md @@ -0,0 +1,25 @@ +# [Valid Anagram](https://leetcode.com/problems/valid-anagram/) +###### No:`242` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @param {string} t + * @return {boolean} + */ +var isAnagram = function(s, t) { + var arr1 = s.split('').sort(); + var arr2 = t.split('').sort(); + if(arr1.length !== arr2.length) { + return false; + } + for(var i = 0; i < arr1.length; i++) { + if(arr1[i] !== arr2[i]) { + return false; + } + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Valid Palindrome/README.md b/old(deprecated)/Algorithms/Valid Palindrome/README.md new file mode 100644 index 0000000..56cbaa0 --- /dev/null +++ b/old(deprecated)/Algorithms/Valid Palindrome/README.md @@ -0,0 +1,30 @@ +# [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) +###### No:`125` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {boolean} + */ +var isPalindrome = function(s) { + var str = s.split('').filter(function(c) { + return c.match(/[\w\d]/); + }).join('').toLowerCase(); + + if(str === '') { + return true; + } + var i = 0; + var j = str.length - 1; + while(i < j) { + if(str[i] != str[j]) { + return false; + } + i++; + j--; + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Valid Parentheses/README.md b/old(deprecated)/Algorithms/Valid Parentheses/README.md new file mode 100644 index 0000000..4c34ce2 --- /dev/null +++ b/old(deprecated)/Algorithms/Valid Parentheses/README.md @@ -0,0 +1,29 @@ +# [Valid Parentheses](https://leetcode.com/problems/valid-parentheses/) +###### No:`20` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @return {boolean} + */ +var isValid = function(s) { + var stack = []; + var match = { + ')': '(', + ']': '[', + '}': '{' + }; + var len; + for(var i = 0; i < s.length; i++) { + len = stack.length; + if(len > 0 && stack[len-1] == match[s[i]]) { + stack.pop(); + } else { + stack.push(s[i]); + } + } + return stack.length === 0; +}; +``` diff --git a/old(deprecated)/Algorithms/Valid Perfect Square/README.md b/old(deprecated)/Algorithms/Valid Perfect Square/README.md new file mode 100644 index 0000000..52ec1fa --- /dev/null +++ b/old(deprecated)/Algorithms/Valid Perfect Square/README.md @@ -0,0 +1,33 @@ +# [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/#/description) +###### No:`367` +###### Difficulty:`Easy` + + + +```js +/** + * @param {number} num + * @return {boolean} + */ +var isPerfectSquare = function(num) { + if (num < 1) return false; + if (num === 1) return true; + + var start = 0; + var end = num; + var middle = num / 2; + + while (start <= end) { + if (parseInt(num / middle) === middle && num % middle === 0) { + return true; + } else if (num / middle > middle) { + start = middle + 1; + } else if (num / middle < middle) { + end = middle - 1; + } + middle = parseInt((start + end) / 2); + } + + return false; +}; +``` diff --git a/old(deprecated)/Algorithms/Valid Sudoku/README.md b/old(deprecated)/Algorithms/Valid Sudoku/README.md new file mode 100644 index 0000000..475f14c --- /dev/null +++ b/old(deprecated)/Algorithms/Valid Sudoku/README.md @@ -0,0 +1,43 @@ +# [Valid Sudoku](https://leetcode.com/problems/valid-sudoku/) +###### No:`36` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {character[][]} board + * @return {boolean} + */ +var isValidSudoku = function(board) { + var rowExist = {}; + var colExist = {}; + var boxExist = {}; + var k, value; + for (var i = 0; i < board.length; i++) { + for (var j = 0; j < board[i].length; j++) { + value = board[i][j]; + k = parseInt(i / 3, 10) * 3 + parseInt(j / 3, 10); //the number of the box + if (!rowExist[i]) { + rowExist[i] = {}; + } + if (!colExist[j]) { + colExist[j] = {}; + } + if (!boxExist[k]) { + boxExist[k] = {}; + } + + if (value !== '.') { + if (rowExist[i][value] || colExist[j][value] || boxExist[k][value]) { + return false; + } else { + rowExist[i][value] = true; + colExist[j][value] = true; + boxExist[k][value] = true; + } + } + } + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/Validate Binary Search Tree/README.md b/old(deprecated)/Algorithms/Validate Binary Search Tree/README.md new file mode 100644 index 0000000..d73ea67 --- /dev/null +++ b/old(deprecated)/Algorithms/Validate Binary Search Tree/README.md @@ -0,0 +1,42 @@ +# [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/) +###### No:`98` +###### Difficulty:`Medium` +## JavaScript + + +```js +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ +/** + * @param {TreeNode} root + * @return {boolean} + */ + +var traverse = function(root, cb) { + if (root === null) { + return; + } + traverse(root.left, cb); + cb(root); + traverse(root.right, cb); + +}; +var isValidBST = function(root) { + var arr = []; + traverse(root, function(node) { + arr.push(node.val); + }); + + for(var i = 0; i < arr.length - 1; i++) { + if (arr[i] >= arr[i + 1]) { + return false; + } + } + return true; +}; +``` diff --git a/old(deprecated)/Algorithms/ZigZag Conversion/README.md b/old(deprecated)/Algorithms/ZigZag Conversion/README.md new file mode 100644 index 0000000..d88436d --- /dev/null +++ b/old(deprecated)/Algorithms/ZigZag Conversion/README.md @@ -0,0 +1,54 @@ +# [ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/) +###### No:`6` +###### Difficulty:`Easy` + + +```javascript +/** + * @param {string} s + * @param {number} numRows + * @return {string} + */ +var convert = function(s, numRows) { + var chars = s.split(''); + var arrs = []; + for(var k = 0; k < numRows; k++) { + arrs.push([]); + } + + var i = 0; + while(i < chars.length) { + for(var x = 0; x < numRows && i < chars.length; x++) { + arrs[x].push(chars[i++]); + } + for(var x = numRows - 2; x > 0 && i < chars.length; x--) { + arrs[x].push(chars[i++]); + } + } + + var ret = ''; + arrs.map(function(item) { + ret = ret.concat(item.join('')); + }); + return ret; +}; +``` +### How to solve? +``` +1 9 17 +2 8 10 16 18 +3 7 11 15 +4 6 12 14 +5 13 +``` + +###### 1.Create `arrs = [[],[],[],[],[]]` + +###### 2.traverse `chars` than save the every char like the following: +arrs[0] = [1, 9, 17]； +arrs[1] = [2, 8, 10, 16, 18]； +arrs[2] = [3, 7, 11, 15]； +arrs[3] = [4, 6, 12, 14]； +arrs[4] = [5, 13]； + +###### 3.concat arrs diff --git a/old(deprecated)/README.md b/old(deprecated)/README.md new file mode 100644 index 0000000..64c367a --- /dev/null +++ b/old(deprecated)/README.md @@ -0,0 +1,161 @@ +leetcode +======== +#### Total solved: 153 (Easy: 111 Medium: 41 Hard: 1 ) +My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/) + + +| No | Title | Source Code | Difficulty | +|----| ----- | -------- | ---------- | +|544|Output Contest Matches|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Output%20Contest%20Matches)|Medium| +|543|Diameter of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Diameter%20of%20Binary%20Tree)|Easy| +|542|01 Matrix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/01%20Matrix)|Medium| +|538|Convert BST to Greater Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Convert%20BST%20to%20Greater%20Tree)|Medium| +|532|K-diff Pairs in an Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/K-diff%20Pairs%20in%20an%20Array)|Easy| +|530|Minimum Absolute Difference in BST|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Absolute%20Difference%20in%20BST)|Easy| +|529|Minesweeper|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minesweeper)|Medium| +|526|Beautiful Arrangement|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Beautiful%20Arrangement)|Medium| +|520|Detect Capital|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Detect%20Capital)|Easy| +|515|Find Largest Value in Each Tree Row|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20Largest%20Value%20in%20Each%20Tree%20Row)|Medium| +|513|Find Bottom Left Tree Value|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20Bottom%20Left%20Tree%20Value)|Medium| +|508|Most Frequent Subtree Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Most%20Frequent%20Subtree%20Sum)|Medium| +|506|Relative Ranks|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Relative%20Ranks)|Easy| +|504|Base 7|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Base%207)|Easy| +|503|Next Greater Element II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Greater%20Element%20II)|Medium| +|501|Find Mode in Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20Mode%20in%20Binary%20Search%20Tree)|Easy| +|500|Keyboard Row|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Keyboard%20Row)|Easy| +|496|Next Greater Element I|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Greater%20Element%20I)|Easy| +|492|Construct the Rectangle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Construct%20the%20Rectangle)|Easy| +|485|Max Consecutive Ones|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Max%20Consecutive%20Ones)|Easy| +|482|License Key Formatting|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/License%20Key%20Formatting)|Medium| +|476|Number Complement|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20Complement)|Easy| +|463|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Easy| +|461|Hamming Distance|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Hamming%20Distance)|Easy| +|459|Repeated Substring Pattern|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Repeated%20Substring%20Pattern)|Easy| +|455|Assign Cookies|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Assign%20Cookies)|Easy| +|453|Minimum Moves to Equal Array Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Moves%20to%20Equal%20Array%20Elements)|Easy| +|450|Delete Node in a BST|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Delete%20Node%20in%20a%20BST)|Medium| +|448|Find All Numbers Disappeared in an Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20All%20Numbers%20Disappeared%20in%20an%20Array)|Easy| +|447|Number of Boomerangs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%20Boomerangs)|Easy| +|442|Find All Duplicates in an Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20All%20Duplicates%20in%20an%20Array)|Medium| +|441|Arranging Coins|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Arranging%20Coins)|Easy| +|437|Path Sum III|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Path%20Sum%20III)|Easy| +|434|Number of Segments in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%20Segments%20in%20a%20String)|Easy| +|415|Add Strings|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Strings)|Easy| +|414|Third Maximum Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Third%20Maximum%20Number)|Easy| +|413|Arithmetic Slices|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Arithmetic%20Slices)|Medium| +|412|Fizz Buzz|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Fizz%20Buzz)|Easy| +|409|Longest Palindrome|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Longest%20Palindrome)|Easy| +|406|Queue Reconstruction by Height|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Queue%20Reconstruction%20by%20Height)|Medium| +|404|Sum of Left Leaves|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sum%20of%20Left%20Leaves)|Easy| +|401|Binary Watch|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Watch)|Easy| +|400|Nth Digit|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Nth%20Digit)|Easy| +|389|Find the Difference|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20the%20Difference)|Easy| +|387|First Unique Character in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/First%20Unique%20Character%20in%20a%20String)|Easy| +|383|Ransom Note|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Ransom%20Note)|Easy| +|374|Guess Number Higher or Lower|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Guess%20Number%20Higher%20or%20Lower)|Easy| +|367|Valid Perfect Square|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Perfect%20Square)|Easy| +|350|Intersection of Two Arrays II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Arrays%20II)|Easy| +|349|Intersection of Two Arrays|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Arrays)|Easy| +|347|Top K Frequent Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Top%20K%20Frequent%20Elements)|Medium| +|345|Reverse Vowels of a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Vowels%20of%20a%20String)|Easy| +|344|Reverse String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20String)|Easy| +|343|Integer Break|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Integer%20Break)|Medium| +|342|Power of Four|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Four)|Easy| +|338|Counting Bits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Counting%20Bits)|Medium| +|328|Odd Even Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Odd%20Even%20Linked%20List)|Medium| +|326|Power of Three|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Three)|Easy| +|319|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Medium| +|292|Nim Game|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Nim%20Game)|Easy| +|283|Move Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Move%20Zeroes)|Easy| +|278|First Bad Version|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/First%20Bad%20Version)|Easy| +|268|Missing Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Missing%20Number)|Medium| +|263|Ugly Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Ugly%20Number)|Easy| +|258|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Easy| +|257|Binary Tree Paths|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Paths)|Easy| +|242|Valid Anagram|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Anagram)|Easy| +|238|Product of Array Except Self|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Product%20of%20Array%20Except%20Self)|Medium| +|237|Delete Node in a Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Delete%20Node%20in%20a%20Linked%20List)|Easy| +|235|Lowest Common Ancestor of a Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Lowest%20Common%20Ancestor%20of%20a%20Binary%20Search%20Tree)|Easy| +|234|Palindrome Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Palindrome%20Linked%20List)|Easy| +|232|Implement Queue using Stacks|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Implement%20Queue%20using%20Stacks)|Easy| +|231|Power of Two|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Two)|Easy| +|228|Summary Ranges|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Summary%20Ranges)|Easy| +|226|Invert Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Invert%20Binary%20Tree)|Easy| +|223|Rectangle Area|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Rectangle%20Area)|Easy| +|219|Contains Duplicate II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Contains%20Duplicate%20II)|Easy| +|217|Contains Duplicate|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Contains%20Duplicate)|Easy| +|206|Reverse Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Linked%20List)|Easy| +|205|Isomorphic Strings|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Isomorphic%20Strings)|Easy| +|204|Count Primes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Count%20Primes)|Easy| +|203|Remove Linked List Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Linked%20List%20Elements)|Easy| +|202|Happy Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Happy%20Number)|Easy| +|198|House Robber|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/House%20Robber)|Easy| +|191|Number of 1 Bits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%201%20Bits)|Easy| +|189|Rotate Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Rotate%20Array)|Easy| +|179|Largest Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Largest%20Number)|Medium| +|172|Factorial Trailing Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Factorial%20Trailing%20Zeroes)|Easy| +|171|Excel Sheet Column Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Excel%20Sheet%20Column%20Number)|Easy| +|169|Majority Element|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Majority%20Element)|Easy| +|168|Excel Sheet Column Title|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Excel%20Sheet%20Column%20Title)|Easy| +|165|Compare Version Numbers|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Compare%20Version%20Numbers)|Easy| +|160|Intersection of Two Linked Lists|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Linked%20Lists)|Easy| +|155|Min Stack|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Min%20Stack)|Easy| +|151|Reverse Words in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Words%20in%20a%20String)|Easy| +|150|Evaluate Reverse Polish Notation|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Evaluate%20Reverse%20Polish%20Notation)|Medium| +|149|Max Points on a Line|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Max%20Points%20on%20a%20Line)|Hard| +|148|Sort List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sort%20List)|Medium| +|144|Binary Tree Preorder Traversal|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Preorder%20Traversal)|Medium| +|141|Linked List Cycle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Linked%20List%20Cycle)|Easy| +|138|Copy List with Random Pointer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Copy%20List%20with%20Random%20Pointer)|Medium| +|136|Single Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Single%20Number)|Medium| +|125|Valid Palindrome|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Palindrome)|Easy| +|122|Best Time to Buy and Sell Stock II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II)|Medium| +|121|Best Time to Buy and Sell Stock|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Best%20Time%20to%20Buy%20and%20Sell%20Stock)|Easy| +|119|Pascal's Triangle II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Pascal's%20Triangle%20II)|Easy| +|118|Pascal's Triangle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Pascal's%20Triangle)|Easy| +|112|Path Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Path%20Sum)|Easy| +|111|Minimum Depth of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Depth%20of%20Binary%20Tree)|Easy| +|110|Balanced Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Balanced%20Binary%20Tree)|Easy| +|108|Convert Sorted Array to Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Convert%20Sorted%20Array%20to%20Binary%20Search%20Tree)|Easy| +|107|Binary Tree Level Order Traversal II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Level%20Order%20Traversal%20II)|Easy| +|104|Maximum Depth of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Maximum%20Depth%20of%20Binary%20Tree)|Easy| +|102|Binary Tree Level Order Traversal|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Level%20Order%20Traversal)|Easy| +|101|Symmetric Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Symmetric%20Tree)|Easy| +|100|Same Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Same%20Tree)|Easy| +|98|Validate Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Validate%20Binary%20Search%20Tree)|Medium| +|92|Reverse Linked List II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Linked%20List%20II)|Medium| +|88|Merge Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Merge%20Sorted%20Array)|Easy| +|83|Remove Duplicates from Sorted List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Duplicates%20from%20Sorted%20List)|Easy| +|73|Set Matrix Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Set%20Matrix%20Zeroes)|Medium| +|70|Climbing Stairs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Climbing%20Stairs)|Easy| +|69|Sqrt(x)|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sqrt(x))|Easy| +|66|Plus One|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Plus%20One)|Easy| +|58|Length of Last Word|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Length%20of%20Last%20Word)|Easy| +|54|Spiral Matrix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Spiral%20Matrix)|Medium| +|53|Maximum Subarray|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Maximum%20Subarray)|Easy| +|46|Permutations|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Permutations)|Medium| +|38|Count and Say|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Count%20and%20Say)|Easy| +|36|Valid Sudoku|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Sudoku)|Easy| +|35|Search Insert Position|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Search%20Insert%20Position)|Easy| +|33|Search in Rotated Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Search%20in%20Rotated%20Sorted%20Array)|Medium| +|31|Next Permutation|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Permutation)|Medium| +|29|Divide Two Integers|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Divide%20Two%20Integers)|Medium| +|28|Implement strStr()|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Implement%20strStr())|Easy| +|27|Remove Element|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Element)|Easy| +|26|Remove Duplicates from Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Duplicates%20from%20Sorted%20Array)|Easy| +|24|Swap Nodes in Pairs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Swap%20Nodes%20in%20Pairs)|Easy| +|22|Generate Parentheses|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Generate%20Parentheses)|Medium| +|21|Merge Two Sorted Lists|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Merge%20Two%20Sorted%20Lists)|Easy| +|20|Valid Parentheses|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Parentheses)|Easy| +|19|Remove Nth Node From End of List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Nth%20Node%20From%20End%20of%20List)|Easy| +|17|Letter Combinations of a Phone Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Letter%20Combinations%20of%20a%20Phone%20Number)|Medium| +|16|3Sum Closest|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/3Sum%20Closest)|Medium| +|15|3Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/3Sum)|Medium| +|14|Longest Common Prefix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Longest%20Common%20Prefix)|Easy| +|13|Roman to Integer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Roman%20to%20Integer)|Easy| +|12|Integer to Roman|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Integer%20to%20Roman)|Medium| +|9|Palindrome Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Palindrome%20Number)|Easy| +|8|String to Integer (atoi)|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/String%20to%20Integer%20(atoi))|Easy| +|7|Reverse Integer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Integer)|Easy| +|6|ZigZag Conversion|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/ZigZag%20Conversion)|Easy| +|1|Two Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Two%20Sum)|Easy| diff --git a/old(deprecated)/generate-md.js b/old(deprecated)/generate-md.js new file mode 100644 index 0000000..fab5af6 --- /dev/null +++ b/old(deprecated)/generate-md.js @@ -0,0 +1,65 @@ +var fs = require('fs'); +var events = require('events'); +var proxy = new events.EventEmitter(); + +var dir = './Algorithms'; +var repo_url = 'https://github.com/duteng/leetcode/tree/master/Algorithms/'; +var ret = []; + +var total = 0; +var easy = 0; +var medium = 0; +var hard = 0; + +targetDirs = fs.readdir(dir, function(err, files) { + var count = files.length; + files.forEach(function(value, index, arr) { + fs.readFile(dir + '/' + value + '/README.md', {encoding: 'utf8'}, function(err, data) { + var no = parseInt(data.match(/###### No:`(\d+)`/)[1], 10); + var difficulty = data.match(/###### Difficulty:`(\w+)`/)[1]; + var title = data.match(/# \[(.*)\]/)[1]; + var link = '[JavaScript](' + repo_url + title.replace(/\s/g, '%20') + ')'; + + total++; + if (difficulty === 'Hard') { + hard++; + } else if (difficulty === 'Medium') { + medium++; + } else if (difficulty === 'Easy') { + easy++; + } + ret.push({ + no: no, + title:title, + difficulty: difficulty, + link: link + }); + if(ret.length == count) { + proxy.emit('readDone'); + } + + }); + }); +}); + +proxy.once('readDone', function() { + ret.sort(function(a, b) { + return b.no - a.no; + }); + + var content = [ + 'leetcode', + '========', + `#### Total solved: ${total} (Easy: ${easy} Medium: ${medium} Hard: ${hard} )`, + 'My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/)', + '', + '', + '| No | Title | Source Code | Difficulty |', + '|----| ----- | -------- | ---------- |' + ].join('\r\n') + '\r\n'; + + for(var i = 0; i < ret.length; i++) { + content += '|' + ret[i].no + '|' + ret[i].title + '|' + ret[i].link + '|' + ret[i].difficulty + '|' + '\r\n'; + } + fs.writeFile('README.md', content); +}); diff --git a/old(deprecated)/package.json b/old(deprecated)/package.json new file mode 100644 index 0000000..12852d1 --- /dev/null +++ b/old(deprecated)/package.json @@ -0,0 +1,23 @@ +{ + "name": "request-leetcode", + "version": "1.0.0", + "description": "leetcode\r ========\r My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/)", + "main": "request.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/duteng/leedcode.git" + }, + "author": "", + "license": "ISC", + "bugs": { + "url": "https://github.com/duteng/leedcode/issues" + }, + "homepage": "https://github.com/duteng/leedcode#readme", + "dependencies": { + "cheerio": "^0.22.0", + "request": "^2.81.0" + } +} diff --git a/old(deprecated)/request-problem.js b/old(deprecated)/request-problem.js new file mode 100644 index 0000000..e5f405b --- /dev/null +++ b/old(deprecated)/request-problem.js @@ -0,0 +1,39 @@ +var fs = require('fs'); +var request = require('request'); +var cheerio = require('cheerio'); + +var urls = [ + 'https://leetcode.com/problems/linked-list-random-node/#/description', +]; + +urls.forEach((url) => { + request(url, (err, response, body) => { + console.log(url, err); + var $ = cheerio.load(body); + var textArr = $('.question-title h3').text().trim().split('. '); + var no = textArr[0]; + var title = textArr[1]; + var difficulty = $('.question-info li').eq(2).text().split(': ').pop(); + + var folderPath = `Algorithms/${title}`; + var filePath = `${folderPath}/README.md`; + + + fs.mkdir(folderPath, (err) => { + fs.open(filePath, 'wx', (err) => { + var content = [ + `# [${title}](${url})`, + `###### No:\`${no}\``, + `###### Difficulty:\`${difficulty}\``, + '## JavaScript', + '', + '', + '```js', + '```', + ].join('\r\n') + '\r\n'; + + fs.writeFile(filePath, content); + }); + }); + }); +}); diff --git a/permutations.cpp b/permutations.cpp deleted file mode 100644 index fa40c2b..0000000 --- a/permutations.cpp +++ /dev/null @@ -1,80 +0,0 @@ -class Solution { -public: - vector > permute(vector &num) { - vector > result, tmp_result; - vector tmp_v; - int size = num.size(),last, m, n; - - if(size == 1) { - result.push_back(num); - } else { - last = num[size - 1]; - num.pop_back(); - tmp_result = permute(num); - m = tmp_result.size(); - n = tmp_result[0].size(); - for(int i = 0; i < m; i++) { - for(int j = 0; j <= n; j++) { - tmp_v = tmp_result[i]; - tmp_v.insert(tmp_v.begin() + j, last); - result.push_back(tmp_v); - } - } - } - return result; - } -}; - -/* -#include -#include -using namespace std; - -template -void print2(vector > v) { - if(v.empty()) { - return; - } - int m = v.size(), - n = v[0].size(); - for(int i = 0; i < m; i++) { - for(int j = 0; j < n; j++) { - cout< > permute(vector &num) { - vector > result, tmp_result; - vector tmp_v; - vector::iterator iter; - int size = num.size(),last, m, n; - - if(size == 1) { - result.push_back(num); - } else { - last = num[size - 1]; - num.pop_back(); - tmp_result = permute(num); - m = tmp_result.size(); - n = tmp_result[0].size(); - for(int i = 0; i < m; i++) { - for(int j = 0; j <= n; j++) { - tmp_v = tmp_result[i]; - tmp_v.insert(tmp_v.begin() + j, last); - result.push_back(tmp_v); - } - } - } - return result; -} - -int main() { - vector > result; - int arr[] = {5,6,7,8}; - vector v (arr, arr + sizeof(arr) / sizeof(arr[0]) ); - result = permute(v); - print2(result); -} -*/ diff --git a/set-matrix-zeroes.cpp b/set-matrix-zeroes.cpp deleted file mode 100644 index afb0166..0000000 --- a/set-matrix-zeroes.cpp +++ /dev/null @@ -1,99 +0,0 @@ -class Solution { -public: - void setZeroes(vector > &matrix) { - const int m = matrix.size(); - const int n = matrix[0].size(); - vector row(m, false); - vector col(n, false); - - for (int i = 0; i < m; ++i) { - for (int j = 0; j < n; ++j) { - if (matrix[i][j] == 0) { - row[i] = col[j] = true; - } - } - } - for (int i = 0; i < m; ++i) { - if (row[i]) { - fill(&matrix[i][0], &matrix[i][0] + n, 0); - } - } - for (int j = 0; j < n; ++j) { - if (col[j]) { - for (int i = 0; i < m; ++i) { - matrix[i][j] = 0; - } - } - } - } -}; -/* -#include -#include - -using namespace std; - - -template -void print(vector v) { - int m = v.size(), - n = v[0].size(), - i, j; - for(i = 0; i < m; i++) { - for(j = 0; j < n; j++) { - cout< > &matrix) { - const int m = matrix.size(); - const int n = matrix[0].size(); - vector row(m, false); - vector col(n, false); - - for (int i = 0; i < m; ++i) { - for (int j = 0; j < n; ++j) { - if (matrix[i][j] == 0) { - row[i] = col[j] = true; - } - } - } - for (int i = 0; i < m; ++i) { - if (row[i]) { - fill(&matrix[i][0], &matrix[i][0] + n, 0); - } - } - for (int j = 0; j < n; ++j) { - if (col[j]) { - for (int i = 0; i < m; ++i) { - matrix[i][j] = 0; - } - } - } -} - - -int main() { - vector > matrix; - int arr1[] = {16,2,77,29}; - int arr2[] = {16,0,77,29}; - int arr3[] = {16,2,77,29}; - int arr4[] = {16,2,77,29}; - vector vec1 (arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]) ); - vector vec2 (arr2, arr2 + sizeof(arr2) / sizeof(arr2[0]) ); - vector vec3 (arr3, arr3 + sizeof(arr3) / sizeof(arr3[0]) ); - vector vec4 (arr4, arr4 + sizeof(arr4) / sizeof(arr4[0]) ); - - matrix.push_back(vec1); - matrix.push_back(vec2); - matrix.push_back(vec3); - matrix.push_back(vec4); - print(matrix); - setZeroes(matrix); - print(matrix); - return 0; -} - -*/