├── .gitignore ├── README.md └── old(deprecated) ├── Algorithms ├── 01 Matrix │ └── README.md ├── 3Sum Closest │ └── README.md ├── 3Sum │ └── README.md ├── Add Digits │ └── README.md ├── Add Strings │ └── README.md ├── Arithmetic Slices │ └── README.md ├── Arranging Coins │ └── README.md ├── Assign Cookies │ └── README.md ├── Balanced Binary Tree │ └── README.md ├── Base 7 │ └── README.md ├── Beautiful Arrangement │ └── README.md ├── Best Time to Buy and Sell Stock II │ └── README.md ├── Best Time to Buy and Sell Stock │ └── README.md ├── Binary Tree Level Order Traversal II │ └── README.md ├── Binary Tree Level Order Traversal │ └── README.md ├── Binary Tree Paths │ └── README.md ├── Binary Tree Preorder Traversal │ └── README.md ├── Binary Watch │ └── README.md ├── Bulb Switcher │ └── README.md ├── Climbing Stairs │ └── README.md ├── Compare Version Numbers │ └── README.md ├── Construct the Rectangle │ └── README.md ├── Contains Duplicate II │ └── README.md ├── Contains Duplicate │ └── README.md ├── Convert BST to Greater Tree │ └── README.md ├── Convert Sorted Array to Binary Search Tree │ └── README.md ├── Copy List with Random Pointer │ └── README.md ├── Count Primes │ └── README.md ├── Count and Say │ └── README.md ├── Counting Bits │ └── README.md ├── Delete Node in a BST │ └── README.md ├── Delete Node in a Linked List │ └── README.md ├── Detect Capital │ └── README.md ├── Diameter of Binary Tree │ └── README.md ├── Divide Two Integers │ └── README.md ├── Evaluate Reverse Polish Notation │ └── README.md ├── Excel Sheet Column Number │ └── README.md ├── Excel Sheet Column Title │ └── README.md ├── Factorial Trailing Zeroes │ └── README.md ├── Find All Duplicates in an Array │ └── README.md ├── Find All Numbers Disappeared in an Array │ └── README.md ├── Find Bottom Left Tree Value │ └── README.md ├── Find Largest Value in Each Tree Row │ └── README.md ├── Find Mode in Binary Search Tree │ └── README.md ├── Find the Difference │ └── README.md ├── First Bad Version │ └── README.md ├── First Unique Character in a String │ └── README.md ├── Fizz Buzz │ └── README.md ├── Generate Parentheses │ └── README.md ├── Guess Number Higher or Lower │ └── README.md ├── Hamming Distance │ └── README.md ├── Happy Number │ └── README.md ├── House Robber │ └── README.md ├── Implement Queue using Stacks │ └── README.md ├── Implement strStr() │ └── README.md ├── Integer Break │ └── README.md ├── Integer to Roman │ └── README.md ├── Intersection of Two Arrays II │ └── README.md ├── Intersection of Two Arrays │ └── README.md ├── Intersection of Two Linked Lists │ └── README.md ├── Invert Binary Tree │ └── README.md ├── Island Perimeter │ └── README.md ├── Isomorphic Strings │ └── README.md ├── K-diff Pairs in an Array │ └── README.md ├── Keyboard Row │ └── README.md ├── Largest Number │ └── README.md ├── Length of Last Word │ └── README.md ├── Letter Combinations of a Phone Number │ └── README.md ├── License Key Formatting │ └── README.md ├── Linked List Cycle │ └── README.md ├── Linked List Random Node │ └── README.md ├── Longest Common Prefix │ └── README.md ├── Longest Palindrome │ └── README.md ├── Lowest Common Ancestor of a Binary Search Tree │ └── README.md ├── Majority Element │ └── README.md ├── Max Consecutive Ones │ └── README.md ├── Max Points on a Line │ └── README.md ├── Maximum Depth of Binary Tree │ └── README.md ├── Maximum Subarray │ └── README.md ├── Merge Sorted Array │ └── README.md ├── Merge Two Sorted Lists │ └── README.md ├── Min Stack │ └── README.md ├── Minesweeper │ └── README.md ├── Minimum Absolute Difference in BST │ └── README.md ├── Minimum Depth of Binary Tree │ └── README.md ├── Minimum Moves to Equal Array Elements │ └── README.md ├── Missing Number │ └── README.md ├── Most Frequent Subtree Sum │ └── README.md ├── Move Zeroes │ └── README.md ├── Next Greater Element I │ └── README.md ├── Next Greater Element II │ └── README.md ├── Next Permutation │ └── README.md ├── Nim Game │ └── README.md ├── Nth Digit │ └── README.md ├── Number Complement │ └── README.md ├── Number of 1 Bits │ └── README.md ├── Number of Boomerangs │ └── README.md ├── Number of Segments in a String │ └── README.md ├── Odd Even Linked List │ └── README.md ├── Output Contest Matches │ └── README.md ├── Palindrome Linked List │ └── README.md ├── Palindrome Number │ └── README.md ├── Pascal's Triangle II │ └── README.md ├── Pascal's Triangle │ └── README.md ├── Path Sum III │ └── README.md ├── Path Sum │ └── README.md ├── Permutations │ └── README.md ├── Plus One │ └── README.md ├── Power of Four │ └── README.md ├── Power of Three │ └── README.md ├── Power of Two │ └── README.md ├── Product of Array Except Self │ └── README.md ├── Queue Reconstruction by Height │ └── README.md ├── Ransom Note │ └── README.md ├── Rectangle Area │ └── README.md ├── Relative Ranks │ └── README.md ├── Remove Duplicates from Sorted Array │ └── README.md ├── Remove Duplicates from Sorted List │ └── README.md ├── Remove Element │ └── README.md ├── Remove Linked List Elements │ └── README.md ├── Remove Nth Node From End of List │ └── README.md ├── Repeated Substring Pattern │ └── README.md ├── Reverse Integer │ └── README.md ├── Reverse Linked List II │ └── README.md ├── Reverse Linked List │ └── README.md ├── Reverse String │ └── README.md ├── Reverse Vowels of a String │ └── README.md ├── Reverse Words in a String │ └── README.md ├── Roman to Integer │ └── README.md ├── Rotate Array │ └── README.md ├── Same Tree │ └── README.md ├── Search Insert Position │ └── README.md ├── Search in Rotated Sorted Array │ └── README.md ├── Set Matrix Zeroes │ └── README.md ├── Single Number │ └── README.md ├── Sort List │ └── README.md ├── Spiral Matrix │ └── README.md ├── Sqrt(x) │ └── README.md ├── String to Integer (atoi) │ └── README.md ├── Sum of Left Leaves │ └── README.md ├── Summary Ranges │ └── README.md ├── Swap Nodes in Pairs │ └── README.md ├── Symmetric Tree │ └── README.md ├── Teemo Attacking │ └── README.md ├── Third Maximum Number │ └── README.md ├── Top K Frequent Elements │ └── README.md ├── Two Sum │ └── README.md ├── Ugly Number │ └── README.md ├── Valid Anagram │ └── README.md ├── Valid Palindrome │ └── README.md ├── Valid Parentheses │ └── README.md ├── Valid Perfect Square │ └── README.md ├── Valid Sudoku │ └── README.md ├── Validate Binary Search Tree │ └── README.md └── ZigZag Conversion │ └── README.md ├── README.md ├── generate-md.js ├── package.json └── request-problem.js /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/01 Matrix/README.md: -------------------------------------------------------------------------------- 1 | # [01 Matrix](https://leetcode.com/problems/01-matrix/#/description) 2 | ###### No:`542` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ### LeetCode Weekly Contest 24 7 | ### 542. 01 Matrix 8 | Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell. 9 | The distance between two adjacent cells is 1. 10 | #### Example 1 11 | Input: 12 | ``` 13 | 0 0 0 14 | 0 1 0 15 | 0 0 0 16 | ``` 17 | Output: 18 | ``` 19 | 0 0 0 20 | 0 1 0 21 | 0 0 0 22 | ``` 23 | #### Example 2 24 | Input: 25 | ``` 26 | 0 0 0 27 | 0 1 0 28 | 1 1 1 29 | ``` 30 | Output: 31 | ``` 32 | 0 0 0 33 | 0 1 0 34 | 1 2 1 35 | ``` 36 | 37 | #### Solution 38 | ```js 39 | /** 40 | * @param {number[][]} matrix 41 | * @return {number[][]} 42 | */ 43 | var updateMatrix = function(matrix) { 44 | var m = matrix.length; 45 | var n = matrix[0].length; 46 | var queue = []; 47 | 48 | for (var i = 0; i < m; i++) { 49 | for (var j = 0; j < n; j++) { 50 | if (matrix[i][j] === 0) { 51 | queue.push([i, j]); 52 | } else { 53 | matrix[i][j] = undefined; 54 | } 55 | } 56 | } 57 | 58 | while (queue.length > 0) { 59 | var [x, y] = queue.shift(); 60 | var range = [[-1,0], [1, 0], [0, -1], [0, 1]]; 61 | range.forEach(([p, q]) => { 62 | p += x; 63 | q += y; 64 | if (p < 0 || p >= m || q < 0 || q >= n) return; 65 | if (matrix[p][q] !== undefined && matrix[p][q] < matrix[x][y] + 1) return; 66 | matrix[p][q] = matrix[x][y] + 1; 67 | queue.push([p, q]); 68 | }); 69 | } 70 | 71 | return matrix; 72 | }; 73 | ``` 74 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/3Sum Closest/README.md: -------------------------------------------------------------------------------- 1 | # [3Sum Closest](https://leetcode.com/problems/3sum-closest/) 2 | ###### No:`16` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @param {number} target 10 | * @return {number} 11 | */ 12 | var threeSumClosest = function(nums, target) { 13 | var closet = Number.MAX_SAFE_INTEGER; 14 | var closetTarget; 15 | 16 | nums = nums.sort((a, b) => a - b); 17 | 18 | for (var i = 0; i + 2 < nums.length; i++) { 19 | if (i > 0 && nums[i] == nums[i - 1]) { 20 | continue; 21 | } 22 | 23 | var j = i + 1, k = nums.length - 1; 24 | 25 | while (j < k) { 26 | if (Math.abs(nums[j] + nums[k] + nums[i] - target) < closet) { 27 | closet = Math.abs(nums[j] + nums[k] + nums[i] - target); 28 | closetTarget = nums[j] + nums[k] + nums[i]; 29 | } 30 | 31 | if (nums[j] + nums[k] + nums[i] === target) { 32 | return target; 33 | } else if (nums[j] + nums[k] + nums[i] > target) { 34 | k--; 35 | } else { 36 | j++; 37 | } 38 | } 39 | } 40 | 41 | return closetTarget; 42 | }; 43 | 44 | ``` 45 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/3Sum/README.md: -------------------------------------------------------------------------------- 1 | # [3Sum](https://leetcode.com/problems/3sum/) 2 | ###### No:`15` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ### Solution 1 7 | Result: `timeout` 8 | How: Use the data structure SumNode. Make sure the key is unique. 9 | ```javascript 10 | /** 11 | * @param {number[]} nums 12 | * @return {number[][]} 13 | */ 14 | var SumNode = function(nums, i, j) { 15 | this.i = i; 16 | this.j = j; 17 | this.sum = nums[i] + nums[j]; 18 | 19 | var max = Math.max(nums[i], nums[j], -this.sum); 20 | var min = Math.min(nums[i], nums[j], -this.sum); 21 | var mid = 0 - max - min; 22 | this.key = [max, mid, min].join('_'); 23 | this.isUsed = false; 24 | 25 | } 26 | 27 | var threeSum = function (nums) { 28 | var ret = []; 29 | var sumNodes = {}; 30 | var node = null; 31 | 32 | for (var i = 0; i < nums.length; i++) { 33 | for (var j = i + 1; j < nums.length; j++) { 34 | node = new SumNode(nums, i, j); 35 | sumNodes[node.key] = node; 36 | } 37 | } 38 | 39 | for (var key in sumNodes) { 40 | node = sumNodes[key]; 41 | for(var k = 0; k < nums.length; k++) { 42 | if (k !== node.i && 43 | k !== node.j && 44 | node.sum + nums[k] === 0 && 45 | !node.isUsed 46 | ) { 47 | delete sumNodes[key]; 48 | node.isUsed = true; 49 | ret.push([nums[k], nums[node.i], nums[node.j]]); 50 | } 51 | } 52 | } 53 | 54 | return ret; 55 | }; 56 | 57 | ``` 58 | 59 | ### Solution 2 60 | Result: timeout 61 | ```javascript 62 | /** 63 | * @param {number[]} nums 64 | * @return {number[][]} 65 | */ 66 | 67 | var threeSum = function(nums) { 68 | var ret = []; 69 | 70 | nums = nums.sort((a, b) => a - b); 71 | for (var i = 0; i + 2 < nums.length; i++) { 72 | if (i > 0 && nums[i] == nums[i - 1]) { 73 | continue; 74 | } 75 | 76 | var j = i + 1, k = nums.length - 1; 77 | var target = -nums[i]; 78 | 79 | while (j < k) { 80 | if (nums[j] + nums[k] == target) { 81 | ret.push([nums[i], nums[j], nums[k]]); 82 | j++; 83 | k--; 84 | while (j < k && nums[j] == nums[j - 1]) j++; 85 | while (j < k && nums[k] == nums[k + 1]) k--; 86 | } else if (nums[j] + nums[k] > target) { 87 | k--; 88 | } else { 89 | j++; 90 | } 91 | } 92 | } 93 | 94 | return ret; 95 | }; 96 | ``` 97 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Add Digits/README.md: -------------------------------------------------------------------------------- 1 | # [Add Digits](https://leetcode.com/problems/add-digits/) 2 | ###### No:`258` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | #### Solution 1: 7 | ```javascript 8 | /** 9 | * @param {number} num 10 | * @return {number} 11 | */ 12 | var addDigits = function(num) { 13 | if(num < 10) { 14 | return num; 15 | } else { 16 | var arr = (num + '').split(''); 17 | var ret = arr.reduce(function(prev, cur) { 18 | return parseInt(prev, 10) + parseInt(cur, 10); 19 | }); 20 | return addDigits(ret); 21 | } 22 | }; 23 | ``` 24 | 25 | 26 | #### Solution 2: 27 | ```javascript 28 | /** 29 | * @param {number} num 30 | * @return {number} 31 | */ 32 | var addDigits = function(num) { 33 | return 1 + (num - 1) % 9; 34 | }; 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Add Strings/README.md: -------------------------------------------------------------------------------- 1 | # [Add Strings](https://leetcode.com/problems/add-strings/) 2 | ###### No:`415` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} num1 9 | * @param {string} num2 10 | * @return {string} 11 | */ 12 | var addStrings = function(num1, num2) { 13 | var zeroString = Array(Math.abs(num1.length - num2.length) + 1).join(0); 14 | if (num1.length > num2.length) { 15 | num2 = zeroString + num2; 16 | } else { 17 | num1 = zeroString + num1; 18 | } 19 | 20 | var d1 = num1.split(''); 21 | var d2 = num2.split(''); 22 | var ret = []; 23 | var sum ; 24 | var hasCarryOver = false; 25 | 26 | for(var i = d1.length - 1; i >= 0 ; i--) { 27 | sum = parseInt(d1[i]) + parseInt(d2[i]); 28 | if (hasCarryOver) { 29 | sum++; 30 | } 31 | if(sum >= 10) { 32 | sum -= 10; 33 | hasCarryOver = true; 34 | } else { 35 | hasCarryOver = false; 36 | } 37 | ret.unshift(sum); 38 | } 39 | 40 | if(hasCarryOver) { 41 | ret.unshift(1); 42 | } 43 | 44 | return ret.join(''); 45 | }; 46 | 47 | ``` 48 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Arithmetic Slices/README.md: -------------------------------------------------------------------------------- 1 | # [Arithmetic Slices](https://leetcode.com/problems/arithmetic-slices/#/description) 2 | ###### No:`413` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} A 10 | * @return {number} 11 | */ 12 | var count = function(len) { 13 | return len < 3 ? 0 : (1+ len - 2) * (len - 2) / 2; 14 | }; 15 | 16 | var numberOfArithmeticSlices = function(A) { 17 | if (A.length < 3) return 0; 18 | var len = 2; 19 | var diff = A[1] - A[0]; 20 | var ret = 0; 21 | 22 | for (var i = 1; i < A.length - 1; i++) { 23 | if (diff === A[i + 1] - A[i]) { 24 | len++ 25 | } else { 26 | ret += count(len); 27 | diff = A[i + 1] - A[i]; 28 | len = 2; 29 | } 30 | } 31 | ret += count(len); 32 | 33 | return ret; 34 | }; 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Arranging Coins/README.md: -------------------------------------------------------------------------------- 1 | # [Arranging Coins](https://leetcode.com/problems/arranging-coins/#/description) 2 | ###### No:`441` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} n 10 | * @return {number} 11 | */ 12 | var arrangeCoins = function(n) { 13 | if (n === 0) {return 0;} 14 | var start = 0; 15 | var end = n; 16 | var middle = parseInt((start + end + 1) / 2); 17 | 18 | while (start <= end) { 19 | if ((1 + middle) * middle / 2 <= n && n < (2 + middle) * (middle + 1) / 2) { 20 | return middle; 21 | } else if ((2 + middle) * (middle + 1) / 2 <= n) { 22 | start = middle + 1; 23 | } else if ((1 + middle) * middle / 2 > n) { 24 | end = middle - 1; 25 | } 26 | middle = parseInt((start + end) / 2); 27 | } 28 | }; 29 | 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Assign Cookies/README.md: -------------------------------------------------------------------------------- 1 | # [Assign Cookies](https://leetcode.com/problems/assign-cookies/) 2 | ###### No:`455` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} g 9 | * @param {number[]} s 10 | * @return {number} 11 | */ 12 | var findContentChildren = function(g, s) { 13 | var compare = (a, b) => a - b; 14 | g = g.sort(compare); 15 | s = s.sort(compare); 16 | 17 | var i = s.length - 1; // person index 18 | var j = g.length - 1; // cookie index 19 | var count = 0; 20 | 21 | while (i >= 0 && j >= 0) { 22 | if(s[i] >= g[j]) { 23 | i--; 24 | j--; 25 | count++ 26 | } else { 27 | j--; 28 | } 29 | } 30 | 31 | return count; 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Balanced Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) 2 | ###### No:`110` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {boolean} 17 | */ 18 | var maxDeepth = function(root) { 19 | if(root === null) { 20 | return 0; 21 | } else { 22 | return Math.max(maxDeepth(root.left), maxDeepth(root.right)) + 1; 23 | } 24 | } 25 | var isBalanced = function(root) { 26 | if(root === null) { 27 | return true; 28 | } 29 | var leftDeepth = maxDeepth(root.left); 30 | var rightDeepth = maxDeepth(root.right); 31 | 32 | if(Math.abs(leftDeepth - rightDeepth) <= 1 33 | && isBalanced(root.left) 34 | && isBalanced(root.right) 35 | ) { 36 | return true; 37 | } else { 38 | return false; 39 | } 40 | }; 41 | ``` 42 | 43 | #### Description: 44 | 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) 45 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Base 7/README.md: -------------------------------------------------------------------------------- 1 | # [Base 7](https://leetcode.com/problems/base-7/#/description) 2 | ###### No:`504` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} num 10 | * @return {string} 11 | */ 12 | var convertToBase7 = function(num) { 13 | if (num < 0) return '-' + convertToBase7(-num); 14 | else if (num < 7) return String(num); 15 | else return convertToBase7(parseInt(num / 7)) + num % 7; 16 | }; 17 | ``` 18 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Beautiful Arrangement/README.md: -------------------------------------------------------------------------------- 1 | # [Beautiful Arrangement](https://leetcode.com/problems/beautiful-arrangement/#/description) 2 | ###### No:`526` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} N 10 | * @return {number} 11 | */ 12 | var countArrangement = function(N) { 13 | var position = []; 14 | for (var i = 1; i <= N; i++) position.push(i); 15 | var value = position.slice(); 16 | 17 | var ret = 0; 18 | var count = function(position, value) { 19 | if (position.length === 1 && value.length === 1) { 20 | if (position[0] % value[0] === 0 || value[0] % position[0] === 0) { 21 | ret++; 22 | } 23 | return 24 | } 25 | for (var i = 0; i < position.length; i++) { 26 | if (position[i] % value[0] === 0 || value[0] % position[i] === 0) { 27 | count(position.slice(0, i).concat(position.slice(i + 1)), value.slice(1)); 28 | } 29 | } 30 | }; 31 | count(position, value); 32 | return ret; 33 | }; 34 | 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Best Time to Buy and Sell Stock II/README.md: -------------------------------------------------------------------------------- 1 | # [Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/) 2 | ###### No:`122` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} prices 9 | * @return {number} 10 | */ 11 | var maxProfit = function(prices) { 12 | var minsum = 0; 13 | var maxsum = 0; 14 | var isUp; 15 | var lastIsUp; 16 | 17 | for(var i = 0; i < prices.length - 1; i++) { 18 | if(prices[i] < prices[i+1]) { 19 | isUp = true; 20 | } else { 21 | isUp = false; 22 | } 23 | if(isUp && (i === 0 || lastIsUp === false)) { 24 | minsum += prices[i]; 25 | } 26 | if(lastIsUp && isUp === false) { 27 | maxsum += prices[i]; 28 | } 29 | if(isUp && i === prices.length - 2) { 30 | maxsum += prices[i + 1]; 31 | } 32 | lastIsUp = isUp; 33 | } 34 | return maxsum - minsum; 35 | }; 36 | ``` 37 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Best Time to Buy and Sell Stock/README.md: -------------------------------------------------------------------------------- 1 | # [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/#/description) 2 | ###### No:`121` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} prices 10 | * @return {number} 11 | */ 12 | var maxProfit = function(prices) { 13 | var min = Number.MAX_VALUE; 14 | var profit = 0; 15 | 16 | for(var i = 0; i < prices.length; i++) { 17 | min = Math.min(min, prices[i]); 18 | profit = Math.max(profit, prices[i] - min); 19 | } 20 | 21 | return profit; 22 | }; 23 | ``` 24 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Binary Tree Level Order Traversal II/README.md: -------------------------------------------------------------------------------- 1 | # [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/) 2 | ###### No:`107` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number[][]} 17 | */ 18 | var traversal = function(ret, root, depth) { 19 | if(root === null) { 20 | return; 21 | } 22 | if(!Array.isArray(ret[depth])) { 23 | ret[depth] = []; 24 | } 25 | ret[depth].push(root.val); 26 | traversal(ret, root.left, depth + 1); 27 | traversal(ret, root.right, depth + 1); 28 | } 29 | var levelOrderBottom = function(root) { 30 | var ret = []; 31 | traversal(ret, root, 0); 32 | return ret.reverse(); 33 | }; 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Binary Tree Level Order Traversal/README.md: -------------------------------------------------------------------------------- 1 | # [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/) 2 | ###### No:`102` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number[][]} 17 | */ 18 | var traversal = function(ret, root, depth) { 19 | if(root === null) { 20 | return; 21 | } 22 | if(!Array.isArray(ret[depth])) { 23 | ret[depth] = []; 24 | } 25 | ret[depth].push(root.val); 26 | traversal(ret, root.left, depth + 1); 27 | traversal(ret, root.right, depth + 1); 28 | } 29 | 30 | var levelOrder = function(root) { 31 | var ret = []; 32 | traversal(ret, root, 0); 33 | return ret; 34 | }; 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Binary Tree Paths/README.md: -------------------------------------------------------------------------------- 1 | # [Binary Tree Paths](https://leetcode.com/problems/binary-tree-paths/) 2 | ###### No:`257` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {string[]} 17 | */ 18 | var binaryTreePaths = function(root) { 19 | if(root === null) { 20 | return []; 21 | } 22 | var ret = []; 23 | var str = arguments[1] ? arguments[1] : ''; 24 | if(str) { 25 | str = str + '->' + root.val; 26 | } else { 27 | str = root.val + ''; 28 | } 29 | if(root.left === null && root.right === null) { 30 | ret.push(str); 31 | } 32 | 33 | if(root.left) { 34 | var leftRet = binaryTreePaths(root.left, str); 35 | Array.prototype.push.apply(ret, leftRet); 36 | } 37 | if(root.right) { 38 | var rightRet = binaryTreePaths(root.right, str); 39 | Array.prototype.push.apply(ret, rightRet); 40 | } 41 | return ret; 42 | }; 43 | ``` 44 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Binary Tree Preorder Traversal/README.md: -------------------------------------------------------------------------------- 1 | # [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) 2 | ###### No:`144` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number[]} 17 | */ 18 | 19 | var preorderTraversal = function(root) { 20 | if(root === null) return []; 21 | var ret = []; 22 | 23 | function pre(root) { 24 | if(root) { 25 | ret.push(root.val); 26 | pre(root.left); 27 | pre(root.right); 28 | } 29 | } 30 | 31 | pre(root); 32 | return ret; 33 | }; 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Binary Watch/README.md: -------------------------------------------------------------------------------- 1 | # [Binary Watch](https://leetcode.com/problems/binary-watch/) 2 | ###### No:`401` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} num 9 | * @return {string[]} 10 | */ 11 | 12 | var bitcount1 = function (num) { 13 | return (num).toString(2).split('').filter(i => i === '1').length; 14 | } 15 | var formatTime = function(h, m) { 16 | if (m < 10) { 17 | return `${h}:0${m}` 18 | } else { 19 | return `${h}:${m}` 20 | } 21 | } 22 | 23 | var readBinaryWatch = function(num) { 24 | var ret = []; 25 | 26 | for (var h = 0; h < 12; h++) { 27 | for (var m = 0; m < 60; m++) { 28 | if(bitcount1(h << 6 | m) === num) { 29 | ret.push(formatTime(h, m)); 30 | } 31 | } 32 | } 33 | 34 | return ret; 35 | }; 36 | ``` 37 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Bulb Switcher/README.md: -------------------------------------------------------------------------------- 1 | # [Add Digits](https://leetcode.com/problems/add-digits/) 2 | ###### No:`319` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | #### Solution 1: 7 | refer: https://leetcode.com/discuss/91371/share-my-o-1-solution-with-explanation 8 | ```js 9 | /** 10 | * @param {number} n 11 | * @return {number} 12 | */ 13 | var bulbSwitch = function(n) { 14 | return parseInt(Math.sqrt(n)); 15 | }; 16 | ``` 17 | 18 | 19 | #### Solution 2: 20 | #### Time Limit Exceeded. Input: 9999999 21 | ```js 22 | /** 23 | * @param {number} n 24 | * @return {number} 25 | */ 26 | var bulbSwitch = function(n) { 27 | var bulbs = new Array(n).fill(0); 28 | for(i = 1; i <= n; i++) { 29 | for(var j = i; j <= n; j = j + i) { 30 | bulbs[j-1] = 1 - bulbs[j-1]; 31 | } 32 | } 33 | var sum = 0; 34 | 35 | for(var i = 0; i < bulbs.length; i++) { 36 | if(bulbs[i] == 1) { 37 | sum++; 38 | } 39 | } 40 | return sum; 41 | }; 42 | ``` 43 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Climbing Stairs/README.md: -------------------------------------------------------------------------------- 1 | # [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/) 2 | ###### No:`70` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return 10 | * 11 | * s[n] = s[n-1] + s[n] 12 | * s[1] = 1; 13 | * s[2] = 2; 14 | */ 15 | var climbStairs = function(n) { 16 | var s = {}; 17 | s[1] = 1; 18 | s[2] = 2; 19 | for(var i = 3; i<=n; i++) { 20 | s[i] = s[i-1] + s[i-2]; 21 | } 22 | return s[n]; 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Compare Version Numbers/README.md: -------------------------------------------------------------------------------- 1 | # [Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/) 2 | ###### No:`165` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} version1 9 | * @param {string} version2 10 | * @return {number} 11 | */ 12 | var compareVersion = function(version1, version2) { 13 | var arr1 = version1.split('.').map(function(item) { 14 | return parseInt(item); 15 | }); 16 | var arr2 = version2.split('.').map(function(item) { 17 | return parseInt(item); 18 | }); 19 | var a, b; 20 | for(var i = 0; i < arr1.length || i < arr2.length; i++) { 21 | a = i >= arr1.length ? 0 : arr1[i]; 22 | b = i >= arr2.length ? 0 : arr2[i]; 23 | if(a > b) { 24 | return 1; 25 | } else if(a < b) { 26 | return -1; 27 | } 28 | } 29 | return 0; 30 | }; 31 | ``` 32 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Construct the Rectangle/README.md: -------------------------------------------------------------------------------- 1 | # [Construct the Rectangle](https://leetcode.com/problems/construct-the-rectangle/#/description) 2 | ###### No:`492` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} area 10 | * @return {number[]} 11 | */ 12 | var constructRectangle = function(area) { 13 | var root = parseInt(Math.sqrt(area)); 14 | var ret = []; 15 | for (var i = root; i <= area; i++) { 16 | if (area % i === 0) { 17 | i > area / i ? ret.push(i, area / i) : ret.push(area / i, i); 18 | break; 19 | } 20 | } 21 | return ret; 22 | }; 23 | ``` 24 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Contains Duplicate II/README.md: -------------------------------------------------------------------------------- 1 | # [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/) 2 | ###### No:`219` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | #### Solution 1: (slower) 7 | ```javascript 8 | var containsNearbyDuplicate = function(nums, k) { 9 | for(var i = 0; i < nums.length; i++) { 10 | for(var j = i + 1; j < nums.length && j - i <= k; j++) { 11 | if(nums[i] === nums[j]) { 12 | return true; 13 | } 14 | } 15 | } 16 | return false; 17 | }; 18 | ``` 19 | 20 | #### Solution 2: (faster) 21 | ```javascript 22 | var containsNearbyDuplicate = function(nums, k) { 23 | var index = {}; 24 | var value; 25 | for(var i = 0; i < nums.length; i++) { 26 | value = nums[i]; 27 | if(index[value] === undefined) { 28 | index[value] = [i]; 29 | } else if(i - index[value][index[value].length - 1] <= k){ 30 | return true; 31 | } else { 32 | index[value].push(i); 33 | } 34 | } 35 | return false; 36 | } 37 | ``` 38 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Contains Duplicate/README.md: -------------------------------------------------------------------------------- 1 | # [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/) 2 | ###### No:`217` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {boolean} 10 | */ 11 | var containsDuplicate = function(nums) { 12 | for(var i = 0; i < nums.length; i++) { 13 | for(var j = i + 1 ; j < nums.length; j++) { 14 | if(nums[i] == nums[j]) { 15 | return true; 16 | } 17 | } 18 | } 19 | return false; 20 | }; 21 | ``` 22 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Convert BST to Greater Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Convert BST to Greater Tree](https://leetcode.com/problems/convert-bst-to-greater-tree/#/description) 2 | ###### No:`538` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ### LeetCode Weekly Contest 24 7 | ### 538. Convert BST to Greater Tree 8 | 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. 9 | 10 | #### Example 11 | ``` 12 | Input: The root of a Binary Search Tree like this: 13 | 5 14 | / \ 15 | 2 13 16 | 17 | Output: The root of a Greater Tree like this: 18 | 18 19 | / \ 20 | 20 13 21 | ``` 22 | #### Solution 23 | ```js 24 | /** 25 | * Definition for a binary tree node. 26 | * function TreeNode(val) { 27 | * this.val = val; 28 | * this.left = this.right = null; 29 | * } 30 | */ 31 | /** 32 | * @param {TreeNode} root 33 | * @return {TreeNode} 34 | */ 35 | var convertBST = function(root) { 36 | var sum = 0; 37 | function traverse (root) { 38 | if (root === null) return; 39 | traverse(root.right); 40 | root.val = root.val + sum; 41 | sum = root.val; 42 | traverse(root.left); 43 | } 44 | 45 | traverse(root); 46 | return root; 47 | }; 48 | ``` 49 | 50 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Convert Sorted Array to Binary Search Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/#/description) 2 | ###### No:`108` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {number[]} nums 17 | * @return {TreeNode} 18 | */ 19 | 20 | var sortedArrayToBST = function(nums) { 21 | if (nums.length === 0) {return null;} 22 | var start = 0; 23 | var end = nums.length - 1; 24 | var middle = parseInt((start + end) / 2); 25 | 26 | var root, node1, node2, node3; 27 | 28 | if (nums.length <= 3) { 29 | node1 = new TreeNode(nums[0]); 30 | if (nums.length === 1) { 31 | return node1; 32 | } 33 | 34 | node2 = new TreeNode(nums[1]); 35 | node2.left = node1; 36 | if (nums.length === 2) { 37 | return node2; 38 | } 39 | 40 | node3 = new TreeNode(nums[2]); 41 | node2.right = node3; 42 | return node2; 43 | 44 | } else { 45 | root = new TreeNode(nums[middle]); 46 | root.left = sortedArrayToBST(nums.slice(0, middle)); 47 | root.right = sortedArrayToBST(nums.slice(middle + 1)); 48 | } 49 | return root; 50 | }; 51 | ``` 52 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Copy List with Random Pointer/README.md: -------------------------------------------------------------------------------- 1 | # [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/#/description) 2 | ###### No:`138` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for singly-linked list with a random pointer. 10 | * function RandomListNode(label) { 11 | * this.label = label; 12 | * this.next = this.random = null; 13 | * } 14 | */ 15 | 16 | /** 17 | * @param {RandomListNode} head 18 | * @return {RandomListNode} 19 | */ 20 | 21 | var copyLinkList = function(head) { 22 | if (head === null) { 23 | return null; 24 | } 25 | 26 | var new_head = new RandomListNode(head.label); 27 | var new_current = new_head; 28 | var node; 29 | 30 | head = head.next; 31 | while(head !== null) { 32 | node = new RandomListNode(head.label); 33 | new_current.next = node; 34 | new_current = node; 35 | head = head.next; 36 | } 37 | 38 | return new_head; 39 | }; 40 | 41 | var copyRandomList = function(head) { 42 | if (head === null) { 43 | return null; 44 | } 45 | 46 | var new_head = copyLinkList(head); 47 | var new_list = []; 48 | var old_list = []; 49 | 50 | var new_curr = new_head; 51 | var old_curr = head; 52 | while (new_curr !== null) { 53 | new_list.push(new_curr); 54 | old_list.push(old_curr); 55 | new_curr = new_curr.next; 56 | old_curr = old_curr.next; 57 | } 58 | 59 | for (var i = 0; i < new_list.length; i++) { 60 | new_list[i].random = old_list[i]; 61 | old_list[i].next = new_list[i]; 62 | } 63 | 64 | for (i = 0; i < new_list.length; i++) { 65 | if (old_list[i].random === null) { 66 | new_list[i].random = null; 67 | } else { 68 | new_list[i].random = old_list[i].random.next; 69 | } 70 | } 71 | 72 | for (i = 0; i < old_list.length - 1; i++) { 73 | old_list[i].next = old_list[i + 1]; 74 | } 75 | old_list[old_list.length - 1].next = null; 76 | 77 | 78 | return new_head; 79 | }; 80 | 81 | 82 | ``` 83 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Count Primes/README.md: -------------------------------------------------------------------------------- 1 | # [Count Primes](https://leetcode.com/problems/count-primes/#/description) 2 | ###### No:`204` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} n 10 | * @return {number} 11 | */ 12 | var countPrimes = function(n) { 13 | var isPrime = []; 14 | for (var i = 2; i < n; i++) { 15 | isPrime[i] = true; 16 | } 17 | 18 | for (var i = 2; i * i < n; i++) { 19 | if (isPrime[i]) { 20 | for (var j = i * i; j < n; j += i) { 21 | isPrime[j] = false; 22 | } 23 | } 24 | } 25 | 26 | var count = 0; 27 | for (var i = 2; i < n; i++) { 28 | if (isPrime[i]) { 29 | count++; 30 | } 31 | } 32 | 33 | return count; 34 | }; 35 | 36 | ``` 37 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Count and Say/README.md: -------------------------------------------------------------------------------- 1 | # [Count and Say](https://leetcode.com/problems/count-and-say/#/description) 2 | ###### No:`38` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} n 10 | * @return {string} 11 | */ 12 | 13 | var countAndSay = function(n) { 14 | if (n === 1) return '1'; 15 | 16 | var last = countAndSay(n - 1); 17 | var digit = last[0]; 18 | var count = 0; 19 | var ret = ''; 20 | 21 | for (var i = 0; i < last.length; i++) { 22 | if (last[i] !== digit) { 23 | ret += count + digit; 24 | digit = last[i]; 25 | count = 0; 26 | } 27 | count++; 28 | } 29 | ret += count + digit; 30 | 31 | return ret; 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Counting Bits/README.md: -------------------------------------------------------------------------------- 1 | # [Counting Bits](https://leetcode.com/problems/counting-bits/) 2 | ###### No:`338` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | var countBits = function(num) { 8 | var ret = [0]; 9 | var j = 1; 10 | for(var i = 1; i <= num; i++) { 11 | if(i == 1) {ret.push(1);continue;} 12 | if(i == Math.pow(2, j+1)) j++; 13 | ret.push(ret[i - Math.pow(2, j)] + 1); 14 | } 15 | return ret; 16 | }; 17 | ``` 18 | 19 | #### How to solve? 20 | DP: 21 | countBits[0] = 0; 22 | countBits[1] = 1; 23 | 24 | condition: max(j) && n>= Math.pow(2, j) 25 | countBits[n] = countBits[n - Math.pow(2, j)] + 1; 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Delete Node in a BST/README.md: -------------------------------------------------------------------------------- 1 | # [Delete Node in a BST](https://leetcode.com/problems/delete-node-in-a-bst/#/description) 2 | ###### No:`450` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @param {number} key 18 | * @return {TreeNode} 19 | */ 20 | var update = function(parent, direction) { 21 | if (parent === null) { 22 | return; 23 | } 24 | var deleteNode = parent[direction]; 25 | if (deleteNode.right) { 26 | parent[direction] = deleteNode.right; 27 | 28 | var leftIsNullNode = deleteNode.right; 29 | while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; 30 | leftIsNullNode.left = deleteNode.left; 31 | return parent; 32 | } 33 | if(deleteNode.left) { 34 | parent[direction] = deleteNode.left; 35 | return parent; 36 | } 37 | parent[direction] = null; 38 | return parent; 39 | }; 40 | 41 | var search = function(root, direction, key, ret) { 42 | var node = root[direction]; 43 | if (node === null) { 44 | return; 45 | } 46 | 47 | if (node.val === key) { 48 | ret.parent = root; 49 | ret.direction = direction; 50 | } else if (node.val > key) { 51 | search(node, 'left', key, ret); 52 | } else { 53 | search(node, 'right', key, ret); 54 | } 55 | }; 56 | 57 | var deleteNode = function(root, key) { 58 | if (root === null) { 59 | return null; 60 | } 61 | 62 | if (root.val === key) { 63 | if (root.right) { 64 | var leftIsNullNode = root.right; 65 | while(leftIsNullNode.left !== null) leftIsNullNode = leftIsNullNode.left; 66 | 67 | leftIsNullNode.left = root.left; 68 | return root.right; 69 | } 70 | return root.left; 71 | } 72 | 73 | var ret = { 74 | parent: null, 75 | direction: null, 76 | }; 77 | search(root, 'left', key, ret); 78 | search(root, 'right', key, ret); 79 | update(ret.parent, ret.direction); 80 | 81 | return root; 82 | }; 83 | 84 | ``` 85 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Delete Node in a Linked List/README.md: -------------------------------------------------------------------------------- 1 | # [Delete Node in a Linked List](https://leetcode.com/problems/delete-node-in-a-linked-list/) 2 | ###### No:`237` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} node 16 | * @return {void} Do not return anything, modify node in-place instead. 17 | */ 18 | var deleteNode = function(node) { 19 | node.val = node.next.val; 20 | node.next = node.next.next; 21 | }; 22 | ``` 23 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Detect Capital/README.md: -------------------------------------------------------------------------------- 1 | # [Detect Capital](https://leetcode.com/problems/detect-capital/#/description) 2 | ###### No:`520` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} word 10 | * @return {boolean} 11 | */ 12 | var detectCapitalUse = function(word) { 13 | return /^[A-Z]?([a-z]*|[A-Z]*)$/.test(word); 14 | }; 15 | ``` 16 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Diameter of Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/#/description) 2 | ###### No:`543` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number} 18 | */ 19 | 20 | var diameterOfBinaryTree = function(root) { 21 | var maxDiameter = -1; 22 | var getDepth = function(root) { 23 | if (root === null) { 24 | return 0; 25 | } 26 | var leftDepth = getDepth(root.left); 27 | var rightDepth = getDepth(root.right); 28 | 29 | maxDiameter = Math.max(maxDiameter, leftDepth + rightDepth); 30 | maxDepth = Math.max(leftDepth, rightDepth) + 1; 31 | return maxDepth; 32 | }; 33 | 34 | if (root === null) return 0; 35 | getDepth(root); 36 | 37 | return maxDiameter; 38 | }; 39 | ``` 40 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Divide Two Integers/README.md: -------------------------------------------------------------------------------- 1 | # [Divide Two Integers](https://leetcode.com/problems/divide-two-integers/#/description) 2 | ###### No:`29` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```java 8 | class Solution { 9 | public: 10 | int divide(int dividend, int divisor) { 11 | if (!divisor || (dividend == INT_MIN && divisor == -1)) 12 | return INT_MAX; 13 | int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1; 14 | long long dvd = labs(dividend); 15 | long long dvs = labs(divisor); 16 | int res = 0; 17 | while (dvd >= dvs) { 18 | long long temp = dvs, multiple = 1; 19 | while (dvd >= (temp << 1)) { 20 | temp <<= 1; 21 | multiple <<= 1; 22 | } 23 | dvd -= temp; 24 | res += multiple; 25 | } 26 | return sign == 1 ? res : -res; 27 | } 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Evaluate Reverse Polish Notation/README.md: -------------------------------------------------------------------------------- 1 | # [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) 2 | ###### No:`150` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string[]} tokens 9 | * @return {number} 10 | */ 11 | var evalRPN = function(tokens) { 12 | var stack = []; 13 | var a, b, result; 14 | for(var i = 0; i < tokens.length; i++) { 15 | if(Number.isNaN(parseInt(tokens[i]))) { 16 | b = stack.pop(); 17 | a = stack.pop(); 18 | if(tokens[i] == '+') { 19 | result = a + b; 20 | } else if(tokens[i] == '-') { 21 | result = a - b; 22 | } else if(tokens[i] == '*') { 23 | result = a * b; 24 | } else if(tokens[i] == '/') { 25 | result = a / b; 26 | } 27 | stack.push(parseInt(result, 10)); 28 | } else { 29 | stack.push(parseInt(tokens[i], 10)); 30 | } 31 | } 32 | return stack.pop(); 33 | }; 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Excel Sheet Column Number/README.md: -------------------------------------------------------------------------------- 1 | # [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) 2 | ###### No:`171` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {number} 10 | */ 11 | var titleToNumber = function(s) { 12 | var arr = s.split(''); 13 | var digit; 14 | var sum = 0; 15 | for(var i = arr.length - 1, j = 0; i >= 0; i--, j++) { 16 | digit = arr[i].charCodeAt(0) - 64; 17 | sum += digit * Math.pow(26, j) 18 | } 19 | return sum; 20 | }; 21 | ``` 22 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Excel Sheet Column Title/README.md: -------------------------------------------------------------------------------- 1 | # [Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/) 2 | ###### No:`168` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {string} 10 | */ 11 | var convertToTitle = function(n) { 12 | var ret = '' 13 | while(n > 0) { 14 | n--; 15 | ret = String.fromCharCode(65 + n % 26) + ret; 16 | n = Math.floor(n / 26); 17 | } 18 | return ret; 19 | }; 20 | ``` 21 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Factorial Trailing Zeroes/README.md: -------------------------------------------------------------------------------- 1 | # [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) 2 | ###### No:`172` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {number} 10 | */ 11 | var trailingZeroes = function(n) { 12 | var sum = 0; 13 | var divisor = 5; 14 | while(n >= divisor) { 15 | sum += Math.floor(n / divisor); 16 | divisor *= 5; 17 | } 18 | return sum; 19 | }; 20 | ``` 21 | 22 | ### How to solve? 23 | Only 2 * 5 can make 0. 24 | 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. 25 | 5 catains one 5; 26 | 25 contains two 5; 27 | 125.. 28 | 29 | So count the number 5 is the answer. 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find All Duplicates in an Array/README.md: -------------------------------------------------------------------------------- 1 | # [Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/#/description) 2 | ###### No:`442` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number[]} 11 | */ 12 | var findDuplicates = function(nums) { 13 | var ret = []; 14 | for (var i = 0; i < nums.length; i++) { 15 | var index = Math.abs(nums[i]) - 1; 16 | if (nums[index] < 0) { 17 | ret.push(Math.abs(nums[i])); 18 | } 19 | nums[index] = -Math.abs(nums[index]); 20 | } 21 | 22 | return ret; 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find All Numbers Disappeared in an Array/README.md: -------------------------------------------------------------------------------- 1 | # [Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/#/description) 2 | ###### No:`448` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number[]} 11 | */ 12 | var findDisappearedNumbers = function(nums) { 13 | var map = {}; 14 | var ret = []; 15 | 16 | nums.forEach(function(num) { 17 | map[num] = true; 18 | }); 19 | 20 | for (var i = 1; i <= nums.length; i++) { 21 | if (map[i] === undefined) { 22 | ret.push(i); 23 | } 24 | } 25 | 26 | return ret; 27 | }; 28 | ``` 29 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find Bottom Left Tree Value/README.md: -------------------------------------------------------------------------------- 1 | # [Find Bottom Left Tree Value](https://leetcode.com/problems/find-bottom-left-tree-value/#/description) 2 | ###### No:`513` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number} 18 | */ 19 | 20 | var findBottomLeftValue = function(root) { 21 | var maxDepth = Number.MIN_SAFE_INTEGER; 22 | var value; 23 | 24 | var traverse = function(root, depth) { 25 | if (root === null) return; 26 | if (depth > maxDepth) { 27 | value = root.val; 28 | maxDepth = depth; 29 | } 30 | traverse(root.left, depth + 1); 31 | traverse(root.right, depth + 1); 32 | }; 33 | 34 | traverse(root, 1); 35 | return value; 36 | }; 37 | 38 | ``` 39 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find Largest Value in Each Tree Row/README.md: -------------------------------------------------------------------------------- 1 | # [Find Largest Value in Each Tree Row](https://leetcode.com/problems/find-largest-value-in-each-tree-row/#/description) 2 | ###### No:`515` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number[]} 18 | */ 19 | var largestValues = function(root) { 20 | if (root === null) return []; 21 | var left = largestValues(root.left); 22 | var right = largestValues(root.right); 23 | 24 | var ret = []; 25 | for(var i = 0; i < left.length || i < right.length; i++) { 26 | if (left[i] === undefined) { 27 | ret.push(right[i]); 28 | } else if (right[i] === undefined) { 29 | ret.push(left[i]); 30 | } else { 31 | ret.push(Math.max(right[i], left[i])); 32 | } 33 | } 34 | ret.unshift(root.val); 35 | 36 | return ret; 37 | }; 38 | ``` 39 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find Mode in Binary Search Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Find Mode in Binary Search Tree](https://leetcode.com/problems/find-mode-in-binary-search-tree/#/description) 2 | ###### No:`501` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number[]} 18 | */ 19 | 20 | var traversal = function(root, func) { 21 | if (root === null) { 22 | return null; 23 | } 24 | traversal(root.left, func); 25 | func(root.val); 26 | traversal(root.right, func); 27 | }; 28 | 29 | var findMode = function(root) { 30 | if (root === null) return []; 31 | 32 | var ret; 33 | var maxCount = Number.MIN_VALUE; 34 | var prevValue; 35 | var currentCount; 36 | 37 | traversal(root, function(val) { 38 | if (prevValue === undefined) { 39 | prevValue = val; 40 | currentCount = 1; 41 | } else { 42 | if (prevValue === val) { 43 | currentCount++; 44 | } else { 45 | currentCount = 1; 46 | } 47 | } 48 | 49 | if(currentCount > maxCount) { 50 | ret = []; 51 | ret.push(val); 52 | maxCount = currentCount; 53 | } else if (currentCount === maxCount) { 54 | ret.push(val); 55 | } 56 | prevValue = val; 57 | }); 58 | 59 | return ret; 60 | }; 61 | ``` 62 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Find the Difference/README.md: -------------------------------------------------------------------------------- 1 | # [Find the Difference](https://leetcode.com/problems/find-the-difference/) 2 | ###### No:`389` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @param {string} t 10 | * @return {character} 11 | */ 12 | var findTheDifference = function(s, t) { 13 | if(!s) return t; 14 | var sSum = s.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); 15 | var tSum = t.split('').map(i => i.charCodeAt(0)).reduce((p, c) => p + c); 16 | return String.fromCharCode(tSum - sSum); 17 | }; 18 | ``` 19 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/First Bad Version/README.md: -------------------------------------------------------------------------------- 1 | # [First Bad Version](https://leetcode.com/problems/first-bad-version/#/description) 2 | ###### No:`278` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for isBadVersion() 10 | * 11 | * @param {integer} version number 12 | * @return {boolean} whether the version is bad 13 | * isBadVersion = function(version) { 14 | * ... 15 | * }; 16 | */ 17 | 18 | /** 19 | * @param {function} isBadVersion() 20 | * @return {function} 21 | */ 22 | var solution = function(isBadVersion) { 23 | /** 24 | * @param {integer} n Total versions 25 | * @return {integer} The first bad version 26 | */ 27 | return function(n) { 28 | var start = 1; 29 | var end = n; 30 | var middle; 31 | while (start <= end) { 32 | middle = start + Math.floor((end - start) / 2); 33 | if (middle + 1 <= n && !isBadVersion(middle) && isBadVersion(middle + 1)) { 34 | return middle + 1; 35 | } 36 | if (middle - 1 > 0 && !isBadVersion(middle - 1) && isBadVersion(middle)) { 37 | return middle 38 | } 39 | if (middle === 1 && isBadVersion(middle)) { 40 | return middle; 41 | } 42 | if (isBadVersion(middle)) { 43 | end = middle - 1; 44 | } else { 45 | start = middle + 1; 46 | } 47 | } 48 | return 'null'; 49 | }; 50 | }; 51 | ``` 52 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/First Unique Character in a String/README.md: -------------------------------------------------------------------------------- 1 | # [First Unique Character in a String](https://leetcode.com/problems/first-unique-character-in-a-string/) 2 | ###### No:`387` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {number} 10 | */ 11 | var firstUniqChar = function(s) { 12 | var map = {}; 13 | 14 | s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); 15 | 16 | for(var i = 0; i < s.length; i++) { 17 | if(map[s[i]] === 1) { 18 | return i; 19 | } 20 | } 21 | 22 | return -1; 23 | 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Fizz Buzz/README.md: -------------------------------------------------------------------------------- 1 | # [Fizz Buzz](https://leetcode.com/problems/fizz-buzz/) 2 | ###### No:`412` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {string[]} 10 | */ 11 | var fizzBuzz = function(n) { 12 | var ret = []; 13 | 14 | for (var i = 1; i <= n; i++) { 15 | if (i % 15 === 0) { 16 | ret.push('FizzBuzz'); 17 | } else if (i % 3 === 0) { 18 | ret.push('Fizz'); 19 | } else if (i % 5 === 0) { 20 | ret.push('Buzz'); 21 | } else { 22 | ret.push(i + ''); 23 | } 24 | } 25 | 26 | return ret; 27 | }; 28 | ``` 29 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Generate Parentheses/README.md: -------------------------------------------------------------------------------- 1 | # [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/) 2 | ###### No:`22` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {string[]} 10 | */ 11 | var generateParenthesis = function(n) { 12 | if(n === 0) { 13 | return []; 14 | } else if(n === 1){ 15 | return ['()']; 16 | } else { 17 | var parenthesis = generateParenthesis(n - 1); 18 | var retObj = {}; 19 | 20 | parenthesis.forEach(p => { 21 | for(var i = 0; i < p.length + 1; i++) { 22 | var charArr = p.split(''); 23 | 24 | charArr.splice(i, 0, '()'); 25 | retObj[charArr.join('')] = true; 26 | } 27 | }); 28 | 29 | return Object.keys(retObj); 30 | } 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Guess Number Higher or Lower/README.md: -------------------------------------------------------------------------------- 1 | # [Guess Number Higher or Lower](https://leetcode.com/problems/guess-number-higher-or-lower/#/description) 2 | ###### No:`374` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /* The guess API is defined in the parent class GuessGame. 9 | @param num, your guess 10 | @return -1 if my number is lower, 1 if my number is higher, otherwise return 0 11 | int guess(int num); */ 12 | 13 | public class Solution extends GuessGame { 14 | public int guessNumber(int n) { 15 | int start = 1; 16 | int end = n; 17 | int middle; 18 | 19 | while (start <= end) { 20 | middle = (end - start) / 2 + start; 21 | if (guess(middle) == 0) { 22 | return middle; 23 | } else if (guess(middle) > 0) { 24 | start = middle + 1; 25 | } else { 26 | end = middle - 1; 27 | } 28 | } 29 | return 0; 30 | } 31 | } 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Hamming Distance/README.md: -------------------------------------------------------------------------------- 1 | # [Hamming Distance](https://leetcode.com/problems/hamming-distance/#/description) 2 | ###### No:`461` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} x 10 | * @param {number} y 11 | * @return {number} 12 | */ 13 | 14 | // Number of 1 Bits 15 | var hammingWeight = function(n) { 16 | var ret = 0; 17 | for(var power = 32; power >= 0; power--) { 18 | var exponent = Math.pow(2, power); 19 | if (n >= exponent) { 20 | ret++; 21 | n -= exponent; 22 | } 23 | } 24 | return ret; 25 | }; 26 | 27 | var hammingDistance = function(x, y) { 28 | return hammingWeight(x ^ y); 29 | }; 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Happy Number/README.md: -------------------------------------------------------------------------------- 1 | # [Happy Number](https://leetcode.com/problems/happy-number/) 2 | ###### No:`202` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {boolean} 10 | */ 11 | 12 | var isHappy = function(n) { 13 | var nums = []; 14 | var ret = n; 15 | 16 | var squire = x => Math.pow(parseInt(x), 2); 17 | var add = (prev, cur) => prev + cur; 18 | while(ret !== 1) { 19 | if(nums.indexOf(ret) > -1) { 20 | return false; 21 | } else { 22 | nums.push(ret); 23 | } 24 | digits = ret.toString().split('').map(squire); 25 | ret = digits.reduce(add); 26 | } 27 | return true; 28 | } 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/House Robber/README.md: -------------------------------------------------------------------------------- 1 | # [House Robber](https://leetcode.com/problems/house-robber/) 2 | ###### No:`198` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number} 10 | */ 11 | var rob = function(nums) { 12 | if(nums.length === 0) { 13 | return 0; 14 | } 15 | if(nums.length === 1) { 16 | return nums[0]; 17 | } 18 | 19 | var max = {}; 20 | max[0] = nums[0]; 21 | max[1] = Math.max(nums[0], nums[1]); 22 | for(var i = 2; i < nums.length; i++) { 23 | max[i] = Math.max(max[i - 2] + nums[i], max[i -1]); 24 | } 25 | return max[nums.length - 1]; 26 | }; 27 | ``` 28 | 29 | ``` 30 | ### How to solve? 31 | ``` 32 | ##### Using DP. 33 | max[0] = nums[0]; 34 | max[1] = Math.max(nums[0], nums[1]); 35 | max[n] = Math.max(max[n] + max[n - 2], max[n -1]); 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Implement Queue using Stacks/README.md: -------------------------------------------------------------------------------- 1 | # [Implement Queue using Stacks](https://leetcode.com/problems/implement-queue-using-stacks/) 2 | ###### No:`232` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @constructor 9 | */ 10 | var Queue = function() { 11 | this.stack1 = []; 12 | this.stack2 =[]; 13 | }; 14 | 15 | /** 16 | * @param {number} x 17 | * @returns {void} 18 | */ 19 | Queue.prototype.push = function(x) { 20 | this.stack1.push(x); 21 | }; 22 | 23 | /** 24 | * @returns {void} 25 | */ 26 | Queue.prototype.pop = function() { 27 | if(this.stack2.length > 0) { 28 | return this.stack2.pop(); 29 | } 30 | if(this.stack1.length > 0) { 31 | while(this.stack1.length > 0) { 32 | this.stack2.push(this.stack1.pop()); 33 | } 34 | return this.stack2.pop(); 35 | } 36 | return null; 37 | }; 38 | 39 | /** 40 | * @returns {number} 41 | */ 42 | Queue.prototype.peek = function() { 43 | if(this.stack2.length > 0) { 44 | return this.stack2[this.stack2.length - 1]; 45 | } 46 | if(this.stack1.length > 0) { 47 | return this.stack1[0]; 48 | } 49 | return null; 50 | }; 51 | 52 | /** 53 | * @returns {boolean} 54 | */ 55 | Queue.prototype.empty = function() { 56 | return this.stack1.length === 0 && this.stack2.length === 0; 57 | }; 58 | ``` 59 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Implement strStr()/README.md: -------------------------------------------------------------------------------- 1 | # [Implement strStr()](https://leetcode.com/problems/implement-strstr) 2 | ###### No:`28` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} haystack 9 | * @param {string} needle 10 | * @return {number} 11 | */ 12 | 13 | var strStr = function(haystack, needle) { 14 | if (needle === '') return 0; 15 | for(var i = 0;; i++) { 16 | for(var j = 0;; j++) { 17 | if (j == needle.length) return i; 18 | if (i + j >= haystack.length) return -1; 19 | if (haystack[i + j] != needle[j]) break; 20 | } 21 | } 22 | return -1; 23 | }; 24 | 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Integer Break/README.md: -------------------------------------------------------------------------------- 1 | # [Integer Break](https://leetcode.com/problems/integer-break/) 2 | ###### No:`343` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {number} 10 | */ 11 | var integerBreak = function(n) { 12 | var maxArr = { 13 | 1: 1, 14 | 2: 1, 15 | }; 16 | var maxValue = null; 17 | var value = null; 18 | 19 | for(var i = 3; i <= n; i++) { 20 | maxValue = Number.MIN_SAFE_INTEGER; 21 | for(var j = 1; j <= i / 2; j++) { 22 | value = Math.max(j, maxArr[j]) * Math.max(i - j, maxArr[i - j]); 23 | if(value > maxValue) { 24 | maxValue = value; 25 | } 26 | } 27 | maxArr[i] = maxValue; 28 | } 29 | 30 | return maxArr[n]; 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Integer to Roman/README.md: -------------------------------------------------------------------------------- 1 | # [Integer to Roman](https://leetcode.com/problems/integer-to-roman/) 2 | ###### No:`12` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} num 9 | * @return {string} 10 | */ 11 | var intToRoman = function(num) { 12 | var M = ["", "M", "MM", "MMM"]; 13 | var C = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"]; 14 | var X = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"]; 15 | var I = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]; 16 | 17 | return [ 18 | M[parseInt(num / 1000)], 19 | C[parseInt((num % 1000) / 100)], 20 | X[parseInt((num % 100) / 10)], 21 | I[num % 10] 22 | ].join(''); 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Intersection of Two Arrays II/README.md: -------------------------------------------------------------------------------- 1 | # [Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) 2 | ###### No:`350` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums1 9 | * @param {number[]} nums2 10 | * @return {number[]} 11 | */ 12 | var intersect = function(nums1, nums2) { 13 | var map = {}; 14 | var ret = []; 15 | 16 | nums1.forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); 17 | 18 | nums2.forEach(i => { 19 | if(map[i] !== undefined && map[i] > 0) { 20 | ret.push(i); 21 | map[i]--; 22 | } 23 | }); 24 | 25 | return ret; 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Intersection of Two Arrays/README.md: -------------------------------------------------------------------------------- 1 | # [Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) 2 | ###### No:`349` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums1 9 | * @param {number[]} nums2 10 | * @return {number[]} 11 | */ 12 | 13 | var intersection = function (nums1, nums2) { 14 | var ret = []; 15 | for (var i = 0; i < nums1.length; i++) { 16 | for (var j = 0; j < nums2.length; j++) { 17 | if (nums1[i] == nums2[j] && ret.indexOf(nums1[i]) === -1) { 18 | ret.push(nums1[i]); 19 | break; 20 | } 21 | } 22 | } 23 | return ret; 24 | } 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Intersection of Two Linked Lists/README.md: -------------------------------------------------------------------------------- 1 | # [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/) 2 | ###### No:`160` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | 15 | /** 16 | * @param {ListNode} headA 17 | * @param {ListNode} headB 18 | * @return {ListNode} 19 | */ 20 | var getIntersectionNode = function(headA, headB) { 21 | if(headA === null || headB === null) { 22 | return null; 23 | } 24 | var pointA = headA; 25 | var pointB = headB; 26 | var i = 0; 27 | var j = 0; 28 | var k = 0; 29 | while(pointA.next !== null) { 30 | pointA = pointA.next; 31 | i++; 32 | } 33 | while(pointB.next !== null) { 34 | pointB = pointB.next; 35 | j++; 36 | } 37 | if(pointB != pointA) { 38 | return null; 39 | } 40 | pointA = headA; 41 | pointB = headB; 42 | 43 | if(i > j) { 44 | while(k < i - j){pointA = pointA.next;k++;} 45 | } else { 46 | while(k < j - i){pointB = pointB.next;k++;} 47 | } 48 | while(pointA != pointB) { 49 | pointA = pointA.next; 50 | pointB = pointB.next; 51 | } 52 | return pointA; 53 | }; 54 | ``` 55 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Invert Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree/) 2 | ###### No:`226` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {TreeNode} 17 | */ 18 | var invertTree = function(root) { 19 | if(root !== null) { 20 | var tmp; 21 | tmp = root.left; 22 | root.left = root.right; 23 | root.right = tmp; 24 | 25 | invertTree(root.left); 26 | invertTree(root.right); 27 | } 28 | return root; 29 | }; 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Island Perimeter/README.md: -------------------------------------------------------------------------------- 1 | # [Add Digits](https://leetcode.com/problems/island-perimeter/) 2 | ###### No:`463` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[][]} grid 9 | * @return {number} 10 | */ 11 | var islandPerimeter = function(grid) { 12 | var perimeter = 4 * grid.reduce((p, c) => p.concat(c)).reduce((p, c) => p + c); 13 | 14 | for(var i = 0; i < grid.length; i++) { 15 | for(var j = 0; j < grid[i].length; j++) { 16 | if(grid[i][j] === 1) { 17 | if(i + 1 < grid.length && grid[i+1][j] === 1) { 18 | perimeter -= 2 ; 19 | } 20 | if(j + 1 < grid[i].length && grid[i][j+1] === 1) { 21 | perimeter -= 2; 22 | } 23 | } 24 | } 25 | } 26 | 27 | return perimeter; 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Isomorphic Strings/README.md: -------------------------------------------------------------------------------- 1 | # [Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/#/description) 2 | ###### No:`205` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} s 10 | * @param {string} t 11 | * @return {boolean} 12 | */ 13 | var isIsomorphic = function(s, t) { 14 | if (s.length !== t.length) return false; 15 | 16 | var smap = {}; 17 | var tmap = {}; 18 | 19 | for (var i = 0; i < s.length; i++) { 20 | if (smap[s[i]] === undefined && tmap[t[i]] === undefined) { 21 | smap[s[i]] = t[i]; 22 | tmap[t[i]] = s[i]; 23 | } 24 | 25 | if (smap[s[i]] !== t[i] || tmap[t[i]] !== s[i] ){ 26 | return false; 27 | } 28 | } 29 | 30 | return true; 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/K-diff Pairs in an Array/README.md: -------------------------------------------------------------------------------- 1 | # [K-diff Pairs in an Array](https://leetcode.com/problems/k-diff-pairs-in-an-array/#/description) 2 | ###### No:`532` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @param {number} k 11 | * @return {number} 12 | */ 13 | var findPairs = function(nums, k) { 14 | if (k < 0 || nums.length === 0) return 0; 15 | var itemCountMap = {}; 16 | var count = 0; 17 | 18 | nums.forEach((item, index) => { 19 | itemCountMap[item] === undefined ? itemCountMap[item] = 1 : itemCountMap[item]++; 20 | }); 21 | 22 | if (k === 0) { 23 | for (var key in itemCountMap) { 24 | if (itemCountMap[key] >= 2) { 25 | count++; 26 | } 27 | } 28 | } else { 29 | for (var key in itemCountMap) { 30 | if (itemCountMap[parseInt(key)+ k] !== undefined) { 31 | count++; 32 | } 33 | } 34 | } 35 | 36 | return count; 37 | }; 38 | 39 | ``` 40 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Keyboard Row/README.md: -------------------------------------------------------------------------------- 1 | # [Keyboard Row](https://leetcode.com/problems/keyboard-row/#/description) 2 | ###### No:`500` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string[]} words 10 | * @return {string[]} 11 | */ 12 | var findWords = function(words) { 13 | return words.filter(function(str) { 14 | return /^([qwertyuiop]*|[asdfghjkl]*|[zxcvbnm]*)$/.test(str.toLowerCase()); 15 | }); 16 | }; 17 | ``` 18 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Largest Number/README.md: -------------------------------------------------------------------------------- 1 | # [Largest Number](https://leetcode.com/problems/largest-number/) 2 | ###### No:`179` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {string} 10 | */ 11 | var largestNumber = function(nums) { 12 | var retStr = nums.sort(function(num1, num2) { 13 | var arr1 = num1 + ''.split(); 14 | var arr2 = num2 + ''.split(); 15 | var len1 = arr1.length; 16 | var len2 = arr2.length; 17 | var a, b; 18 | 19 | for (var i = 0; i < len1 || i < len2; i++) { 20 | a = i >= arr1.length ? arr1[i % len1] : arr1[i]; 21 | b = i >= arr2.length ? arr2[i % len2] : arr2[i]; 22 | if (a != b) { 23 | return b - a; 24 | } 25 | } 26 | 27 | // [121,12] 12 > 121; [212,21] 212 > 21 28 | var isRise; 29 | var checkArr = len1 > len2 ? arr1 : arr2; 30 | for (var j = 0; j < checkArr.length - 1; j++) { 31 | if (checkArr[j] != checkArr[j + 1]) { 32 | if (checkArr[j] > checkArr[j + 1]) { 33 | isRise = false; 34 | break; 35 | } else { 36 | isRise = true; 37 | break; 38 | } 39 | } 40 | } 41 | if (isRise) { 42 | return len1 - len2; 43 | } else { 44 | return len2 - len1; 45 | } 46 | 47 | 48 | }).join(''); 49 | 50 | if (retStr[0] == '0') { 51 | return '0'; 52 | } else { 53 | return retStr; 54 | } 55 | }; 56 | ``` 57 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Length of Last Word/README.md: -------------------------------------------------------------------------------- 1 | # [Length of Last Word](https://leetcode.com/problems/length-of-last-word/#/description) 2 | ###### No:`58` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} s 10 | * @return {number} 11 | */ 12 | var lengthOfLastWord = function(s) { 13 | return s.trim().split(' ').pop().length; 14 | }; 15 | ``` 16 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Letter Combinations of a Phone Number/README.md: -------------------------------------------------------------------------------- 1 | # [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/) 2 | ###### No:`17` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} digits 9 | * @return {string[]} 10 | */ 11 | var letterCombinations = function(digits) { 12 | var map = { 13 | 2: ['a', 'b', 'c'], 14 | 3: ['d', 'e', 'f'], 15 | 4: ['g', 'h', 'i'], 16 | 5: ['j', 'k', 'l'], 17 | 6: ['m', 'n', 'o'], 18 | 7: ['p', 'q', 'r', 's'], 19 | 8: ['t', 'u', 'v'], 20 | 9: ['w', 'x', 'y', 'z'], 21 | }; 22 | 23 | if(digits.length === 0) { 24 | return []; 25 | } else if(digits.length === 1) { 26 | return map[digits]; 27 | } else { 28 | var front = map[digits.slice(0, 1)]; 29 | var back = letterCombinations(digits.slice(1)); 30 | var ret = []; 31 | 32 | front.forEach(f => { 33 | back.forEach(b => { 34 | ret.push(f + b); 35 | }); 36 | }); 37 | 38 | return ret; 39 | } 40 | }; 41 | ``` 42 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/License Key Formatting/README.md: -------------------------------------------------------------------------------- 1 | # [License Key Formatting](https://leetcode.com/problems/license-key-formatting/#/description) 2 | ###### No:`482` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} S 10 | * @param {number} K 11 | * @return {string} 12 | */ 13 | var format = function(chars, length, separator) { 14 | if (chars.length <= length) { 15 | return chars.join(''); 16 | } 17 | return format(chars.slice(0, chars.length - length), length, separator) + separator + chars.slice(-length).join(''); 18 | }; 19 | var licenseKeyFormatting = function(S, K) { 20 | var chars = S.split('').filter((char) => { 21 | return char !== '-'; 22 | }); 23 | 24 | return format(chars, K, '-').toUpperCase(); 25 | 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Linked List Cycle/README.md: -------------------------------------------------------------------------------- 1 | # [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/#/description) 2 | ###### No:`141` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for singly-linked list. 10 | * function ListNode(val) { 11 | * this.val = val; 12 | * this.next = null; 13 | * } 14 | */ 15 | 16 | /** 17 | * @param {ListNode} head 18 | * @return {boolean} 19 | */ 20 | var hasCycle = function(head) { 21 | if (head === null) {return false;} 22 | var fast = head; 23 | var slow = head; 24 | 25 | while(slow.next !== null && slow.next.next !== null) { 26 | fast = fast.next; 27 | slow = slow.next.next; 28 | if (slow === fast) return true; 29 | } 30 | 31 | return false; 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Linked List Random Node/README.md: -------------------------------------------------------------------------------- 1 | # [Linked List Random Node](https://leetcode.com/problems/linked-list-random-node/#/description) 2 | ###### No:`382` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```js 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param head The linked list's head. 16 | Note that the head is guaranteed to be not null, so it contains at least one node. 17 | * @param {ListNode} head 18 | */ 19 | var Solution = function(head) { 20 | this.head = head; 21 | }; 22 | 23 | /** 24 | * Returns a random node's value. 25 | * @return {number} 26 | */ 27 | Solution.prototype.getRandom = function() { 28 | var ret = this.head.val; 29 | var p = this.head.next; 30 | var i = 2; 31 | while (p !== null) { 32 | var random = Math.ceil(Math.random() * i); 33 | if (random === 1) { 34 | ret = p.val; 35 | } 36 | i++; 37 | p = p.next; 38 | } 39 | 40 | return ret; 41 | }; 42 | 43 | /** 44 | * Your Solution object will be instantiated and called as such: 45 | * var obj = Object.create(Solution).createNew(head) 46 | * var param_1 = obj.getRandom() 47 | */ 48 | ``` 49 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Longest Common Prefix/README.md: -------------------------------------------------------------------------------- 1 | # [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/#/description) 2 | ###### No:`14` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string[]} strs 10 | * @return {string} 11 | */ 12 | var longestCommonPrefix = function(strs) { 13 | if (strs.length === 0) return ''; 14 | if (strs.length === 0) return strs[1]; 15 | 16 | var ret = ''; 17 | var isBreak = false; 18 | var isCommon = true; 19 | var char; 20 | 21 | for (var j = 0; j < strs[0].length; j++) { 22 | char = strs[0][j]; 23 | 24 | for (var i = 1; i < strs.length; i++) { 25 | if (strs[i].length <= j || strs[i][j] !== char) { 26 | isBreak = true; 27 | break; 28 | } 29 | } 30 | if (isBreak) { 31 | break; 32 | } 33 | ret += strs[0][j]; 34 | } 35 | return ret; 36 | }; 37 | 38 | ``` 39 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Longest Palindrome/README.md: -------------------------------------------------------------------------------- 1 | # [Longest Palindrome](https://leetcode.com/problems/longest-palindrome/) 2 | ###### No:`409` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {number} 10 | */ 11 | var longestPalindrome = function(s) { 12 | var map = {}; 13 | var number = 0; 14 | var hasOdd = false; 15 | 16 | s.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); 17 | 18 | for(var i in map) { 19 | if(map[i] % 2 === 0) { 20 | number += map[i]; 21 | } else if(map[i] > 2) { 22 | number += map[i] - 1; 23 | hasOdd = true; 24 | } else { 25 | hasOdd = true; 26 | } 27 | } 28 | 29 | if(hasOdd) number++; 30 | 31 | return number; 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Lowest Common Ancestor of a Binary Search Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Lowest Common Ancestor of a Binary Search Tree](https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree) 2 | ###### No:`235` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @param {TreeNode} p 17 | * @param {TreeNode} q 18 | * @return {TreeNode} 19 | */ 20 | var lowestCommonAncestor = function(root, p, q) { 21 | var tmp; 22 | if(p > q) { 23 | tmp = p; 24 | p = q; 25 | q = tmp; 26 | } 27 | if(root.val >= p.val && root.val <= q.val) { 28 | return root; 29 | }else if(p.val < root.val & q.val < root.val) { 30 | return lowestCommonAncestor(root.left, p, q); 31 | } else if(p.val > root.val && q.val > root.val){ 32 | return lowestCommonAncestor(root.right, p, q); 33 | } 34 | 35 | }; 36 | ``` 37 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Majority Element/README.md: -------------------------------------------------------------------------------- 1 | # [Majority Element](https://leetcode.com/problems/majority-element/) 2 | ###### No:`169` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number} 10 | */ 11 | var majorityElement = function(nums) { 12 | var count = 1; 13 | var item = nums[0]; 14 | for(var i = 1; i < nums.length; i++) { 15 | if(count === 0) { 16 | count = 1; 17 | item = nums[i]; 18 | } else { 19 | if(nums[i] == item) { 20 | count++; 21 | } else { 22 | count--; 23 | } 24 | } 25 | } 26 | return item; 27 | }; 28 | ``` 29 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Max Consecutive Ones/README.md: -------------------------------------------------------------------------------- 1 | # [Max Consecutive Ones](https://leetcode.com/problems/max-consecutive-ones/#/description) 2 | ###### No:`485` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number} 11 | */ 12 | var findMaxConsecutiveOnes = function(nums) { 13 | var max = 0; 14 | var length = 0; 15 | nums.forEach(function(num) { 16 | if (num === 1) length++; 17 | if (num === 0) { 18 | if (length > max) max = length; 19 | length = 0; 20 | } 21 | }); 22 | if (length > max) max = length; 23 | return max; 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Max Points on a Line/README.md: -------------------------------------------------------------------------------- 1 | # [Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/) 2 | ###### No:`149` 3 | ###### Difficulty:`Hard` 4 | ## CPP 5 | 6 | ```cpp 7 | /** 8 | * Definition for a point. 9 | * struct Point { 10 | * int x; 11 | * int y; 12 | * Point() : x(0), y(0) {} 13 | * Point(int a, int b) : x(a), y(b) {} 14 | * }; 15 | */ 16 | class Solution { 17 | public: 18 | int maxPoints(vector &points) { 19 | if(points.size() < 3) { 20 | return points.size(); 21 | } 22 | int maxPoints = 0; //the max point in line 23 | int size = points.size(); 24 | map count; 25 | map::iterator iter; 26 | for(int i = 0; i < size; i++ ) { 27 | int x1 = points[i].x; 28 | int y1 = points[i].y; 29 | int coincideCount = 0; //number of duplicate points 30 | count.clear(); 31 | count[(double)INT_MIN] = 0; 32 | for(int j = i + 1; j < size; j++) { 33 | int x2 = points[j].x; 34 | int y2 = points[j].y; 35 | if(x1 == x2 && y1 == y2) { 36 | coincideCount++; 37 | } else if(x1 == x2){ 38 | count[(double)INT_MIN]++; 39 | } else { 40 | double slope = 1.0*(y1-y2)/(x1-x2); 41 | count[slope]++; 42 | } 43 | } 44 | for(iter = count.begin(); iter != count.end(); iter++) { 45 | if(iter->second + coincideCount > maxPoints) { 46 | maxPoints = iter->second + coincideCount; 47 | } 48 | } 49 | } 50 | maxPoints = maxPoints + 1; 51 | return maxPoints; 52 | } 53 | }; 54 | ``` 55 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Maximum Depth of Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/) 2 | ###### No:`104` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number} 17 | */ 18 | var maxDepth = function(root) { 19 | if(root == null) { 20 | return 0; 21 | } else { 22 | return Math.max(maxDepth(root.left), maxDepth(root.right)) +1; 23 | } 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Maximum Subarray/README.md: -------------------------------------------------------------------------------- 1 | # [Maximum Subarray](https://leetcode.com/problems/maximum-subarray/#/description) 2 | ###### No:`53` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number} 11 | */ 12 | // https://discuss.leetcode.com/topic/6413/dp-solution-some-thoughts 13 | var maxSubArray = function(nums) { 14 | var max = nums[0]; 15 | var dp = {}; 16 | dp[0] = nums[0]; 17 | 18 | for (var i = 1; i < nums.length; i++) { 19 | dp[i] = dp[i - 1] > 0 ? dp[i - 1] + nums[i] : nums[i]; 20 | max = Math.max(max, dp[i]); 21 | } 22 | 23 | return max; 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Merge Sorted Array/README.md: -------------------------------------------------------------------------------- 1 | # [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/) 2 | ###### No:`88` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums1 9 | * @param {number} m 10 | * @param {number[]} nums2 11 | * @param {number} n 12 | * @return {void} Do not return anything, modify nums1 in-place instead. 13 | */ 14 | var merge = function(nums1, m, nums2, n) { 15 | while(n > 0) { 16 | if(m <= 0 || nums1[m - 1] <= nums2[n -1]) { 17 | nums1[m + n - 1] = nums2[n - 1]; 18 | n--; 19 | } else { 20 | nums1[m + n - 1] = nums1[m - 1]; 21 | m--; 22 | } 23 | } 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Merge Two Sorted Lists/README.md: -------------------------------------------------------------------------------- 1 | # [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/) 2 | ###### No:`21` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} l1 16 | * @param {ListNode} l2 17 | * @return {ListNode} 18 | */ 19 | var mergeTwoLists = function(l1, l2) { 20 | if(!l1) return l2; 21 | if(!l2) return l1; 22 | var head = null 23 | if(l1.val < l2.val) { 24 | head = l1; 25 | l1 = l1.next; 26 | } else { 27 | head = l2; 28 | l2 = l2.next; 29 | } 30 | 31 | var newlist = head; 32 | 33 | while(l1 && l2) { 34 | if(l1.val < l2.val) { 35 | newlist.next = l1; 36 | l1 = l1.next; 37 | } else { 38 | newlist.next = l2; 39 | l2 = l2.next; 40 | } 41 | newlist = newlist.next; 42 | } 43 | if(!l1) { 44 | newlist.next = l2; 45 | } else { 46 | newlist.next = l1; 47 | } 48 | 49 | return head; 50 | }; 51 | ``` 52 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Min Stack/README.md: -------------------------------------------------------------------------------- 1 | # [Min Stack](https://leetcode.com/problems/min-stack/) 2 | ###### No:`155` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @constructor 9 | */ 10 | var MinStack = function() { 11 | this.stack = []; 12 | this.min = Number.MAX_SAFE_INTEGER; 13 | }; 14 | 15 | /** 16 | * @param {number} x 17 | * @returns {void} 18 | */ 19 | MinStack.prototype.push = function(x) { 20 | if(x < this.min) { 21 | this.min = x; 22 | } 23 | this.stack.push(x); 24 | }; 25 | 26 | /** 27 | * @returns {void} 28 | */ 29 | MinStack.prototype.pop = function() { 30 | var number = this.stack.pop(); 31 | if(number == this.min) { 32 | this.min = Math.min.apply(null, this.stack); 33 | } 34 | }; 35 | 36 | /** 37 | * @returns {number} 38 | */ 39 | MinStack.prototype.top = function() { 40 | if(this.stack.length > 0) { 41 | return this.stack[this.stack.length - 1]; 42 | } else { 43 | return undefined; 44 | } 45 | }; 46 | 47 | /** 48 | * @returns {number} 49 | */ 50 | MinStack.prototype.getMin = function() { 51 | return this.min; 52 | }; 53 | ``` 54 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Minesweeper/README.md: -------------------------------------------------------------------------------- 1 | # [Minesweeper](https://leetcode.com/problems/minesweeper/#/description) 2 | ###### No:`529` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {character[][]} board 10 | * @param {number[]} click 11 | * @return {character[][]} 12 | */ 13 | var getMineCount = function(board, point) { 14 | var m = board.length; 15 | var n = board[0].length; 16 | var x = point[0]; 17 | var y = point[1]; 18 | var count = 0; 19 | for (var i = -1; i < 2; i++) { 20 | for (var j = -1; j < 2; j++) { 21 | var p = x + i; 22 | var q = y + j; 23 | if (p < 0 || p >= m || q < 0 || q >= n) continue; 24 | if (board[p][q] === 'M' || board[p][q] === 'X') count++; 25 | } 26 | } 27 | return count; 28 | }; 29 | 30 | var updateBoard = function(board, click) { 31 | var m = board.length; 32 | var n = board[0].length; 33 | var visited = []; 34 | for (var k = 0; k < m; k++) visited.push(new Array(n).fill(false)); 35 | 36 | var queue = []; 37 | queue.push(click); 38 | 39 | while(queue.length > 0) { 40 | var point = queue.shift(); 41 | var x = point[0]; 42 | var y = point[1]; 43 | 44 | if (visited[x][y]) { 45 | continue; 46 | } else { 47 | visited[x][y] = true; 48 | } 49 | 50 | if (board[x][y] === 'M') { 51 | board[x][y] = 'X'; 52 | } else { 53 | var count = getMineCount(board, point); 54 | 55 | if (count === 0) { 56 | board[x][y] = 'B'; 57 | for (var i = -1; i < 2; i++) { 58 | for (var j = -1; j < 2; j++) { 59 | var p = x + i; 60 | var q = y + j; 61 | if (p < 0 || p >= m || q < 0 || q >= n || (p === x && q === y)) continue; 62 | if (board[p][q] === 'E'){ 63 | queue.push([p, q]); 64 | } 65 | } 66 | } 67 | } else { 68 | board[x][y] = count + ''; 69 | } 70 | } 71 | } 72 | 73 | return board; 74 | }; 75 | 76 | ``` 77 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Minimum Absolute Difference in BST/README.md: -------------------------------------------------------------------------------- 1 | # [Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/#/description) 2 | ###### No:`530` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number} 18 | */ 19 | 20 | var getMinimumDifference = function(root) { 21 | var prev = null; 22 | var min = Number.MAX_VALUE; 23 | var traversal = function(root) { 24 | if (root === null) return; 25 | traversal(root.left); 26 | if (prev !== null && root.val - prev < min) { 27 | min = root.val - prev; 28 | } 29 | prev = root.val; 30 | traversal(root.right); 31 | }; 32 | traversal(root); 33 | 34 | return min; 35 | }; 36 | ``` 37 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Minimum Depth of Binary Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/) 2 | ###### No:`111` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number} 17 | */ 18 | var minDepth = function(root) { 19 | if(root === null) { 20 | return 0; 21 | } 22 | var leftDepth = minDepth(root.left); 23 | var rightDepth = minDepth(root.right); 24 | 25 | /* 26 | * As a shot, the follow can be write: 27 | * return (leftDepth == 0 || rightDepth == 0) ? leftDepth + rightDepth + 1: Math.min(leftDepth,rightDepth) + 1; 28 | */ 29 | if(leftDepth !== 0 && rightDepth !== 0) { 30 | return Math.min(leftDepth, rightDepth) + 1; 31 | } else if(leftDepth === 0) { 32 | return rightDepth + 1; 33 | } else { 34 | return leftDepth + 1; 35 | } 36 | }; 37 | ``` 38 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Minimum Moves to Equal Array Elements/README.md: -------------------------------------------------------------------------------- 1 | # [Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/#/description) 2 | ###### No:`453` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number} 11 | */ 12 | var minMoves = function(nums) { 13 | var min = Math.min.apply(null, nums) 14 | 15 | return nums.reduce((p, c) => p + c - min, 0); 16 | }; 17 | ``` 18 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Missing Number/README.md: -------------------------------------------------------------------------------- 1 | # [Missing Number](https://leetcode.com/problems/missing-number/) 2 | ###### No:`268` 3 | ###### Difficulty:`Medium` 4 | 5 | #### Solution 1 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number} 10 | */ 11 | var missingNumber = function(nums) { 12 | return (0 + nums.length) * (nums.length + 1) / 2 - nums.reduce((p, c) => p + c, 0); 13 | }; 14 | ``` 15 | 16 | #### Solution 2 17 | Any number XOR itself will be 0. 18 | e.g.[0,1,3] 19 | ret = （0 ^ 1 ^ 3） ^ (0 ^ 1 ^ 2 ^ 3) // will get 2 20 | ```js 21 | /** 22 | * @param {number[]} nums 23 | * @return {number} 24 | */ 25 | var missingNumber = function(nums) { 26 | return nums.reduce((p, c, i) => p ^ c ^ i, 0) ^ nums.length; 27 | }; 28 | ``` 29 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Most Frequent Subtree Sum/README.md: -------------------------------------------------------------------------------- 1 | # [Most Frequent Subtree Sum](https://leetcode.com/problems/most-frequent-subtree-sum/#/description) 2 | ###### No:`508` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {number[]} 18 | */ 19 | function getSum (root, map) { 20 | if (root === null) return 0; 21 | var left = getSum(root.left, map); 22 | var right = getSum(root.right, map); 23 | var sum = root.val + left + right; 24 | 25 | map[sum] === undefined ? map[sum] = 1 : map[sum]++; 26 | return sum; 27 | } 28 | var findFrequentTreeSum = function(root) { 29 | if (root === null) return []; 30 | var valueCountMap = {}; 31 | var max = -1; 32 | var ret = []; 33 | var key; 34 | 35 | getSum(root, valueCountMap); 36 | for (key in valueCountMap) { 37 | if (valueCountMap[key] > max) { 38 | max = valueCountMap[key]; 39 | } 40 | } 41 | 42 | for (key in valueCountMap) { 43 | if (valueCountMap[key] === max) { 44 | ret.push(parseInt(key)); 45 | } 46 | } 47 | 48 | return ret; 49 | }; 50 | ``` 51 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Move Zeroes/README.md: -------------------------------------------------------------------------------- 1 | # [Move Zeroes](https://leetcode.com/problems/move-zeroes/) 2 | ###### No:`283` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {void} Do not return anything, modify nums in-place instead. 10 | */ 11 | var moveZeroes = function(nums) { 12 | var sum = 0; 13 | for(var i = nums.length - 1; i >=0; i--) { 14 | if(nums[i] === 0) { 15 | nums.splice(i,1); 16 | sum++; 17 | } 18 | } 19 | [].push.apply(nums, new Array(sum).fill(0)) 20 | }; 21 | ``` 22 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Next Greater Element I/README.md: -------------------------------------------------------------------------------- 1 | # [Next Greater Element I](https://leetcode.com/problems/next-greater-element-i/#/description) 2 | ###### No:`496` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} findNums 10 | * @param {number[]} nums 11 | * @return {number[]} 12 | */ 13 | var nextGreaterElement = function(findNums, nums) { 14 | var map = {}; 15 | var stack = []; 16 | nums.forEach(function(num) { 17 | while(stack.length > 0 && stack[stack.length - 1] < num) { 18 | map[stack.pop()] = num; 19 | } 20 | stack.push(num); 21 | }); 22 | 23 | return findNums.map(function(num) { 24 | return map[num] || -1; 25 | }); 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Next Greater Element II/README.md: -------------------------------------------------------------------------------- 1 | # [Next Greater Element II](https://leetcode.com/problems/next-greater-element-ii/#/description) 2 | ###### No:`503` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number[]} 11 | */ 12 | var nextGreaterElements = function(nums) { 13 | var nextGreaterMap = {}; 14 | var stack = []; 15 | nums.concat(nums).forEach((item) => { 16 | while (stack.length > 0 && stack[stack.length - 1] < item) { 17 | var key = stack.pop(); 18 | if (nextGreaterMap[key] === undefined) { 19 | nextGreaterMap[key] = []; 20 | } 21 | nextGreaterMap[key].push(item); 22 | } 23 | stack.push(item); 24 | }); 25 | 26 | return nums.map((item) => { 27 | if (nextGreaterMap[item] && nextGreaterMap[item].length > 0) { 28 | return nextGreaterMap[item].shift(); 29 | } else { 30 | return -1; 31 | } 32 | }); 33 | }; 34 | 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Next Permutation/README.md: -------------------------------------------------------------------------------- 1 | # [Next Permutation](https://leetcode.com/problems/next-permutation/#/description) 2 | ###### No:`31` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | var nextPermutation = function(nums) { 9 | if (nums.length <= 1) { 10 | return; 11 | } 12 | 13 | var i = nums.length - 2; 14 | var j = nums.length - 1; 15 | while (nums[i] >= nums[i + 1] && i > -1) { 16 | i--; 17 | } 18 | if (i >= 0) { 19 | while (nums[j] <= nums[i]) { 20 | j--; 21 | } 22 | 23 | var temp; 24 | temp = nums[i]; 25 | nums[i] = nums[j]; 26 | nums[j] = temp; 27 | } 28 | 29 | var start = i + 1; 30 | var end = nums.length - 1; 31 | 32 | while (start < end) { 33 | temp = nums[start]; 34 | nums[start] = nums[end]; 35 | nums[end] = temp; 36 | start++; 37 | end--; 38 | } 39 | 40 | }; 41 | ``` 42 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Nim Game/README.md: -------------------------------------------------------------------------------- 1 | # [Nim Game](https://leetcode.com/problems/nim-game/) 2 | ###### No:`292` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {boolean} 10 | */ 11 | var canWinNim = function(n) { 12 | return !(n !== 0 && n%4 === 0); 13 | }; 14 | ``` 15 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Nth Digit/README.md: -------------------------------------------------------------------------------- 1 | # [Nth Digit](https://leetcode.com/problems/nth-digit/#/description) 2 | ###### No:`400` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} n 10 | * @return {number} 11 | */ 12 | var findNthDigit = function(n) { 13 | var length = 1; 14 | var count = 9; 15 | var digits = 9; 16 | 17 | while (n > digits) { 18 | length++; 19 | count *= 10; 20 | digits += length * count; 21 | } 22 | n = n - (digits - length * count); 23 | 24 | var position = Math.ceil(n / length); 25 | var number = Math.pow(10, (length - 1)) + position - 1; 26 | 27 | if (n % length === 0) { 28 | return number % 10; 29 | } else { 30 | return parseInt(String(number)[n % length - 1]); 31 | } 32 | }; 33 | 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Number Complement/README.md: -------------------------------------------------------------------------------- 1 | # [Number Complement](https://leetcode.com/problems/number-complement/#/description) 2 | ###### No:`476` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} num 10 | * @return {number} 11 | 12 | 这道题给了我们一个数，让我们求补数。通过分析题目汇总的例子，我们知道需要做的就是每个位翻转一下就行了，但是翻转的起始位置上从最高位的1开始的，前面的0是不能被翻转的，所以我们从高往低遍历，如果遇到第一个1了后，我们的flag就赋值为true，然后就可以进行翻转了，翻转的方法就是对应位异或一个1即可，参见代码如下： 13 | 14 | 15 | 16 | 解法一： 17 | 18 | 复制代码 19 | class Solution { 20 | public: 21 | int findComplement(int num) { 22 | bool start = false; 23 | for (int i = 31; i >= 0; --i) { 24 | if (num & (1 << i)) start = true; 25 | if (start) num ^= (1 << i); 26 | } 27 | return num; 28 | } 29 | }; 30 | 复制代码 31 | 32 | 33 | 由于位操作里面的取反符号～本身就可以翻转位，但是如果直接对num取反的话就是每一位都翻转了，而最高位1之前的0是不能翻转的，所以我们只要用一个mask来标记最高位1前面的所有0的位置，然后对mask取反后，与上对num取反的结果即可，参见代码如下： 34 | 35 | 36 | 37 | 解法二： 38 | 39 | 复制代码 40 | class Solution { 41 | public: 42 | int findComplement(int num) { 43 | int mask = INT_MAX; 44 | while (mask & num) mask <<= 1; 45 | return ~mask & ~num; 46 | } 47 | }; 48 | 复制代码 49 | 50 | 51 | 再来看一种迭代的写法，一行搞定碉堡了，思路就是每次都右移一位，并根据最低位的值先进行翻转，如果当前值小于等于1了，就不用再调用递归函数了，参见代码如下： 52 | 53 | 54 | 55 | 解法三： 56 | 57 | class Solution { 58 | public: 59 | int findComplement(int num) { 60 | return (1 - num % 2) + 2 * (num <= 1 ? 0 : findComplement(num / 2)); 61 | } 62 | }; 63 | 64 | */ 65 | 66 | var findComplement = function(num) { 67 | var mask = ~0; 68 | while (mask & num) mask <<= 1; 69 | return ~mask & ~num; 70 | }; 71 | ``` 72 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Number of 1 Bits/README.md: -------------------------------------------------------------------------------- 1 | # [Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/) 2 | ###### No:`191` 3 | ###### Difficulty:`Easy` 4 | #### Solution 1 5 | ```js 6 | /** 7 | * @param {number} n - a positive integer 8 | * @return {number} 9 | */ 10 | var hammingWeight = function(n) { 11 | var count = 0; 12 | while (n) { 13 | n = n & (n - 1); 14 | count++; 15 | } 16 | 17 | return count; 18 | }; 19 | ``` 20 | #### Solution 2 21 | ```javascript 22 | /** 23 | * @param {number} n - a positive integer 24 | * @return {number} 25 | */ 26 | var hammingWeight = function(n) { 27 | var ret = 0; 28 | const base = 2; 29 | const bitnum = 32; 30 | var power = bitnum -1; 31 | 32 | for(var i = 0; i < bitnum; i++) { 33 | if(n >= Math.pow(base, power)) { 34 | ret++; 35 | n -= Math.pow(base, power); 36 | } 37 | power--; 38 | } 39 | 40 | return ret; 41 | }; 42 | 43 | ``` 44 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Number of Boomerangs/README.md: -------------------------------------------------------------------------------- 1 | # [Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs/) 2 | ###### No:`447` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ### Solution: 7 | 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). 8 | 9 | ```javascript 10 | /** 11 | * @param {number[][]} points 12 | * @return {number} 13 | */ 14 | 15 | var getDistance = function(a, b) { 16 | var dx = a[0] - b[0]; 17 | var dy = a[1] - b[1]; 18 | 19 | return dx * dx + dy * dy; 20 | } 21 | 22 | var numberOfBoomerangs = function(points) { 23 | var map; 24 | var distance; 25 | var ret = 0; 26 | 27 | for(var i = 0; i < points.length; i++) { 28 | map = {}; 29 | for(var j = 0; j < points.length; j++) { 30 | if(i !== j) { 31 | distance = getDistance(points[i], points[j]); 32 | map[distance] === undefined ? map[distance] = 1 : map[distance] += 1; 33 | } 34 | } 35 | 36 | for(var d in map) { 37 | ret += map[d] * (map[d] - 1); 38 | } 39 | } 40 | 41 | return ret; 42 | }; 43 | ``` 44 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Number of Segments in a String/README.md: -------------------------------------------------------------------------------- 1 | # [Number of Segments in a String](https://leetcode.com/problems/number-of-segments-in-a-string/#/description) 2 | ###### No:`434` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} s 10 | * @return {number} 11 | */ 12 | /* 13 | var countSegments = function(s) { 14 | return s.split(' ').filter((item) => item !== '').length; 15 | }; 16 | */ 17 | 18 | var countSegments = function(s) { 19 | var count = 0; 20 | for (var i = 0; i < s.length; i++) { 21 | if (s[i] !== ' ' && (i === 0 || s[i - 1] === ' ')) count++; 22 | } 23 | 24 | return count; 25 | }; 26 | ``` 27 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Odd Even Linked List/README.md: -------------------------------------------------------------------------------- 1 | # [Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) 2 | ###### No:`328` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {ListNode} 17 | */ 18 | var oddEvenList = function(head) { 19 | if(head === null) { 20 | return null; 21 | } 22 | var second = head.next; 23 | 24 | var odd = head; 25 | var even = head.next; 26 | while(odd && odd.next && odd.next.next) { 27 | odd.next = even.next; 28 | odd = odd.next; 29 | if(odd) { 30 | even.next = odd.next; 31 | even = even.next; 32 | } 33 | } 34 | odd.next = second; 35 | return head; 36 | }; 37 | ``` 38 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Output Contest Matches/README.md: -------------------------------------------------------------------------------- 1 | # [Output Contest Matches](https://leetcode.com/problems/output-contest-matches/) 2 | ###### No:`544` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ### LeetCode Weekly Contest 24 7 | ### 544. Output Contest Matches 8 | 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. 9 | 10 | 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. 11 | 12 | #### Example 13 | ``` 14 | Input: 2 15 | Output: (1,2) 16 | Input: 4 17 | Output: ((1,4),(2,3)) 18 | Input: 8 19 | Output: (((1,8),(4,5)),((2,7),(3,6))) 20 | ``` 21 | 22 | #### Solution 23 | ```js 24 | /** 25 | * @param {number} n 26 | * @return {string} 27 | */ 28 | function getMatch (match) { 29 | if (match.length === 1) return match; 30 | var ret = []; 31 | var start = 0; 32 | var end = match.length - 1; 33 | var value; 34 | 35 | while (start < end) { 36 | value = `(${match[start]},${match[end]})`; 37 | ret.push(value); 38 | start++; 39 | end--; 40 | } 41 | 42 | return getMatch(ret); 43 | } 44 | var findContestMatch = function(n) { 45 | var match = []; 46 | for (var i = 1; i <= n; i++) match.push(i); 47 | 48 | return getMatch(match)[0]; 49 | }; 50 | ``` 51 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Palindrome Linked List/README.md: -------------------------------------------------------------------------------- 1 | # [Palindrome Linked List](https://leetcode.com/problems/palindrome-linked-list/) 2 | ###### No:`234` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {boolean} 17 | */ 18 | var isPalindrome = function(head) { 19 | function reverseList(head) { 20 | if(!head) { 21 | return head; 22 | } 23 | var prev = null; 24 | var next = null; 25 | while(head) { 26 | next = head.next; 27 | head.next = prev; 28 | prev = head; 29 | head = next; 30 | } 31 | return prev; 32 | } 33 | if(!head || !head.next ) { 34 | return true; 35 | } 36 | var slow = head; 37 | var fast = head; 38 | while(fast && fast.next && fast.next.next) { 39 | slow = slow.next; 40 | fast = fast.next.next; 41 | } 42 | 43 | slow.next = reverseList(slow.next); 44 | slow = slow.next; 45 | 46 | while(slow) { 47 | if(head.val !== slow.val) { 48 | return false; 49 | } 50 | head = head.next; 51 | slow = slow.next; 52 | } 53 | 54 | return true; 55 | }; 56 | ``` 57 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Palindrome Number/README.md: -------------------------------------------------------------------------------- 1 | # [Palindrome Number](https://leetcode.com/problems/palindrome-number/) 2 | ###### No:`9` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} x 9 | * @return {boolean} 10 | */ 11 | var isPalindrome = function(x) { 12 | x += ''; 13 | var i = 0; 14 | var j = x.length - 1; 15 | while(i < j) { 16 | if(x[i] != x[j]) { 17 | return false 18 | } 19 | i++; 20 | j--; 21 | } 22 | return true; 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Pascal's Triangle II/README.md: -------------------------------------------------------------------------------- 1 | # [Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/) 2 | ###### No:`119` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} rowIndex 9 | * @return {number[]} 10 | */ 11 | var getRow = function(rowIndex) { 12 | var ret = []; 13 | ret[0] = 1; 14 | for(var i = 1; i <= rowIndex; i++ ) { 15 | ret[i] = 1; 16 | for(j = i - 1; j > 0; j--) { 17 | ret[j] = ret[j] + ret[j - 1]; 18 | } 19 | } 20 | return ret; 21 | }; 22 | ``` 23 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Pascal's Triangle/README.md: -------------------------------------------------------------------------------- 1 | # [Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/) 2 | ###### No:`118` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} numRows 9 | * @return {number[][]} 10 | */ 11 | var generate = function(numRows) { 12 | if(numRows === 0) { 13 | return []; 14 | } 15 | if(numRows === 1) { 16 | return [[1]]; 17 | } 18 | 19 | var ret = [[1]]; 20 | for(var i = 1; i < numRows; i++) { 21 | ret.push([]); 22 | for(var j = 0; j < ret[i - 1].length - 1; j++) { 23 | ret[i].push(ret[i-1][j] + ret[i-1][j + 1]); 24 | } 25 | ret[i].unshift(1); 26 | ret[i].push(1); 27 | } 28 | return ret; 29 | }; 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Path Sum III/README.md: -------------------------------------------------------------------------------- 1 | # [Path Sum III](https://leetcode.com/problems/path-sum-iii/#/description) 2 | ###### No:`437` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @param {number} sum 18 | * @return {number} 19 | */ 20 | var traversal = function(root, list, sum, cb) { 21 | if (root === null) return; 22 | cb(list, root.val); 23 | var newList = list.map((item) => item - root.val).concat(sum); 24 | 25 | traversal(root.left, newList, sum, cb); 26 | traversal(root.right, newList, sum, cb); 27 | }; 28 | var pathSum = function(root, sum) { 29 | var count = 0; 30 | var cb = function (list, val) { 31 | list.forEach((item) => { 32 | if (item === val) { 33 | count++; 34 | } 35 | }); 36 | } 37 | 38 | traversal(root, [sum], sum, cb); 39 | return count; 40 | }; 41 | 42 | ``` 43 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Path Sum/README.md: -------------------------------------------------------------------------------- 1 | # [Path Sum](https://leetcode.com/problems/path-sum/) 2 | ###### No:`112` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @param {number} sum 17 | * @return {boolean} 18 | */ 19 | var hasPathSum = function(root, sum) { 20 | if(root == null) { 21 | return false; 22 | } 23 | if(root.left == null && root.right == null && sum == root.val) { 24 | return true; 25 | } 26 | if(hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val)) { 27 | return true; 28 | } else { 29 | return false; 30 | } 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Permutations/README.md: -------------------------------------------------------------------------------- 1 | # [Permutations](https://leetcode.com/problems/permutations/) 2 | ###### No:`46` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number[][]} 10 | */ 11 | var permute = function(nums) { 12 | var ret = []; 13 | if(nums.length == 1) { 14 | ret.push(nums); 15 | return ret; 16 | } 17 | 18 | var item, item_copy; 19 | var head = nums.shift(); 20 | var pre_ret = permute(nums); 21 | 22 | for(var i = 0; i < pre_ret.length; i++ ) { 23 | item = pre_ret[i]; 24 | for(var j = 0; j <= item.length; j++) { 25 | item_copy = [].slice.call(item); 26 | item_copy.splice(j, 0, head); 27 | ret.push(item_copy); 28 | } 29 | } 30 | return ret; 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Plus One/README.md: -------------------------------------------------------------------------------- 1 | # [Plus One](https://leetcode.com/problems/plus-one/) 2 | ###### No:`66` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} digits 9 | * @return {number[]} 10 | */ 11 | var plusOne = function(digits) { 12 | digits.unshift(0); 13 | var tail = digits.length - 1; 14 | digits[tail]++; 15 | while(tail > 0) { 16 | if(digits[tail] == 10) { 17 | digits[tail] = 0; 18 | tail--; 19 | digits[tail]++; 20 | } else { 21 | tail--; 22 | } 23 | } 24 | if(digits[0] == 0) { 25 | digits.shift(); 26 | } 27 | return digits; 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Power of Four/README.md: -------------------------------------------------------------------------------- 1 | # [Power of Four](https://leetcode.com/problems/power-of-four/#/description) 2 | ###### No:`342` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | var isPowerOfFour = function(num) { 9 | if (num < 1) { 10 | return false; 11 | } else if (num === 1) { 12 | return true; 13 | } else if (num % 4 !== 0) { 14 | return false; 15 | } else { 16 | return isPowerOfFour(num / 4); 17 | } 18 | }; 19 | ``` 20 | ```js 21 | var isPowerOfFour = function(num) { 22 | return num > 0 && (num & (num - 1)) === 0 && (num & 0x55555555) !== 0; 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Power of Three/README.md: -------------------------------------------------------------------------------- 1 | # [Power of Three](https://leetcode.com/problems/power-of-three/) 2 | ###### No:`326` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {boolean} 10 | */ 11 | var isPowerOfThree = function(n) { 12 | while(true) { 13 | if(n === 1) { 14 | return true; 15 | } 16 | if(n === 0 || n === 2) { 17 | return false; 18 | } 19 | if(n % 3 !== 0) { 20 | return false; 21 | } else { 22 | n = n / 3; 23 | } 24 | } 25 | return true; 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Power of Two/README.md: -------------------------------------------------------------------------------- 1 | # [Power of Two](https://leetcode.com/problems/power-of-two/) 2 | ###### No:`231` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} n 9 | * @return {boolean} 10 | */ 11 | var isPowerOfTwo = function(n) { 12 | if(n === 0) return false; 13 | while(n !== 1) { 14 | if(n % 2 === 0) { 15 | n = n / 2; 16 | } else { 17 | return false; 18 | } 19 | } 20 | return true; 21 | }; 22 | ``` 23 | 24 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Product of Array Except Self/README.md: -------------------------------------------------------------------------------- 1 | # [Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/) 2 | ###### No:`238` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number[]} 10 | */ 11 | var productExceptSelf = function(nums) { 12 | var zeroCount = 0; 13 | var products = nums 14 | .filter((num) => { 15 | if(num === 0) zeroCount++; 16 | return num !== 0; 17 | }) 18 | .reduce((prev, curr) => prev * curr, 1); 19 | return nums.map((num) => { 20 | if(zeroCount >= 2) { 21 | return 0; 22 | } 23 | if(zeroCount === 1) { 24 | return num === 0 ? products : 0; 25 | } 26 | return products / num; 27 | 28 | }); 29 | }; 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Queue Reconstruction by Height/README.md: -------------------------------------------------------------------------------- 1 | # [Queue Reconstruction by Height](https://leetcode.com/problems/queue-reconstruction-by-height/#/description) 2 | ###### No:`406` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[][]} people 10 | * @return {number[][]} 11 | */ 12 | var reconstructQueue = function(people) { 13 | if (people.length <= 1) return people; 14 | people.sort((a, b) => { 15 | if (a[0] !== b[0]) { 16 | return b[0] - a[0]; 17 | } else { 18 | return a[1] - b[1]; 19 | } 20 | }); 21 | 22 | var ret = []; 23 | ret.push(people[0]); 24 | 25 | for (var i = 1; i < people.length; i++) { 26 | if (people[i][0] === people[0][0]) { 27 | ret.push(people[i]); 28 | continue; 29 | } 30 | 31 | var count = 0, index = 0; 32 | while (count < people[i][1]) { 33 | if (ret[index][0] >= people[i][0]) count++; 34 | index++; 35 | } 36 | ret.splice(index, 0, people[i]); 37 | } 38 | 39 | return ret; 40 | }; 41 | ``` 42 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Ransom Note/README.md: -------------------------------------------------------------------------------- 1 | # [Ransom Note](https://leetcode.com/problems/ransom-note/) 2 | ###### No:`383` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} ransomNote 9 | * @param {string} magazine 10 | * @return {boolean} 11 | */ 12 | var canConstruct = function(ransomNote, magazine) { 13 | var map = {}; 14 | var flag = true; 15 | 16 | magazine.split('').forEach(i => map[i] === undefined ? map[i] = 1 : map[i]++); 17 | ransomNote.split('').forEach(i => { 18 | if(map[i] === undefined || map[i] === 0) { 19 | flag = false; 20 | } else { 21 | map[i]--; 22 | } 23 | }); 24 | 25 | return flag; 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Rectangle Area/README.md: -------------------------------------------------------------------------------- 1 | # [Rectangle Area](https://leetcode.com/problems/rectangle-area/) 2 | ###### No:`223` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} A 9 | * @param {number} B 10 | * @param {number} C 11 | * @param {number} D 12 | * @param {number} E 13 | * @param {number} F 14 | * @param {number} G 15 | * @param {number} H 16 | * @return {number} 17 | */ 18 | var computeArea = function(A, B, C, D, E, F, G, H) { 19 | var areaA = (C-A) * (D-B); 20 | var areaB = (G-E) * (H-F); 21 | 22 | var left = Math.max(A, E); 23 | var right = Math.min(G, C); 24 | var bottom = Math.max(F, B); 25 | var top = Math.min(D, H); 26 | 27 | var overlap = 0; 28 | 29 | if(right > left && top > bottom) { 30 | overlap = (right - left) * (top - bottom); 31 | } 32 | return areaA + areaB - overlap; 33 | }; 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Relative Ranks/README.md: -------------------------------------------------------------------------------- 1 | # [Relative Ranks](https://leetcode.com/problems/relative-ranks/#/description) 2 | ###### No:`506` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {string[]} 11 | */ 12 | var findRelativeRanks = function(nums) { 13 | var rank = 4; 14 | var map = {}; 15 | var sortNums = [].slice.call(nums).sort((a, b) => b - a); 16 | for (var i = 0; i < sortNums.length; i++) { 17 | if (i === 0) { 18 | map[sortNums[i]] = 'Gold Medal'; 19 | } else if (i === 1) { 20 | map[sortNums[i]] = 'Silver Medal'; 21 | } else if (i === 2) { 22 | map[sortNums[i]] = 'Bronze Medal'; 23 | } else { 24 | map[sortNums[i]] = String(rank); 25 | rank++; 26 | } 27 | } 28 | 29 | return nums.map((score) => { 30 | return map[score]; 31 | }); 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Remove Duplicates from Sorted Array/README.md: -------------------------------------------------------------------------------- 1 | # [Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/) 2 | ###### No:`26` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number} 10 | */ 11 | var removeDuplicates = function(nums) { 12 | var i = 0; 13 | var j = 0; 14 | while(j < nums.length) { 15 | if(nums[i] == nums[j]) { 16 | j++; 17 | } else { 18 | i++; 19 | nums[i] = nums[j]; 20 | j++; 21 | } 22 | } 23 | return i + 1; 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Remove Duplicates from Sorted List/README.md: -------------------------------------------------------------------------------- 1 | # [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/) 2 | ###### No:`83` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {ListNode} 17 | */ 18 | var deleteDuplicates = function(head) { 19 | var iter = head; 20 | while(iter) { 21 | if(iter.next && iter.val === iter.next.val) { 22 | iter.next = iter.next.next; 23 | } else { 24 | iter = iter.next; 25 | } 26 | } 27 | return head; 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Remove Element/README.md: -------------------------------------------------------------------------------- 1 | # [Remove Element](https://leetcode.com/problems/remove-element/) 2 | ###### No:`27` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @param {number} val 10 | * @return {number} 11 | */ 12 | var removeElement = function(nums, val) { 13 | var head = 0; 14 | var tail = nums.length - 1; 15 | while(head <= tail) { 16 | if(nums[head] != val) { 17 | head++; 18 | continue; 19 | } 20 | 21 | if(nums[tail] == val) { 22 | tail--; 23 | continue; 24 | } 25 | 26 | nums[head] = nums[tail]; 27 | tail--; 28 | } 29 | return head; 30 | }; 31 | ``` 32 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Remove Linked List Elements/README.md: -------------------------------------------------------------------------------- 1 | # [Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/) 2 | ###### No:`203` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @param {number} val 17 | * @return {ListNode} 18 | */ 19 | var removeElements = function(head, val) { 20 | while(head && head.val == val) { 21 | head = head.next; 22 | } 23 | 24 | if(!head) { 25 | return head; 26 | } 27 | 28 | var prev = head; 29 | var iter = head.next; 30 | 31 | while(iter) { 32 | if(iter.val == val) { 33 | prev.next = iter.next; 34 | } else { 35 | prev = iter; 36 | } 37 | iter = iter.next; 38 | } 39 | 40 | return head; 41 | }; 42 | ``` 43 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Remove Nth Node From End of List/README.md: -------------------------------------------------------------------------------- 1 | # [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/) 2 | ###### No:`19` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @param {number} n 17 | * @return {ListNode} 18 | */ 19 | var removeNthFromEnd = function(head, n) { 20 | var front = head; 21 | var end = head; 22 | for(var i = 0; i <= n && front; i++) { 23 | front = front.next; 24 | } 25 | 26 | // delete first node 27 | if(i < n + 1) { 28 | return head.next; 29 | } 30 | 31 | while(front) { 32 | front = front.next; 33 | end = end.next; 34 | } 35 | end.next = end.next.next; 36 | return head; 37 | }; 38 | ``` 39 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Repeated Substring Pattern/README.md: -------------------------------------------------------------------------------- 1 | # [Repeated Substring Pattern](https://leetcode.com/problems/repeated-substring-pattern/#/description) 2 | ###### No:`459` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} s 10 | * @return {boolean} 11 | */ 12 | /* 13 | var repeatedSubstringPattern = function(s) { 14 | if (s.length === 1) return false; 15 | var ret = false; 16 | 17 | for (var i = 1; i <= parseInt((s.length + 1) / 2); i++) { 18 | for (var j = i; j < s.length; j++) { 19 | if (s[j % i] !== s[j]) break; 20 | } 21 | if (j === s.length && (j - 1) % i === i - 1) { 22 | ret = true; 23 | break; 24 | } 25 | } 26 | 27 | return ret; 28 | }; 29 | */ 30 | 31 | var repeatedSubstringPattern = function(s) { 32 | return /^(.+)\1+$/.test(s); 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse Integer/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse Integer](https://leetcode.com/problems/reverse-integer/) 2 | ###### No:`7` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} x 9 | * @return {number} 10 | */ 11 | var reverse = function(x) { 12 | var flag = (x < 0 ? true : false); 13 | x = Math.abs(x); 14 | var reverse = parseInt((x + '').split('').reverse().join(''), 10); 15 | if(reverse > Math.pow(2, 31)) { 16 | return 0; 17 | } 18 | if(flag) { 19 | return 0 - reverse; 20 | } else { 21 | return reverse; 22 | } 23 | }; 24 | ``` 25 | ###### PS: 26 | 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? 27 | For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows. 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse Linked List II/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/) 2 | ###### No:`92` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @param {number} m 17 | * @param {number} n 18 | * @return {ListNode} 19 | */ 20 | 21 | var reverseBetween = function(head, m, n) { 22 | function reverseList(head) { 23 | if(!head) { 24 | return head; 25 | } 26 | var prev = null; 27 | var next = null; 28 | while(head) { 29 | next = head.next; 30 | head.next = prev; 31 | prev = head; 32 | head = next; 33 | } 34 | return prev; 35 | } 36 | if(m === n) { 37 | return head; 38 | } 39 | var middleLeft = null; 40 | var middleRight = null; 41 | var left = null; 42 | var right = null; 43 | 44 | var i = 1; 45 | var point = head; 46 | while(point) { 47 | if(i + 1 === m) { 48 | left = point; 49 | } 50 | if(i === m) { 51 | middleLeft = point; 52 | } 53 | if(i === n) { 54 | middleRight = point; 55 | } 56 | if(i === n + 1) { 57 | right = point; 58 | } 59 | i++; 60 | point = point.next; 61 | } 62 | if(left) { 63 | left.next = null; 64 | } 65 | 66 | middleRight.next = null; 67 | reverseList(middleLeft); 68 | middleLeft.next = right; 69 | 70 | if(left) { 71 | left.next = middleRight; 72 | return head; 73 | } else { 74 | return middleRight; 75 | } 76 | }; 77 | 78 | ``` 79 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse Linked List/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/) 2 | ###### No:`206` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {ListNode} 17 | */ 18 | var reverseList = function(head) { 19 | if(!head) { 20 | return head; 21 | } 22 | var prev = null; 23 | var next = null; 24 | while(head) { 25 | next = head.next; 26 | head.next = prev; 27 | prev = head; 28 | head = next; 29 | } 30 | return prev; 31 | }; 32 | ``` 33 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse String/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse String](https://leetcode.com/problems/reverse-string/) 2 | ###### No:`344` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {string} 10 | */ 11 | var reverseString = function(s) { 12 | return s.split('').reverse().join(''); 13 | }; 14 | ``` 15 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse Vowels of a String/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse Vowels of a String](https://leetcode.com/problems/reverse-vowels-of-a-string/#/description) 2 | ###### No:`345` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {string} s 10 | * @return {string} 11 | */ 12 | var reverseVowels = function(s) { 13 | s = s.split(''); 14 | var vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']; 15 | var start = -1; 16 | var end = s.length; 17 | var temp; 18 | 19 | while (start < end) { 20 | while (start < end && vowels.indexOf(s[++start]) === -1); 21 | while (start < end && vowels.indexOf(s[--end]) === -1); 22 | temp = s[start]; 23 | s[start] = s[end]; 24 | s[end] = temp; 25 | } 26 | 27 | return s.join(''); 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Reverse Words in a String/README.md: -------------------------------------------------------------------------------- 1 | # [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/) 2 | ###### No:`151` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} str 9 | * @returns {string} 10 | */ 11 | var reverseWords = function(str) { 12 | return str.split(' ').reverse().filter(function(item) { 13 | return '' != item; 14 | }).join(' ').trim(); 15 | }; 16 | 17 | ``` 18 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Roman to Integer/README.md: -------------------------------------------------------------------------------- 1 | # [Roman to Integer](https://leetcode.com/problems/roman-to-integer/) 2 | ###### No:`13` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {number} 10 | * 11 | * Symbol Value 12 | * I 1 13 | * V 5 14 | * X 10 15 | * L 50 16 | * C 100 17 | * D 500 18 | * M 1,000 19 | 20 | */ 21 | var romanToInt = function(s) { 22 | var map = { 23 | 'I':1, 24 | 'V':5, 25 | 'X':10, 26 | 'L':50, 27 | 'C':100, 28 | 'D':500, 29 | 'M':1000 30 | }; 31 | 32 | var sum = 0; 33 | var right = 'I'; 34 | 35 | for(var i = s.length - 1; i >=0; i--) { 36 | if(i < s.length - 1) { 37 | right = s[i + 1]; 38 | } 39 | if(map[s[i]] < map[right]) { 40 | sum -= map[s[i]]; 41 | } else { 42 | sum += map[s[i]]; 43 | right = s[i]; 44 | } 45 | } 46 | return sum; 47 | }; 48 | 49 | ``` 50 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Rotate Array/README.md: -------------------------------------------------------------------------------- 1 | # [Rotate Array](https://leetcode.com/problems/rotate-array/) 2 | ###### No:`189` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @param {number} k 10 | * @return {void} Do not return anything, modify nums in-place instead. 11 | */ 12 | var rotate = function(nums, k) { 13 | for(var i = 0; i < k; i++) { 14 | nums.unshift(nums.pop()); 15 | } 16 | }; 17 | ``` 18 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Same Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Same Tree](https://leetcode.com/problems/same-tree/) 2 | ###### No:`100` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} p 16 | * @param {TreeNode} q 17 | * @return {boolean} 18 | */ 19 | var isSameTree = function(p, q) { 20 | if(p == null || q == null) { 21 | return p == q; 22 | } 23 | if(p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right)) { 24 | return true; 25 | } else { 26 | return false; 27 | } 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Search Insert Position/README.md: -------------------------------------------------------------------------------- 1 | # [Search Insert Position](https://leetcode.com/problems/search-insert-position/#/description) 2 | ###### No:`35` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @param {number} target 11 | * @return {number} 12 | */ 13 | var searchInsert = function(nums, target) { 14 | var start = 0; 15 | var end = nums.length - 1; 16 | var middle = parseInt((start + end) / 2); 17 | 18 | while(start <= end) { 19 | if (target === nums[middle]) { 20 | return middle; 21 | } else if (target > nums[middle]) { 22 | start = middle + 1; 23 | } else if (target < nums[middle] ) { 24 | end = middle - 1; 25 | } 26 | if (start > end) { 27 | if (target < nums[middle]) { 28 | return middle; 29 | } else { 30 | return middle + 1; 31 | } 32 | } else { 33 | middle = parseInt((start + end) / 2); 34 | } 35 | } 36 | }; 37 | ``` 38 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Search in Rotated Sorted Array/README.md: -------------------------------------------------------------------------------- 1 | # [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/#/description) 2 | ###### No:`33` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @param {number} target 11 | * @return {number} 12 | */ 13 | function binarySearch(nums, target) { 14 | var end = nums.length - 1; 15 | var start = 0; 16 | var middle = parseInt((start + end) / 2); 17 | 18 | while (end >= start) { 19 | if (nums[middle] == target) { 20 | return middle; 21 | } else if(nums[middle] > target) { 22 | end = middle - 1; 23 | } else if(nums[middle] < target) { 24 | start = middle + 1; 25 | } 26 | middle = parseInt((start + end) / 2); 27 | } 28 | return -1; 29 | } 30 | 31 | var search = function(nums, target) { 32 | var i = 0; 33 | while(nums[i] <= nums[i+1]) { 34 | i++; 35 | } 36 | 37 | if (nums[0] <= target && target <= nums[i]) { 38 | return binarySearch(nums.slice(0, i + 1), target); 39 | } else if (nums[i + 1] <= target && target <= nums[nums.length - 1]){ 40 | var ret = binarySearch(nums.slice(i + 1), target); 41 | return ret == -1 ? -1 : i + 1 + ret; 42 | } else { 43 | return -1; 44 | } 45 | }; 46 | 47 | ``` 48 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Set Matrix Zeroes/README.md: -------------------------------------------------------------------------------- 1 | # [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) 2 | ###### No:`73` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[][]} matrix 9 | * @return {void} Do not return anything, modify matrix in-place instead. 10 | */ 11 | var setZeroes = function(matrix) { 12 | var hasZeroFirstCol = false; 13 | for(var i = 0; i < matrix.length; i++) { 14 | if(matrix[i][0] === 0) { 15 | hasZeroFirstCol = true; 16 | } 17 | for(var j = 1; j < matrix[i].length; j++) { 18 | if(matrix[i][j] === 0) { 19 | matrix[0][j] = matrix[i][0] = 0; 20 | } 21 | } 22 | } 23 | for(var y = matrix.length - 1; y >= 0; y--) { 24 | for(var x = matrix[y].length - 1; x >= 1; x--) { 25 | if(matrix[0][x] === 0 || matrix[y][0] === 0) { 26 | matrix[y][x] = 0; 27 | } 28 | } 29 | if(hasZeroFirstCol) { 30 | matrix[y][0] = 0; 31 | } 32 | } 33 | }; 34 | ``` 35 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Single Number/README.md: -------------------------------------------------------------------------------- 1 | # [Single Number](https://leetcode.com/problems/single-number/) 2 | ###### No:`136` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {number} 10 | */ 11 | var singleNumber = function(nums) { 12 | return nums.reduce(function(prev, cur) { 13 | return prev ^ cur; 14 | }); 15 | }; 16 | ``` 17 | 18 | #### Description: 19 | Any number that XOR itselt will be 0; 20 | 21 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Sort List/README.md: -------------------------------------------------------------------------------- 1 | # [Sort List](https://leetcode.com/problems/sort-list/) 2 | ###### No:`148` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {ListNode} 17 | */ 18 | var sortList = function(head) { 19 | function merge(l1, l2) { 20 | if(!l1) return l2; 21 | if(!l2) return l1; 22 | var head = null 23 | if(l1.val < l2.val) { 24 | head = l1; 25 | l1 = l1.next; 26 | } else { 27 | head = l2; 28 | l2 = l2.next; 29 | } 30 | var newlist = head; 31 | while(l1 && l2) { 32 | if(l1.val < l2.val) { 33 | newlist.next = l1; 34 | l1 = l1.next; 35 | } else { 36 | newlist.next = l2; 37 | l2 = l2.next; 38 | } 39 | newlist = newlist.next; 40 | } 41 | if(!l1) { 42 | newlist.next = l2; 43 | } else { 44 | newlist.next = l1; 45 | } 46 | return head; 47 | } 48 | 49 | if(!head || !head.next) { 50 | return head; 51 | } 52 | 53 | var p1 = head; 54 | var p2 = head; 55 | 56 | // p1 go step 1 57 | // p2 go step 2 58 | while(p1 && p2) { 59 | p2 = p2.next; 60 | if(p2) { 61 | p2 = p2.next; 62 | } 63 | if(!p2) { 64 | break; 65 | } 66 | p1 = p1.next; 67 | } 68 | 69 | var right = p1.next; 70 | p1.next = null; 71 | var left = head; 72 | 73 | return merge(sortList(left), sortList(right)); 74 | } 75 | ``` 76 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Spiral Matrix/README.md: -------------------------------------------------------------------------------- 1 | # [Spiral Matrix](https://leetcode.com/problems/spiral-matrix/#/description) 2 | ###### No:`54` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[][]} matrix 10 | * @return {number[]} 11 | */ 12 | var spiralOrder = function(matrix) { 13 | if (matrix.length == 0) {return [];} 14 | var n = matrix.length; 15 | var m = matrix[0].length; 16 | var up = 0, right = m - 1, down = n - 1, left = 0; 17 | var ret = []; 18 | 19 | while(true) { 20 | for(var r = left; r <= right; r++) ret.push(matrix[up][r]); 21 | if (++up > down) break; 22 | 23 | for(var d = up; d <= down; d++) ret.push(matrix[d][right]); 24 | if (--right < left) break; 25 | 26 | for(var l = right; l >= left; l--) ret.push(matrix[down][l]); 27 | if (--down < up) break; 28 | 29 | for(var u = down; u >= up; u--) ret.push(matrix[u][left]); 30 | if (++left > right) break; 31 | } 32 | return ret; 33 | }; 34 | 35 | ``` 36 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Sqrt(x)/README.md: -------------------------------------------------------------------------------- 1 | # [Sqrt(x)](https://leetcode.com/problems/sqrtx/#/description) 2 | ###### No:`69` 3 | ###### Difficulty:`Easy` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} x 10 | * @return {number} 11 | */ 12 | var mySqrt = function(x) { 13 | var start = 1; 14 | var end = x; 15 | var middle; 16 | 17 | while (start <= end) { 18 | middle = start + parseInt((end - start) / 2); 19 | if (x / middle === middle) { 20 | return middle; 21 | } else if (x / middle > middle) { 22 | start = middle + 1; 23 | } else { 24 | end = middle - 1; 25 | } 26 | } 27 | 28 | return end; 29 | }; 30 | 31 | ``` 32 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/String to Integer (atoi)/README.md: -------------------------------------------------------------------------------- 1 | # [String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/) 2 | ###### No:`8` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} str 9 | * @return {number} 10 | */ 11 | var myAtoi = function(str) { 12 | var ret = parseInt(str, 10); 13 | if(Number.isNaN(ret)) { 14 | return 0; 15 | } 16 | if(ret > 2147483647) { 17 | return 2147483647; 18 | } else if(ret < -2147483648) { 19 | return -2147483648; 20 | } else { 21 | return ret; 22 | } 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Sum of Left Leaves/README.md: -------------------------------------------------------------------------------- 1 | # [Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) 2 | ###### No:`404` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {number} 17 | */ 18 | var sumOfLeftLeaves = function(root) { 19 | if(root === null) return 0; 20 | 21 | if(root.left !== null && root.left.left === null && root.left.right === null) { 22 | return root.left.val + sumOfLeftLeaves(root.right); 23 | } else { 24 | return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right); 25 | } 26 | }; 27 | ``` 28 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Summary Ranges/README.md: -------------------------------------------------------------------------------- 1 | # [Summary Ranges](https://leetcode.com/problems/summary-ranges/) 2 | ###### No:`228` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @return {string[]} 10 | */ 11 | var summaryRanges = function(nums) { 12 | if(nums.length === 0) { 13 | return nums; 14 | } 15 | 16 | var ret = []; 17 | var start = 0; 18 | 19 | for(var i = 1; i < nums.length; i++) { 20 | if(nums[i] - nums[i-1] != 1) { 21 | ret.push(nums.slice(start, i)); 22 | start = i; 23 | } 24 | } 25 | ret.push(nums.slice(start)); 26 | 27 | ret = ret.map(function(item) { 28 | if(item.length > 1) { 29 | return item[0] + '->' + item[item.length - 1]; 30 | } else { 31 | return item[0] + ''; 32 | } 33 | }); 34 | 35 | return ret; 36 | }; 37 | ``` 38 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Swap Nodes in Pairs/README.md: -------------------------------------------------------------------------------- 1 | # [Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/) 2 | ###### No:`24` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for singly-linked list. 9 | * function ListNode(val) { 10 | * this.val = val; 11 | * this.next = null; 12 | * } 13 | */ 14 | /** 15 | * @param {ListNode} head 16 | * @return {ListNode} 17 | */ 18 | var swapPairs = function(head) { 19 | if(head === null || head.next === null) { 20 | return head; 21 | } 22 | 23 | var newhead = null; 24 | var tmp1 = head.next; 25 | var tmp2 = head.next.next; 26 | head.next.next = head; 27 | head.next = tmp2; 28 | 29 | newhead = tmp1; 30 | 31 | var p = head; 32 | while(p && p.next && p.next.next) { 33 | tmp1 = p.next.next; 34 | tmp2 = p.next.next.next; 35 | p.next.next.next = p.next; 36 | p.next.next = tmp2; 37 | p.next = tmp1; 38 | p = p.next.next; 39 | } 40 | 41 | return newhead; 42 | }; 43 | ``` 44 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Symmetric Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Symmetric Tree](https://leetcode.com/problems/symmetric-tree/) 2 | ###### No:`101` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * Definition for a binary tree node. 9 | * function TreeNode(val) { 10 | * this.val = val; 11 | * this.left = this.right = null; 12 | * } 13 | */ 14 | /** 15 | * @param {TreeNode} root 16 | * @return {boolean} 17 | */ 18 | 19 | var isSymmetric = function(root) { 20 | function isSymmetricNode(left, right) { 21 | if(!left && !right) { 22 | return true; 23 | } 24 | if((left && !right) || (!left && right)) { 25 | return false; 26 | } 27 | return (left.val == right.val) 28 | && isSymmetricNode(left.left, right.right) 29 | && isSymmetricNode(left.right, right.left); 30 | } 31 | if(root === null) { 32 | return true; 33 | } 34 | var left = root.left; 35 | var right = root.right; 36 | return isSymmetricNode(left, right); 37 | }; 38 | 39 | ``` 40 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Teemo Attacking/README.md: -------------------------------------------------------------------------------- 1 | # [Teemo Attacking](https://leetcode.com/problems/teemo-attacking/#/description) 2 | ###### No:`495` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} timeSeries 10 | * @param {number} duration 11 | * @return {number} 12 | */ 13 | var findPoisonedDuration = function(timeSeries, duration) { 14 | if (timeSeries.length === 0) return 0; 15 | 16 | var time = 0; 17 | for (var i = 0; i < timeSeries.length - 1; i++) { 18 | if (timeSeries[i + 1] - timeSeries[i] < duration) { 19 | time += timeSeries[i + 1] - timeSeries[i]; 20 | } else { 21 | time += duration; 22 | } 23 | } 24 | time += duration; 25 | 26 | return time; 27 | }; 28 | ``` 29 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Third Maximum Number/README.md: -------------------------------------------------------------------------------- 1 | # [Third Maximum Number](https://leetcode.com/problems/third-maximum-number/#/description) 2 | ###### No:`414` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number[]} nums 10 | * @return {number} 11 | */ 12 | var getMax = function(nums) { 13 | return Math.max.apply(null, nums); 14 | }; 15 | 16 | var removeItem = function(nums, item) { 17 | return nums.filter((value) => value !== item); 18 | }; 19 | 20 | var thirdMax = function(nums) { 21 | var first = getMax(nums); 22 | nums = removeItem(nums, first); 23 | var second = getMax(nums); 24 | nums = removeItem(nums, second); 25 | 26 | if (nums.length === 0) return first; 27 | return getMax(nums); 28 | 29 | }; 30 | 31 | ``` 32 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Top K Frequent Elements/README.md: -------------------------------------------------------------------------------- 1 | # [Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) 2 | ###### No:`347` 3 | ###### Difficulty:`Medium` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @param {number} k 10 | * @return {number[]} 11 | */ 12 | 13 | function SortNumber(size) { 14 | this.size = size; 15 | this.container = []; 16 | } 17 | SortNumber.prototype.setCompare = function(compare) { 18 | this.compare = compare; 19 | } 20 | SortNumber.prototype.getMax = function() { 21 | return this.max; 22 | } 23 | SortNumber.prototype.getMin = function() { 24 | return this.min; 25 | } 26 | SortNumber.prototype.getAll = function() { 27 | return this.container; 28 | } 29 | SortNumber.prototype.setBigNumber = function(num) { 30 | if (this.container.length < this.size) { 31 | this.container.push(num); 32 | } else if (this.compare(this.min, num) < 0) { 33 | this.container.shift(); 34 | this.container.push(num); 35 | } else { 36 | return; 37 | } 38 | 39 | this.container.sort(this.compare); 40 | this.max = this.container[this.container.length - 1]; 41 | this.min = this.container[0]; 42 | } 43 | 44 | var topKFrequent = function(nums, k) { 45 | var topNumber = new SortNumber(k); 46 | topNumber.setCompare((a, b) => a.count - b.count); 47 | var showTimes = {}; 48 | nums.map((num) => { 49 | if(showTimes[num]) { 50 | showTimes[num]++; 51 | } else { 52 | showTimes[num] = 1; 53 | } 54 | }); 55 | for(var num in showTimes) { 56 | topNumber.setBigNumber({ 57 | value: num, 58 | count: showTimes[num], 59 | }); 60 | } 61 | 62 | return topNumber.getAll().map((item) => parseInt(item.value)); 63 | }; 64 | ``` 65 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Two Sum/README.md: -------------------------------------------------------------------------------- 1 | # [Two Sum](https://leetcode.com/problems/two-sum/) 2 | ###### No:`1` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number[]} nums 9 | * @param {number} target 10 | * @return {number[]} 11 | */ 12 | var twoSum = function(nums, target) { 13 | var ret = []; 14 | for(var i = 0; i < nums.length; i++) { 15 | for(var j = i + 1; j < nums.length; j++) { 16 | if(nums[i] + nums[j] === target) { 17 | ret.push(i); 18 | ret.push(j); 19 | } 20 | } 21 | } 22 | return ret; 23 | }; 24 | ``` 25 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Ugly Number/README.md: -------------------------------------------------------------------------------- 1 | # [Ugly Number](https://leetcode.com/problems/ugly-number/) 2 | ###### No:`263` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {number} num 9 | * @return {boolean} 10 | */ 11 | var isUgly = function(num) { 12 | if(num <= 0) { 13 | return false; 14 | } 15 | while(num % 2 === 0) {num /= 2;} 16 | while(num % 3 === 0) {num /= 3;} 17 | while(num % 5 === 0) {num /= 5;} 18 | return num === 1 ? true : false; 19 | }; 20 | ``` 21 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Valid Anagram/README.md: -------------------------------------------------------------------------------- 1 | # [Valid Anagram](https://leetcode.com/problems/valid-anagram/) 2 | ###### No:`242` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @param {string} t 10 | * @return {boolean} 11 | */ 12 | var isAnagram = function(s, t) { 13 | var arr1 = s.split('').sort(); 14 | var arr2 = t.split('').sort(); 15 | if(arr1.length !== arr2.length) { 16 | return false; 17 | } 18 | for(var i = 0; i < arr1.length; i++) { 19 | if(arr1[i] !== arr2[i]) { 20 | return false; 21 | } 22 | } 23 | return true; 24 | }; 25 | ``` 26 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Valid Palindrome/README.md: -------------------------------------------------------------------------------- 1 | # [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) 2 | ###### No:`125` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {boolean} 10 | */ 11 | var isPalindrome = function(s) { 12 | var str = s.split('').filter(function(c) { 13 | return c.match(/[\w\d]/); 14 | }).join('').toLowerCase(); 15 | 16 | if(str === '') { 17 | return true; 18 | } 19 | var i = 0; 20 | var j = str.length - 1; 21 | while(i < j) { 22 | if(str[i] != str[j]) { 23 | return false; 24 | } 25 | i++; 26 | j--; 27 | } 28 | return true; 29 | }; 30 | ``` 31 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Valid Parentheses/README.md: -------------------------------------------------------------------------------- 1 | # [Valid Parentheses](https://leetcode.com/problems/valid-parentheses/) 2 | ###### No:`20` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @return {boolean} 10 | */ 11 | var isValid = function(s) { 12 | var stack = []; 13 | var match = { 14 | ')': '(', 15 | ']': '[', 16 | '}': '{' 17 | }; 18 | var len; 19 | for(var i = 0; i < s.length; i++) { 20 | len = stack.length; 21 | if(len > 0 && stack[len-1] == match[s[i]]) { 22 | stack.pop(); 23 | } else { 24 | stack.push(s[i]); 25 | } 26 | } 27 | return stack.length === 0; 28 | }; 29 | ``` 30 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Valid Perfect Square/README.md: -------------------------------------------------------------------------------- 1 | # [Valid Perfect Square](https://leetcode.com/problems/valid-perfect-square/#/description) 2 | ###### No:`367` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | 7 | ```js 8 | /** 9 | * @param {number} num 10 | * @return {boolean} 11 | */ 12 | var isPerfectSquare = function(num) { 13 | if (num < 1) return false; 14 | if (num === 1) return true; 15 | 16 | var start = 0; 17 | var end = num; 18 | var middle = num / 2; 19 | 20 | while (start <= end) { 21 | if (parseInt(num / middle) === middle && num % middle === 0) { 22 | return true; 23 | } else if (num / middle > middle) { 24 | start = middle + 1; 25 | } else if (num / middle < middle) { 26 | end = middle - 1; 27 | } 28 | middle = parseInt((start + end) / 2); 29 | } 30 | 31 | return false; 32 | }; 33 | ``` 34 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Valid Sudoku/README.md: -------------------------------------------------------------------------------- 1 | # [Valid Sudoku](https://leetcode.com/problems/valid-sudoku/) 2 | ###### No:`36` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {character[][]} board 9 | * @return {boolean} 10 | */ 11 | var isValidSudoku = function(board) { 12 | var rowExist = {}; 13 | var colExist = {}; 14 | var boxExist = {}; 15 | var k, value; 16 | for (var i = 0; i < board.length; i++) { 17 | for (var j = 0; j < board[i].length; j++) { 18 | value = board[i][j]; 19 | k = parseInt(i / 3, 10) * 3 + parseInt(j / 3, 10); //the number of the box 20 | if (!rowExist[i]) { 21 | rowExist[i] = {}; 22 | } 23 | if (!colExist[j]) { 24 | colExist[j] = {}; 25 | } 26 | if (!boxExist[k]) { 27 | boxExist[k] = {}; 28 | } 29 | 30 | if (value !== '.') { 31 | if (rowExist[i][value] || colExist[j][value] || boxExist[k][value]) { 32 | return false; 33 | } else { 34 | rowExist[i][value] = true; 35 | colExist[j][value] = true; 36 | boxExist[k][value] = true; 37 | } 38 | } 39 | } 40 | } 41 | return true; 42 | }; 43 | ``` 44 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/Validate Binary Search Tree/README.md: -------------------------------------------------------------------------------- 1 | # [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/) 2 | ###### No:`98` 3 | ###### Difficulty:`Medium` 4 | ## JavaScript 5 | 6 | 7 | ```js 8 | /** 9 | * Definition for a binary tree node. 10 | * function TreeNode(val) { 11 | * this.val = val; 12 | * this.left = this.right = null; 13 | * } 14 | */ 15 | /** 16 | * @param {TreeNode} root 17 | * @return {boolean} 18 | */ 19 | 20 | var traverse = function(root, cb) { 21 | if (root === null) { 22 | return; 23 | } 24 | traverse(root.left, cb); 25 | cb(root); 26 | traverse(root.right, cb); 27 | 28 | }; 29 | var isValidBST = function(root) { 30 | var arr = []; 31 | traverse(root, function(node) { 32 | arr.push(node.val); 33 | }); 34 | 35 | for(var i = 0; i < arr.length - 1; i++) { 36 | if (arr[i] >= arr[i + 1]) { 37 | return false; 38 | } 39 | } 40 | return true; 41 | }; 42 | ``` 43 | -------------------------------------------------------------------------------- /old(deprecated)/Algorithms/ZigZag Conversion/README.md: -------------------------------------------------------------------------------- 1 | # [ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/) 2 | ###### No:`6` 3 | ###### Difficulty:`Easy` 4 | 5 | 6 | ```javascript 7 | /** 8 | * @param {string} s 9 | * @param {number} numRows 10 | * @return {string} 11 | */ 12 | var convert = function(s, numRows) { 13 | var chars = s.split(''); 14 | var arrs = []; 15 | for(var k = 0; k < numRows; k++) { 16 | arrs.push([]); 17 | } 18 | 19 | var i = 0; 20 | while(i < chars.length) { 21 | for(var x = 0; x < numRows && i < chars.length; x++) { 22 | arrs[x].push(chars[i++]); 23 | } 24 | for(var x = numRows - 2; x > 0 && i < chars.length; x--) { 25 | arrs[x].push(chars[i++]); 26 | } 27 | } 28 | 29 | var ret = ''; 30 | arrs.map(function(item) { 31 | ret = ret.concat(item.join('')); 32 | }); 33 | return ret; 34 | }; 35 | ``` 36 | ### How to solve? 37 | ``` 38 | 1 9 17 39 | 2 8 10 16 18 40 | 3 7 11 15 41 | 4 6 12 14 42 | 5 13 43 | ``` 44 | 45 | ###### 1.Create `arrs = [[],[],[],[],[]]` 46 | 47 | ###### 2.traverse `chars` than save the every char like the following: 48 | arrs[0] = [1, 9, 17]； 49 | arrs[1] = [2, 8, 10, 16, 18]； 50 | arrs[2] = [3, 7, 11, 15]； 51 | arrs[3] = [4, 6, 12, 14]； 52 | arrs[4] = [5, 13]； 53 | 54 | ###### 3.concat arrs 55 | -------------------------------------------------------------------------------- /old(deprecated)/README.md: -------------------------------------------------------------------------------- 1 | leetcode 2 | ======== 3 | #### Total solved: 153 (Easy: 111 Medium: 41 Hard: 1 ) 4 | My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/) 5 | 6 | 7 | | No | Title | Source Code | Difficulty | 8 | |----| ----- | -------- | ---------- | 9 | |544|Output Contest Matches|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Output%20Contest%20Matches)|Medium| 10 | |543|Diameter of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Diameter%20of%20Binary%20Tree)|Easy| 11 | |542|01 Matrix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/01%20Matrix)|Medium| 12 | |538|Convert BST to Greater Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Convert%20BST%20to%20Greater%20Tree)|Medium| 13 | |532|K-diff Pairs in an Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/K-diff%20Pairs%20in%20an%20Array)|Easy| 14 | |530|Minimum Absolute Difference in BST|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Absolute%20Difference%20in%20BST)|Easy| 15 | |529|Minesweeper|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minesweeper)|Medium| 16 | |526|Beautiful Arrangement|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Beautiful%20Arrangement)|Medium| 17 | |520|Detect Capital|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Detect%20Capital)|Easy| 18 | |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| 19 | |513|Find Bottom Left Tree Value|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20Bottom%20Left%20Tree%20Value)|Medium| 20 | |508|Most Frequent Subtree Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Most%20Frequent%20Subtree%20Sum)|Medium| 21 | |506|Relative Ranks|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Relative%20Ranks)|Easy| 22 | |504|Base 7|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Base%207)|Easy| 23 | |503|Next Greater Element II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Greater%20Element%20II)|Medium| 24 | |501|Find Mode in Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20Mode%20in%20Binary%20Search%20Tree)|Easy| 25 | |500|Keyboard Row|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Keyboard%20Row)|Easy| 26 | |496|Next Greater Element I|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Greater%20Element%20I)|Easy| 27 | |492|Construct the Rectangle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Construct%20the%20Rectangle)|Easy| 28 | |485|Max Consecutive Ones|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Max%20Consecutive%20Ones)|Easy| 29 | |482|License Key Formatting|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/License%20Key%20Formatting)|Medium| 30 | |476|Number Complement|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20Complement)|Easy| 31 | |463|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Easy| 32 | |461|Hamming Distance|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Hamming%20Distance)|Easy| 33 | |459|Repeated Substring Pattern|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Repeated%20Substring%20Pattern)|Easy| 34 | |455|Assign Cookies|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Assign%20Cookies)|Easy| 35 | |453|Minimum Moves to Equal Array Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Moves%20to%20Equal%20Array%20Elements)|Easy| 36 | |450|Delete Node in a BST|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Delete%20Node%20in%20a%20BST)|Medium| 37 | |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| 38 | |447|Number of Boomerangs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%20Boomerangs)|Easy| 39 | |442|Find All Duplicates in an Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20All%20Duplicates%20in%20an%20Array)|Medium| 40 | |441|Arranging Coins|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Arranging%20Coins)|Easy| 41 | |437|Path Sum III|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Path%20Sum%20III)|Easy| 42 | |434|Number of Segments in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%20Segments%20in%20a%20String)|Easy| 43 | |415|Add Strings|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Strings)|Easy| 44 | |414|Third Maximum Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Third%20Maximum%20Number)|Easy| 45 | |413|Arithmetic Slices|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Arithmetic%20Slices)|Medium| 46 | |412|Fizz Buzz|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Fizz%20Buzz)|Easy| 47 | |409|Longest Palindrome|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Longest%20Palindrome)|Easy| 48 | |406|Queue Reconstruction by Height|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Queue%20Reconstruction%20by%20Height)|Medium| 49 | |404|Sum of Left Leaves|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sum%20of%20Left%20Leaves)|Easy| 50 | |401|Binary Watch|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Watch)|Easy| 51 | |400|Nth Digit|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Nth%20Digit)|Easy| 52 | |389|Find the Difference|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Find%20the%20Difference)|Easy| 53 | |387|First Unique Character in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/First%20Unique%20Character%20in%20a%20String)|Easy| 54 | |383|Ransom Note|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Ransom%20Note)|Easy| 55 | |374|Guess Number Higher or Lower|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Guess%20Number%20Higher%20or%20Lower)|Easy| 56 | |367|Valid Perfect Square|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Perfect%20Square)|Easy| 57 | |350|Intersection of Two Arrays II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Arrays%20II)|Easy| 58 | |349|Intersection of Two Arrays|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Arrays)|Easy| 59 | |347|Top K Frequent Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Top%20K%20Frequent%20Elements)|Medium| 60 | |345|Reverse Vowels of a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Vowels%20of%20a%20String)|Easy| 61 | |344|Reverse String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20String)|Easy| 62 | |343|Integer Break|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Integer%20Break)|Medium| 63 | |342|Power of Four|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Four)|Easy| 64 | |338|Counting Bits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Counting%20Bits)|Medium| 65 | |328|Odd Even Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Odd%20Even%20Linked%20List)|Medium| 66 | |326|Power of Three|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Three)|Easy| 67 | |319|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Medium| 68 | |292|Nim Game|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Nim%20Game)|Easy| 69 | |283|Move Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Move%20Zeroes)|Easy| 70 | |278|First Bad Version|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/First%20Bad%20Version)|Easy| 71 | |268|Missing Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Missing%20Number)|Medium| 72 | |263|Ugly Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Ugly%20Number)|Easy| 73 | |258|Add Digits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Add%20Digits)|Easy| 74 | |257|Binary Tree Paths|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Paths)|Easy| 75 | |242|Valid Anagram|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Anagram)|Easy| 76 | |238|Product of Array Except Self|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Product%20of%20Array%20Except%20Self)|Medium| 77 | |237|Delete Node in a Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Delete%20Node%20in%20a%20Linked%20List)|Easy| 78 | |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| 79 | |234|Palindrome Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Palindrome%20Linked%20List)|Easy| 80 | |232|Implement Queue using Stacks|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Implement%20Queue%20using%20Stacks)|Easy| 81 | |231|Power of Two|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Power%20of%20Two)|Easy| 82 | |228|Summary Ranges|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Summary%20Ranges)|Easy| 83 | |226|Invert Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Invert%20Binary%20Tree)|Easy| 84 | |223|Rectangle Area|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Rectangle%20Area)|Easy| 85 | |219|Contains Duplicate II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Contains%20Duplicate%20II)|Easy| 86 | |217|Contains Duplicate|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Contains%20Duplicate)|Easy| 87 | |206|Reverse Linked List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Linked%20List)|Easy| 88 | |205|Isomorphic Strings|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Isomorphic%20Strings)|Easy| 89 | |204|Count Primes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Count%20Primes)|Easy| 90 | |203|Remove Linked List Elements|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Linked%20List%20Elements)|Easy| 91 | |202|Happy Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Happy%20Number)|Easy| 92 | |198|House Robber|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/House%20Robber)|Easy| 93 | |191|Number of 1 Bits|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Number%20of%201%20Bits)|Easy| 94 | |189|Rotate Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Rotate%20Array)|Easy| 95 | |179|Largest Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Largest%20Number)|Medium| 96 | |172|Factorial Trailing Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Factorial%20Trailing%20Zeroes)|Easy| 97 | |171|Excel Sheet Column Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Excel%20Sheet%20Column%20Number)|Easy| 98 | |169|Majority Element|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Majority%20Element)|Easy| 99 | |168|Excel Sheet Column Title|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Excel%20Sheet%20Column%20Title)|Easy| 100 | |165|Compare Version Numbers|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Compare%20Version%20Numbers)|Easy| 101 | |160|Intersection of Two Linked Lists|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Intersection%20of%20Two%20Linked%20Lists)|Easy| 102 | |155|Min Stack|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Min%20Stack)|Easy| 103 | |151|Reverse Words in a String|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Words%20in%20a%20String)|Easy| 104 | |150|Evaluate Reverse Polish Notation|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Evaluate%20Reverse%20Polish%20Notation)|Medium| 105 | |149|Max Points on a Line|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Max%20Points%20on%20a%20Line)|Hard| 106 | |148|Sort List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sort%20List)|Medium| 107 | |144|Binary Tree Preorder Traversal|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Preorder%20Traversal)|Medium| 108 | |141|Linked List Cycle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Linked%20List%20Cycle)|Easy| 109 | |138|Copy List with Random Pointer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Copy%20List%20with%20Random%20Pointer)|Medium| 110 | |136|Single Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Single%20Number)|Medium| 111 | |125|Valid Palindrome|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Palindrome)|Easy| 112 | |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| 113 | |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| 114 | |119|Pascal's Triangle II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Pascal's%20Triangle%20II)|Easy| 115 | |118|Pascal's Triangle|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Pascal's%20Triangle)|Easy| 116 | |112|Path Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Path%20Sum)|Easy| 117 | |111|Minimum Depth of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Minimum%20Depth%20of%20Binary%20Tree)|Easy| 118 | |110|Balanced Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Balanced%20Binary%20Tree)|Easy| 119 | |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| 120 | |107|Binary Tree Level Order Traversal II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Level%20Order%20Traversal%20II)|Easy| 121 | |104|Maximum Depth of Binary Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Maximum%20Depth%20of%20Binary%20Tree)|Easy| 122 | |102|Binary Tree Level Order Traversal|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Binary%20Tree%20Level%20Order%20Traversal)|Easy| 123 | |101|Symmetric Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Symmetric%20Tree)|Easy| 124 | |100|Same Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Same%20Tree)|Easy| 125 | |98|Validate Binary Search Tree|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Validate%20Binary%20Search%20Tree)|Medium| 126 | |92|Reverse Linked List II|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Linked%20List%20II)|Medium| 127 | |88|Merge Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Merge%20Sorted%20Array)|Easy| 128 | |83|Remove Duplicates from Sorted List|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Duplicates%20from%20Sorted%20List)|Easy| 129 | |73|Set Matrix Zeroes|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Set%20Matrix%20Zeroes)|Medium| 130 | |70|Climbing Stairs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Climbing%20Stairs)|Easy| 131 | |69|Sqrt(x)|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Sqrt(x))|Easy| 132 | |66|Plus One|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Plus%20One)|Easy| 133 | |58|Length of Last Word|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Length%20of%20Last%20Word)|Easy| 134 | |54|Spiral Matrix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Spiral%20Matrix)|Medium| 135 | |53|Maximum Subarray|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Maximum%20Subarray)|Easy| 136 | |46|Permutations|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Permutations)|Medium| 137 | |38|Count and Say|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Count%20and%20Say)|Easy| 138 | |36|Valid Sudoku|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Sudoku)|Easy| 139 | |35|Search Insert Position|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Search%20Insert%20Position)|Easy| 140 | |33|Search in Rotated Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Search%20in%20Rotated%20Sorted%20Array)|Medium| 141 | |31|Next Permutation|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Next%20Permutation)|Medium| 142 | |29|Divide Two Integers|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Divide%20Two%20Integers)|Medium| 143 | |28|Implement strStr()|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Implement%20strStr())|Easy| 144 | |27|Remove Element|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Element)|Easy| 145 | |26|Remove Duplicates from Sorted Array|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Remove%20Duplicates%20from%20Sorted%20Array)|Easy| 146 | |24|Swap Nodes in Pairs|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Swap%20Nodes%20in%20Pairs)|Easy| 147 | |22|Generate Parentheses|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Generate%20Parentheses)|Medium| 148 | |21|Merge Two Sorted Lists|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Merge%20Two%20Sorted%20Lists)|Easy| 149 | |20|Valid Parentheses|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Valid%20Parentheses)|Easy| 150 | |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| 151 | |17|Letter Combinations of a Phone Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Letter%20Combinations%20of%20a%20Phone%20Number)|Medium| 152 | |16|3Sum Closest|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/3Sum%20Closest)|Medium| 153 | |15|3Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/3Sum)|Medium| 154 | |14|Longest Common Prefix|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Longest%20Common%20Prefix)|Easy| 155 | |13|Roman to Integer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Roman%20to%20Integer)|Easy| 156 | |12|Integer to Roman|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Integer%20to%20Roman)|Medium| 157 | |9|Palindrome Number|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Palindrome%20Number)|Easy| 158 | |8|String to Integer (atoi)|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/String%20to%20Integer%20(atoi))|Easy| 159 | |7|Reverse Integer|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Reverse%20Integer)|Easy| 160 | |6|ZigZag Conversion|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/ZigZag%20Conversion)|Easy| 161 | |1|Two Sum|[JavaScript](https://github.com/duteng/leetcode/tree/master/Algorithms/Two%20Sum)|Easy| 162 | -------------------------------------------------------------------------------- /old(deprecated)/generate-md.js: -------------------------------------------------------------------------------- 1 | var fs = require('fs'); 2 | var events = require('events'); 3 | var proxy = new events.EventEmitter(); 4 | 5 | var dir = './Algorithms'; 6 | var repo_url = 'https://github.com/duteng/leetcode/tree/master/Algorithms/'; 7 | var ret = []; 8 | 9 | var total = 0; 10 | var easy = 0; 11 | var medium = 0; 12 | var hard = 0; 13 | 14 | targetDirs = fs.readdir(dir, function(err, files) { 15 | var count = files.length; 16 | files.forEach(function(value, index, arr) { 17 | fs.readFile(dir + '/' + value + '/README.md', {encoding: 'utf8'}, function(err, data) { 18 | var no = parseInt(data.match(/###### No:`(\d+)`/)[1], 10); 19 | var difficulty = data.match(/###### Difficulty:`(\w+)`/)[1]; 20 | var title = data.match(/# \[(.*)\]/)[1]; 21 | var link = '[JavaScript](' + repo_url + title.replace(/\s/g, '%20') + ')'; 22 | 23 | total++; 24 | if (difficulty === 'Hard') { 25 | hard++; 26 | } else if (difficulty === 'Medium') { 27 | medium++; 28 | } else if (difficulty === 'Easy') { 29 | easy++; 30 | } 31 | ret.push({ 32 | no: no, 33 | title:title, 34 | difficulty: difficulty, 35 | link: link 36 | }); 37 | if(ret.length == count) { 38 | proxy.emit('readDone'); 39 | } 40 | 41 | }); 42 | }); 43 | }); 44 | 45 | proxy.once('readDone', function() { 46 | ret.sort(function(a, b) { 47 | return b.no - a.no; 48 | }); 49 | 50 | var content = [ 51 | 'leetcode', 52 | '========', 53 | `#### Total solved: ${total} (Easy: ${easy} Medium: ${medium} Hard: ${hard} )`, 54 | 'My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/)', 55 | '', 56 | '', 57 | '| No | Title | Source Code | Difficulty |', 58 | '|----| ----- | -------- | ---------- |' 59 | ].join('\r\n') + '\r\n'; 60 | 61 | for(var i = 0; i < ret.length; i++) { 62 | content += '|' + ret[i].no + '|' + ret[i].title + '|' + ret[i].link + '|' + ret[i].difficulty + '|' + '\r\n'; 63 | } 64 | fs.writeFile('README.md', content); 65 | }); 66 | -------------------------------------------------------------------------------- /old(deprecated)/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "request-leetcode", 3 | "version": "1.0.0", 4 | "description": "leetcode\r ========\r My JavaScript Solution of [leetcode](http://oj.leetcode.com/problems/)", 5 | "main": "request.js", 6 | "scripts": { 7 | "test": "echo \"Error: no test specified\" && exit 1" 8 | }, 9 | "repository": { 10 | "type": "git", 11 | "url": "git+https://github.com/duteng/leedcode.git" 12 | }, 13 | "author": "", 14 | "license": "ISC", 15 | "bugs": { 16 | "url": "https://github.com/duteng/leedcode/issues" 17 | }, 18 | "homepage": "https://github.com/duteng/leedcode#readme", 19 | "dependencies": { 20 | "cheerio": "^0.22.0", 21 | "request": "^2.81.0" 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /old(deprecated)/request-problem.js: -------------------------------------------------------------------------------- 1 | var fs = require('fs'); 2 | var request = require('request'); 3 | var cheerio = require('cheerio'); 4 | 5 | var urls = [ 6 | 'https://leetcode.com/problems/linked-list-random-node/#/description', 7 | ]; 8 | 9 | urls.forEach((url) => { 10 | request(url, (err, response, body) => { 11 | console.log(url, err); 12 | var $ = cheerio.load(body); 13 | var textArr = $('.question-title h3').text().trim().split('. '); 14 | var no = textArr[0]; 15 | var title = textArr[1]; 16 | var difficulty = $('.question-info li').eq(2).text().split(': ').pop(); 17 | 18 | var folderPath = `Algorithms/${title}`; 19 | var filePath = `${folderPath}/README.md`; 20 | 21 | 22 | fs.mkdir(folderPath, (err) => { 23 | fs.open(filePath, 'wx', (err) => { 24 | var content = [ 25 | `# [${title}](${url})`, 26 | `###### No:\`${no}\``, 27 | `###### Difficulty:\`${difficulty}\``, 28 | '## JavaScript', 29 | '', 30 | '', 31 | '```js', 32 | '```', 33 | ].join('\r\n') + '\r\n'; 34 | 35 | fs.writeFile(filePath, content); 36 | }); 37 | }); 38 | }); 39 | }); 40 | --------------------------------------------------------------------------------