back to leetcode

Author: jyxia

Easy/125-validPalindrome.js

@@ -1,7 +1,7 @@
 /**
  * Key: use regular expression to find only alpha and numeric letters.
  * Two pointers: start and end
- * 
+ *
  * @param {string} s
  * @return {boolean}
  */
@@ -10,7 +10,7 @@ var isPalindrome = function(s) {
     s = s.match(pattern);
     if (!s || s.length === 1) return true;
     for (var i = 0; i < s.length / 2; i++) {
-        if (s[i].toLowerCase() !== s[s.length - 1 -i].toLowerCase()) return false;
+        if (s[i].toLowerCase() !== s[s.length - 1 - i].toLowerCase()) return false;
     }
 
     return true;

Easy/412-fizzBuzz.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+var fizzBuzz = function(n) {
+    var res = [];
+
+    for (var i = 1; i <= n; i++) {
+        if (i % 15 === 0) {
+            res.push('FizzBuzz');
+        } else if (i % 5 === 0) {
+            res.push('Buzz');
+        } else if (i % 3 === 0) {
+            res.push('Fizz');
+        } else {
+            res.push('' + i);
+        }
+     }
+
+     return res;
+};
+
+// try without %
+var fizzBuzz = function(n) {
+    var res = [];
+
+    for (var i = 1, fizz = 0, buzz = 0; i <= n; i++) {
+        if (fizz === 3 && buzz === 5) {
+            res.push('FizzBuzz');
+            fizz = 0;
+            buzz = 0;
+        } else if (buzz === 5) {
+            res.push('Buzz');
+            buzz = 0;
+        } else if (fizz === 3) {
+            res.push('Fizz');
+            fizz = 0;
+        } else {
+            res.push('' + i);
+            fizz++;
+            buzz++;
+        }
+     }
+
+     return res;
+};

Easy/70-climbChairs.js

@@ -19,6 +19,21 @@ var climbStairs = function(n) {
     return result;
 };
 
+// 2nd try
+var climbStairs = function(n) {
+    if (n <= 2) return n;
+    var stepOne = 1;
+    var stepTwo = 2;
+    var result;
+    for (var i = 2; i < n; i++) {
+        result = stepOne + stepTwo;
+        stepOne = stepTwo;
+        stepTwo = result;
+    }
+
+    return result;
+};
+
 // recursive, exponential complexity. Not accepted
 var climbStairs = function(n) {
     if (n === 1) return 1;

Hard/287-findDuplicateNumber.js

@@ -0,0 +1,32 @@
+/**
+ * Solution: Binary search [1, n-1]; find the mid number, count how many numbers
+ * are less than or equal to mid, if the count is more than mid, then the duplicates
+ * must exist in [1, mid], otherwise [mid+1, hi].
+ * e.g. [1,10], mid = 5,if the count of number that is <= 5 in nums (the array), then
+ * the duplicate number must be in [1,5] .... continue this binary search in this half.
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findDuplicate = function(nums) {
+    var n = nums.length;
+    var lo = 1;
+    var hi = n - 1;
+
+    while (lo < hi) {
+        var mid = lo + Math.floor((hi - lo) / 2);
+        var count = 0;
+        for (var i = 0; i < n; i++) {
+            if (nums[i] <= mid) {
+                count++;
+            }
+        }
+        if (count <= mid) {
+            lo = mid + 1;
+        } else {
+            hi = mid;
+        }
+    }
+
+    return lo;
+};

Medium/122-bestTimeToBuySellStockII.js

@@ -5,6 +5,8 @@
  * @param {number[]} prices
  * @return {number}
  */
+// This solution in fact doesn't follow the rule (you're not allowed to buy and sell at the same time),
+// But mathmatically it is right.
 var maxProfit = function(prices) {
     var maxProfit = 0;
     for (var i = 1; i < prices.length; i++) {
@@ -14,3 +16,22 @@ var maxProfit = function(prices) {
 
     return maxProfit;
 };
+
+// 2nd try, my own solution
+var maxProfit = function(prices) {
+    var maxProfit = 0;
+    var minPrice = prices[0];
+    for (var i = 0; i < prices.length;) {
+        i++;
+        while (prices[i] > prices[i-1]) {
+            i++;
+        }
+        maxProfit += prices[i-1] - minPrice;
+        minPrice = prices[i];
+    }
+    return maxProfit;
+};
+
+// test cases
+// [5,4,1,2,7,8]
+// [1,2,5,4,6,8]

Medium/268-missingNumber.js

@@ -11,6 +11,17 @@ var missingNumber = function(nums) {
   return nSum - numsSum;
 };
 
+var missingNumber = function(nums) {
+    var length = nums.length;
+    var total = 0.5 * length * (length + 1);
+    var numSum = 0;
+    for (var i = 0; i < length; i++) {
+        numSum += nums[i];
+    }
+
+    return total - numSum;
+};
+
 // solution 2 use bit manipulation
 var missingNumber = function(nums) {
   var missNum = 0;

Medium/284-peekingIterator.java

@@ -0,0 +1,41 @@
+// No JavaScript supported
+// peek() means peek next elment but pointer doesn't move (i.e. still points the next elment)
+// Solution, think the iterator as the the pointer, cache next value
+// Java Iterator interface reference:
+// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
+class PeekingIterator implements Iterator<Integer> {
+    Integer next = null;
+    Iterator<Integer> iter;
+
+	public PeekingIterator(Iterator<Integer> iterator) {
+	    // initialize any member here.
+	    this.iter = iterator;
+	    if (iter.hasNext()) {
+	        this.next = iter.next();
+	    }
+	}
+
+    // Returns the next element in the iteration without advancing the iterator.
+	public Integer peek() {
+        return this.next;
+	}
+
+	// hasNext() and next() should behave the same as in the Iterator interface.
+	// Override them if needed.
+	@Override
+	public Integer next() {
+	    Integer nextCache = next;
+	    if (iter.hasNext()) {
+	        next = iter.next();
+	    } else {
+	        next = null;
+	    }
+
+	    return nextCache;
+	}
+
+	@Override
+	public boolean hasNext() {
+	    return next != null;
+	}
+}

README.md

@@ -68,6 +68,7 @@
 * [326. Power of Three](https://leetcode.com/problems/power-of-three/) - [Solution](./Easy/326-powerOfThree.js)
 * [328. Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) - [Solution](./Easy/328-oddevenLinkedList.js)
 * [342. Power of Four](https://leetcode.com/problems/power-of-four/) - [Solution](./Easy/342-powerOfFour.js)
+* [412. Fizz Buzz](https://leetcode.com/problems/fizz-buzz/?tab=Solutions) - [Solution](./Easy/412-fizzBuzz.js)
 
 
 ##### Medium
@@ -106,8 +107,8 @@
 * [71. Simplify Path](https://leetcode.com/problems/simplify-path/) - [Solution](./Medium/71-simplifyPath.js)
 * [73. Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) - [Solution](./Medium/73-setMatrixZeroes.js)
 * [74. Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/) - [Solution](./Medium/74-search2DMatrix.js)
-* [75.  Sort Colors](https://leetcode.com/problems/sort-colors/) - [Solution](./Medium/75-sortColors.js)
-* [77.	Combinations](https://leetcode.com/problems/combinations/) - [Solution](./Medium/77-combinations.js)
+* [75. Sort Colors](https://leetcode.com/problems/sort-colors/) - [Solution](./Medium/75-sortColors.js)
+* [77. Combinations](https://leetcode.com/problems/combinations/) - [Solution](./Medium/77-combinations.js)
 * [78. Subsets](https://leetcode.com/problems/subsets/) - [Solution](./Medium/78-subsets.js)
 * [79. Word Search](https://leetcode.com/problems/word-search/) - [Solution](./Medium/79-wordSearch.js)
 * [80. Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/) - [Solution](./Medium/80-removeDuplicatesII.js)
@@ -163,6 +164,7 @@
 * [260. Single Number III](https://leetcode.com/problems/single-number-iii/) - [Solution](./Medium/260-singleNumberIII.js)
 * [268. Missing Number](https://leetcode.com/problems/missing-number/) - [Solution](./Medium/268-missingNumber.js)
 * [274. H-Index](https://leetcode.com/problems/h-index/) - [Solution](./Medium/274-hIndex.js)
+* [284. Peeking Iterator](https://leetcode.com/problems/peeking-iterator/) - [Solution](./Medium/284-peekingIterator.java)
 * [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/) - [Solution](./Medium/300-longestIncreasingSubsequence.js)
 * [309. Best Time to Buy and Sell Stock with Cooldown](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/) - [Solution](./Medium/309-bestTimeStockCooldown.js)
 * [318. Maximum Product of Word Lengths](https://leetcode.com/problems/maximum-product-of-word-lengths/) - [Solution](./Medium/318-maximumProductWordLengths.js)
@@ -186,3 +188,4 @@
 * [132. Palindrome Partitioning II](https://leetcode.com/problems/palindrome-partitioning-ii/) -  [Solution](./Hard/132-palindromePartitioningII.js)
 * [145. Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) -  [Solution](./Hard/145-binaryTreePostorder.js)
 * [154.	Find Minimum in Rotated Sorted Array II](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/) - [Solution](./Hard/154-findMinimumInRotatedSortedArray-II.js)
+* [287. Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number/) - [Solution](./Hard/287-findDuplicateNumber.js)