Add more problems.

Author: jeantimex

README.md

@@ -113,6 +113,11 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [First Missing Positive](src/array/first-missing-positive.js)
 - [Missing Ranges](src/array/missing-ranges.js)
 - [Majority Elements](src/array/majority-element.js)
+- [Find All Duplicates in an Array](src/array/find-all-duplicates-in-an-array.js)
+- [Third Maximum Number](src/array/third-maximum-number.js)
+- [Split Array with Equal Sum](src/array/split-array-with-equal-sum.js)
+- [Maximum Swap](src/array/maximum-swap.js)
+- [Candy Crush](src/candy-crush.js)
 
 ### Matrix
 
@@ -122,6 +127,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Diagonal Traverse](src/matrix/diagonal-traverse.js)
 - [Number Of Corner Rectangles](src/matrix/number-of-corner-rectangles.js)
 - [Lonely Pixel I](src/matrix/lonely-pixel-i.js)
+- [Lonely Pixel II](src/matrix/lonely-pixel-ii.js)
 - [Sparse Matrix Multiplication](src/matrix/sparse-matrix-multiplication.js)
 - [Escape The Ghosts](src/matrix/escape-the-ghosts.js)
 - [Brick Wall](src/matrix/brick-wall.js)
@@ -366,6 +372,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 ### Depth First Search
 
 - [Number of Islands](src/dfs/number-of-islands.js)
+- [Max Area of Island](src/dfs/max-area-of-island.js)
 - [Next Closest Time](src/dfs/next-closest-time.js)
 - [Decode String](src/dfs/decode-string.js)
 - [Pacific Atlantic Water Flow](src/dfs/pacific-atlantic-water-flow.js)
@@ -444,6 +451,7 @@ A collection of JavaScript problems and solutions for studying algorithms.
 - [Largest Sum of Averages](src/dynamic-programing/largest-sum-of-averages.js)
 - [Maximum Sum of 3 Non-Overlapping Subarrays](src/dynamic-programming/maximum-sum-of-3-non-overlapping-subarrays.js)
 - [Maximal Rectangle](src/dynamic-programming/maximal-rectangle.js)
+- [Min Cost Climbing Stairs](src/dynamic-programming/min-cost-climbing-stairs.js)
 - [House Robber](src/dynamic-programming/house-robber.js)
 - [House Robber II](src/dynamic-programming/house-robber-ii.js)
 - [Paint Fence](src/dynamic-programming/paint-fence.js)

src/array/candy-crush.js

@@ -0,0 +1,78 @@
+/**
+ * Candy Crush
+ *
+ * This question is about implementing a basic elimination algorithm for Candy Crush.
+ *
+ * Given a 2D integer array board representing the grid of candy, different positive integers board[i][j]
+ * represent different types of candies. A value of board[i][j] = 0 represents that the cell at position (i, j)
+ * is empty. The given board represents the state of the game following the player's move.
+ *
+ * Now, you need to restore the board to a stable state by crushing candies according to the following rules:
+ *
+ * If three or more candies of the same type are adjacent vertically or horizontally, "crush" them all at the
+ * same time - these positions become empty.
+ *
+ * After crushing all candies simultaneously, if an empty space on the board has candies on top of itself,
+ * then these candies will drop until they hit a candy or bottom at the same time. (No new candies will drop
+ * outside the top boundary.)
+ *
+ * After the above steps, there may exist more candies that can be crushed. If so, you need to repeat the above steps.
+ *
+ * If there does not exist more candies that can be crushed (ie. the board is stable), then return the current board.
+ * You need to perform the above rules until the board becomes stable, then return the current board.
+ *
+ * Note:
+ * The length of board will be in the range [3, 50].
+ * The length of board[i] will be in the range [3, 50].
+ * Each board[i][j] will initially start as an integer in the range [1, 2000].
+ */
+
+/**
+ * @param {number[][]} board
+ * @return {number[][]}
+ */
+const candyCrush = board => {
+  const m = board.length;
+  const n = board[0].length;
+
+  let shouldContinue = false;
+
+  // Crush horizontally
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n - 2; j++) {
+      const v = Math.abs(board[i][j]);
+      if (v && v === Math.abs(board[i][j + 1]) && v === Math.abs(board[i][j + 2])) {
+        board[i][j] = board[i][j + 1] = board[i][j + 2] = -v;
+        shouldContinue = true;
+      }
+    }
+  }
+
+  // Crush vertically
+  for (let i = 0; i < m - 2; i++) {
+    for (let j = 0; j < n; j++) {
+      const v = Math.abs(board[i][j]);
+      if (v && v === Math.abs(board[i + 1][j]) && v === Math.abs(board[i + 2][j])) {
+        board[i][j] = board[i + 1][j] = board[i + 2][j] = -v;
+        shouldContinue = true;
+      }
+    }
+  }
+
+  // Drop vertically
+  for (let j = 0; j < n; j++) {
+    let row = m - 1;
+    for (let i = m - 1; i >= 0; i--) {
+      if (board[i][j] >= 0) {
+        board[row--][j] = board[i][j];
+      }
+    }
+    for (let i = row; i >= 0; i--) {
+      board[i][j] = 0;
+    }
+  }
+
+  return shouldContinue ? candyCrush(board) : board;
+};
+
+export { candyCrush };

src/array/find-all-duplicates-in-an-array.js

@@ -0,0 +1,39 @@
+/**
+ * Find All Duplicates in an Array
+ *
+ * Given an array of integers, 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.
+ *
+ * Find all the elements that appear twice in this array.
+ *
+ * Could you do it without extra space and in O(n) runtime?
+ *
+ * Example:
+ *
+ * Input:
+ * [4,3,2,7,8,2,3,1]
+ *
+ * Output:
+ * [2,3]
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findDuplicates = nums => {
+  const result = [];
+
+  for (let i = 0; i < nums.length; i++) {
+    const index = Math.abs(nums[i]) - 1;
+
+    if (nums[index] < 0) {
+      result.push(Math.abs(nums[i]));
+    } else {
+      nums[index] = -nums[index];
+    }
+  }
+
+  return result;
+};
+
+export { findDuplicates };

src/array/maximum-swap.js

@@ -0,0 +1,49 @@
+/**
+ * Maximum Swap
+ *
+ * Given a non-negative integer, you could swap two digits at most once to get the maximum valued number.
+ * Return the maximum valued number you could get.
+ *
+ * Example 1:
+ *
+ * Input: 2736
+ * Output: 7236
+ * Explanation: Swap the number 2 and the number 7.
+ *
+ * Example 2:
+ *
+ * Input: 9973
+ * Output: 9973
+ * Explanation: No swap.
+ */
+
+/**
+ * @param {number} num
+ * @return {number}
+ */
+const maximumSwap = num => {
+  const digits = num.toString().split('');
+
+  // Use buckets to record the last position of digit 0 ~ 9 in this num.
+  const buckets = Array(10).fill(-1);
+  for (let i = 0; i < digits.length; i++) {
+    buckets[digits[i] - '0'] = i;
+  }
+
+  // Loop through the num array from left to right. For each position,
+  // we check whether there exists a larger digit in this num (start from 9 to current digit).
+  // We also need to make sure the position of this larger digit is behind the current one.
+  // If we find it, simply swap these two digits and return the result.
+  for (let i = 0; i < digits.length; i++) {
+    for (let k = 9; k > digits[i] - '0'; k--) {
+      if (buckets[k] > i) {
+        [digits[i], digits[buckets[k]]] = [digits[buckets[k]], digits[i]];
+        return parseInt(digits.join(''));
+      }
+    }
+  }
+
+  return num;
+};
+
+export { maximumSwap };

src/array/split-array-with-equal-sum.js

@@ -0,0 +1,72 @@
+/**
+ * Split Array with Equal Sum
+ *
+ * Given an array with n integers, you need to find if there are triplets (i, j, k) which satisfies
+ * following conditions:
+ *
+ * 0 < i, i + 1 < j, j + 1 < k < n - 1
+ *
+ * Sum of subarrays (0, i - 1), (i + 1, j - 1), (j + 1, k - 1) and (k + 1, n - 1) should be equal.
+ * where we define that subarray (L, R) represents a slice of the original array starting from the element
+ * indexed L to the element indexed R.
+ *
+ * Example:
+ *
+ * Input: [1,2,1,2,1,2,1]
+ * Output: True
+ *
+ * Explanation:
+ *
+ * i = 1, j = 3, k = 5.
+ * sum(0, i - 1) = sum(0, 0) = 1
+ * sum(i + 1, j - 1) = sum(2, 2) = 1
+ * sum(j + 1, k - 1) = sum(4, 4) = 1
+ * sum(k + 1, n - 1) = sum(6, 6) = 1
+ *
+ * Note:
+ * 1 <= n <= 2000.
+ * Elements in the given array will be in range [-1,000,000, 1,000,000].
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const splitArray = nums => {
+  if (nums.length < 7) {
+    return false;
+  }
+
+  // Step 1. Calculate the prefix sum
+  const sum = Array(nums.length).fill(0);
+  sum[0] = nums[0];
+  for (let i = 1; i < nums.length; i++) {
+    sum[i] = sum[i - 1] + nums[i];
+  }
+
+  // Here j is used for middle cut, i for left cut and k for right cut.
+  // Iterate middle cuts and then find left cuts which divides the first
+  // half into two equal quarters, store that quarter sums in the hashset.
+  // Then find right cuts which divides the second half into two equal
+  // quarters and check if quarter sum is present in the hashset.
+  // If yes return true.
+  for (let j = 3; j < nums.length - 3; j++) {
+    const set = new Set();
+
+    for (let i = 1; i < j - 1; i++) {
+      if (sum[i - 1] == sum[j - 1] - sum[i]) {
+        set.add(sum[i - 1]);
+      }
+    }
+
+    for (let k = j + 2; k < nums.length - 1; k++) {
+      if (sum[nums.length - 1] - sum[k] == sum[k - 1] - sum[j] && set.has(sum[k - 1] - sum[j])) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+};
+
+export { splitArray };

src/array/third-maximum-number.js

@@ -0,0 +1,62 @@
+/**
+ * Third Maximum Number
+ *
+ * Given a non-empty array of integers, return the third maximum number in this array.
+ * If it does not exist, return the maximum number. The time complexity must be in O(n).
+ *
+ * Example 1:
+ *
+ * Input: [3, 2, 1]
+ *
+ * Output: 1
+ *
+ * Explanation: The third maximum is 1.
+ *
+ * Example 2:
+ *
+ * Input: [1, 2]
+ *
+ * Output: 2
+ *
+ * Explanation: The third maximum does not exist, so the maximum (2) is returned instead.
+ *
+ * Example 3:
+ *
+ * Input: [2, 2, 3, 1]
+ *
+ * Output: 1
+ *
+ * Explanation: Note that the third maximum here means the third maximum distinct number.
+ * Both numbers with value 2 are both considered as second maximum.
+ */
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const thirdMax = nums => {
+  let first = -Infinity;
+  let second = -Infinity;
+  let third = -Infinity;
+
+  for (let num of nums) {
+    if (num === first || num === second || num === third) {
+      continue;
+    }
+
+    if (num > first) {
+      third = second;
+      second = first;
+      first = num;
+    } else if (num > second) {
+      third = second;
+      second = num;
+    } else if (num > third) {
+      third = num;
+    }
+  }
+
+  return third === -Infinity ? first : third;
+};
+
+export { thirdMax };