├── .gitignore └── old(deprecated) ├── Algorithms ├── Nim Game │ └── README.md ├── Reverse String │ └── README.md ├── Detect Capital │ └── README.md ├── Length of Last Word │ └── README.md ├── Rotate Array │ └── README.md ├── Keyboard Row │ └── README.md ├── Base 7 │ └── README.md ├── Reverse Words in a String │ └── README.md ├── Single Number │ └── README.md ├── Minimum Moves to Equal Array Elements │ └── README.md ├── Power of Two │ └── README.md ├── Ugly Number │ └── README.md ├── Climbing Stairs │ └── README.md ├── Excel Sheet Column Title │ └── README.md ├── Palindrome Number │ └── README.md ├── Contains Duplicate │ └── README.md ├── Pascal's Triangle II │ └── README.md ├── Find the Difference │ └── README.md ├── Move Zeroes │ └── README.md ├── Excel Sheet Column Number │ └── README.md ├── String to Integer (atoi) │ └── README.md ├── Delete Node in a Linked List │ └── README.md ├── Two Sum │ └── README.md ├── Power of Four │ └── README.md ├── First Unique Character in a String │ └── README.md ├── Power of Three │ └── README.md ├── Implement strStr() │ └── README.md ├── Valid Anagram │ └── README.md ├── Counting Bits │ └── README.md ├── Remove Duplicates from Sorted Array │ └── README.md ├── Best Time to Buy and Sell Stock │ └── README.md ├── Construct the Rectangle │ └── README.md ├── Maximum Depth of Binary Tree │ └── README.md ├── Fizz Buzz │ └── README.md ├── Intersection of Two Arrays │ └── README.md ├── Max Consecutive Ones │ └── README.md ├── Number of Segments in a String │ └── README.md ├── Plus One │ └── README.md ├── Find All Duplicates in an Array │ └── README.md ├── Intersection of Two Arrays II │ └── README.md ├── Majority Element │ └── README.md ├── Maximum Subarray │ └── README.md ├── Ransom Note │ └── README.md ├── Valid Palindrome │ └── README.md ├── Merge Sorted Array │ └── README.md ├── Valid Parentheses │ └── README.md ├── Remove Element │ └── README.md ├── Same Tree │ └── README.md ├── Happy Number │ └── README.md ├── Invert Binary Tree │ └── README.md ├── Find All Numbers Disappeared in an Array │ └── README.md ├── Hamming Distance │ └── README.md ├── Sqrt(x) │ └── README.md ├── Reverse Linked List │ └── README.md ├── Missing Number │ └── README.md ├── Next Greater Element I │ └── README.md ├── Factorial Trailing Zeroes │ └── README.md ├── Integer to Roman │ └── README.md ├── Pascal's Triangle │ └── README.md ├── Count Primes │ └── README.md ├── Remove Duplicates from Sorted List │ └── README.md ├── Sum of Left Leaves │ └── README.md ├── Third Maximum Number │ └── README.md ├── Assign Cookies │ └── README.md ├── Generate Parentheses │ └── README.md ├── Count and Say │ └── README.md ├── Teemo Attacking │ └── README.md ├── Add Digits │ └── README.md ├── Binary Tree Preorder Traversal │ └── README.md ├── Longest Palindrome │ └── README.md ├── License Key Formatting │ └── README.md ├── Integer Break │ └── README.md ├── Linked List Cycle │ └── README.md ├── Path Sum │ └── README.md ├── Permutations │ └── README.md ├── Isomorphic Strings │ └── README.md ├── Nth Digit │ └── README.md ├── Product of Array Except Self │ └── README.md ├── Reverse Vowels of a String │ └── README.md ├── House Robber │ └── README.md ├── Island Perimeter │ └── README.md ├── Binary Watch │ └── README.md ├── Arranging Coins │ └── README.md ├── Rectangle Area │ └── README.md ├── Repeated Substring Pattern │ └── README.md ├── Arithmetic Slices │ └── README.md ├── Reverse Integer │ └── README.md ├── Summary Ranges │ └── README.md ├── Odd Even Linked List │ └── README.md ├── Compare Version Numbers │ └── README.md ├── Binary Tree Level Order Traversal │ └── README.md ├── Valid Perfect Square │ └── README.md ├── Remove Nth Node From End of List │ └── README.md ├── Binary Tree Level Order Traversal II │ └── README.md ├── Divide Two Integers │ └── README.md ├── Number of 1 Bits │ └── README.md ├── Relative Ranks │ └── README.md ├── Find Bottom Left Tree Value │ └── README.md ├── Next Permutation │ └── README.md ├── Remove Linked List Elements │ └── README.md ├── K-diff Pairs in an Array │ └── README.md ├── Bulb Switcher │ └── README.md ├── Minimum Absolute Difference in BST │ └── README.md ├── Longest Common Prefix │ └── README.md ├── Best Time to Buy and Sell Stock II │ └── README.md ├── Guess Number Higher or Lower │ └── README.md ├── Symmetric Tree │ └── README.md ├── Beautiful Arrangement │ └── README.md ├── Validate Binary Search Tree │ └── README.md ├── Letter Combinations of a Phone Number │ └── README.md ├── Roman to Integer │ └── README.md ├── Lowest Common Ancestor of a Binary Search Tree │ └── README.md ├── Swap Nodes in Pairs │ └── README.md ├── Next Greater Element II │ └── README.md ├── Spiral Matrix │ └── README.md ├── Contains Duplicate II │ └── README.md ├── Set Matrix Zeroes │ └── README.md ├── Evaluate Reverse Polish Notation │ └── README.md ├── Minimum Depth of Binary Tree │ └── README.md ├── Diameter of Binary Tree │ └── README.md ├── Path Sum III │ └── README.md ├── Search Insert Position │ └── README.md ├── Min Stack │ └── README.md ├── Find Largest Value in Each Tree Row │ └── README.md ├── Binary Tree Paths │ └── README.md ├── Queue Reconstruction by Height │ └── README.md ├── Add Strings │ └── README.md ├── Merge Two Sorted Lists │ └── README.md ├── Number of Boomerangs │ └── README.md ├── 3Sum Closest │ └── README.md ├── Balanced Binary Tree │ └── README.md ├── Linked List Random Node │ └── README.md ├── Valid Sudoku │ └── README.md ├── Implement Queue using Stacks │ └── README.md ├── Intersection of Two Linked Lists │ └── README.md ├── Most Frequent Subtree Sum │ └── README.md ├── Palindrome Linked List │ └── README.md ├── ZigZag Conversion │ └── README.md ├── Search in Rotated Sorted Array │ └── README.md ├── Convert BST to Greater Tree │ └── README.md ├── Convert Sorted Array to Binary Search Tree │ └── README.md ├── First Bad Version │ └── README.md ├── Largest Number │ └── README.md ├── Find Mode in Binary Search Tree │ └── README.md ├── 01 Matrix │ └── README.md ├── Number Complement │ └── README.md ├── Top K Frequent Elements │ └── README.md ├── Output Contest Matches │ └── README.md ├── Max Points on a Line │ └── README.md ├── Sort List │ └── README.md ├── Reverse Linked List II │ └── README.md ├── Minesweeper │ └── README.md ├── Copy List with Random Pointer │ └── README.md ├── Delete Node in a BST │ └── README.md └── 3Sum │ └── README.md ├── package.json ├── request-problem.js ├── generate-md.js └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | -------------------------------------------------------------------------------- /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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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)/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)/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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)/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 | -------------------------------------------------------------------------------- /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/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/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/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/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/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/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/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/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/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/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/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)/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/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/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/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/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/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/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/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/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/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/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/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/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)/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)/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/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/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)/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 | --------------------------------------------------------------------------------