Merge branch 'release/1.24.0'

Author: ecgan

README.md

@@ -48,19 +48,42 @@ The listing below is sorted based on LeetCode #. If you are interested to see my
 | LeetCode # | Title | Difficulty | Topics |
 |-----------:|:------|:-----------|:-------|
 | 1 | [Two Sum](/problems/two-sum) | Easy | Array, hash table |
+| 33 | [Search in Rotated Sorted Array](/problems/search-in-rotated-sorted-array) | Medium | Array, Binary Search |
 | 35 | [Search Insert Position](/problems/search-insert-position) | Easy | Array, binary search |
+| 49 | [Group Anagrams](/problems/group-anagrams) | Medium | Hash Table, String |
 | 53 | [Maximum Subarray](/problems/maximum-subarray) | Easy | Array, Divide and Conquer, Dynamic Programming |
+| 55 | [Jump Game](/problems/jump-game) | Medium | Array, Greedy |
+| 64 | [Minimum Path Sum](/problems/minimum-path-sum) | Medium | Array, Dynamic Programming |
 | 70 | [Climbing Stairs](/problems/climbing-stairs) | Easy | Dynamic Programming |
 | 121 | [Best Time to Buy and Sell Stock](/problems/best-time-to-buy-and-sell-stock) | Easy | Array, Dynamic Programming |
+| 122 | [Best Time to Buy and Sell Stock II](/problems/best-time-to-buy-and-sell-stock-ii) | Easy | Array, Greedy |
+| 124 | [Binary Tree Maximum Path Sum](/problems/binary-tree-maximum-path-sum) | Hard | Tree, Depth-first Search |
 | 136 | [Single Number](/problems/single-number) | Easy | Hash table, bit manipulation |
+| 146 | [LRU Cache](/problems/lru-cache) | Medium | Design |
+| 155 | [Min Stack](/problems/min-stack) | Easy | Stack, Design |
 | 189 | [Rotate Array](/problems/rotate-array) | Easy | Array |
 | 198 | [House Robber](/problems/house-robber) | Easy | Dynamic Programming |
+| 200 | [Number of Islands](/problems/number-of-islands) | Medium | Depth-first Search, Breadth-first Search, Union Find |
+| 201 | [Bitwise AND of Numbers Range](/problems/bitwise-and-of-numbers-range) | Medium | Bit Manipulation |
+| 202 | [Happy Number](/problems/happy-number) | Easy | Hash Table, Math |
+| 221 | [Maximal Square](/problems/maximal-square) | Medium | Dynamic Programming |
+| 238 | [Product of Array Except Self](/problems/product-of-array-except-self) | Medium | Array |
+| 283 | [Move Zeroes](/problems/move-zeroes) | Easy | Array, Two Pointers |
 | 303 | [Range Sum Query - Immutable](/problems/range-sum-query-immutable) | Easy | Dynamic Programming |
 | 349 | [Intersection of Two Arrays](/problems/intersection-of-two-arrays) | Easy | Hash table, two pointers, binary search, sort, set |
 | 350 | [Intersection of Two Arrays II](/problems/intersection-of-two-arrays-ii) | Easy | Hash Table, two pointers, binary search, sort |
 | 392 | [Is Subsequence](/problems/is-subsequence) | Easy | Binary Search, Dynamic Programming, Greedy |
+| 525 | [Contiguous Array](/problems/contiguous-array) | Medium | Hash Table |
+| 543 | [Diameter of Binary Tree](/problems/diameter-of-binary-tree) | Easy | Tree |
+| 560 | [Subarray Sum Equals K](/problems/subarray-sum-equals-k) | Medium | Array, Hash Table |
+| 678 | [Valid Parenthesis String](/problems/valid-parenthesis-string) | Medium | String |
 | 746 | [Min Cost Climbing Stairs](/problems/min-cost-climbing-stairs) | Easy | Array, Dynamic Programming |
+| 844 | [Backspace String Compare](/problems/backspace-string-compare) | Easy | Two Pointers, Stack |
+| 876 | [Middle of the Linked List](/problems/middle-of-the-linked-list) | Easy | Linked List |
+| 1008 | [Construct Binary Search Tree from Preorder Traversal](/problems/construct-binary-search-tree-from-preorder-traversal) | Medium | Tree |
 | 1025 | [Divisor Game](/problems/divisor-game) | Easy | Math, Dynamic Programming |
+| 1046 | [Last Stone Weight](/problems/last-stone-weight) | Easy | Heap, Greedy |
+| 1143 | [Longest Common Subsequence](/problems/longest-common-subsequence) | Medium | Dynamic Programming |
 | 1144 | [Decrease Elements To Make Array Zigzag](/problems/decrease-elements-to-make-array-zigzag) | Medium | Array |
 | 1145 | [Binary Tree Coloring Game](/problems/binary-tree-coloring-game/) | Medium | Tree, depth-first search |
 | 1150 | [Check If a Number Is Majority Element in a Sorted Array](/problems/is-a-a-majority-element) | Easy | Array, binary search |
@@ -119,6 +142,11 @@ The listing below is sorted based on LeetCode #. If you are interested to see my
 | 1417 | [Reformat The String](/problems/reformat-the-string) | Easy | String |
 | 1418 | [Display Table of Food Orders in a Restaurant](/problems/display-table-of-food-orders-in-a-restaurant) | Medium | Hash Table |
 | 1419 | [Minimum Number of Frogs Croaking](/problems/minimum-number-of-frogs-croaking) | Medium | String |
+| 1426 | [Counting Elements](/problem/counting-elements) | - | - |
+| 1427 | [Perform String Shifts](/problems/perform-string-shifts) | - | - |
+| 1428 | [Leftmost Column with at Least a One](/problems/leftmost-column-with-at-least-a-one) | - | - |
+| 1429 | [First Unique Number](/problems/first-unique-number) | - | - |
+| 1430 | [Check If a String Is a Valid Sequence from Root to Leaves Path in a Binary Tree](/problems/check-if-a-string-is-a-valid-sequence-from-root-to-leaves-path-in-a-binary-tree) | - | - |
 
 ## Questions / Issues
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "leetcode",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "My solutions for LeetCode problems.",
   "main": "index.js",
   "scripts": {

package.json

@@ -0,0 +1,67 @@
+# Backspace String Compare
+
+LeetCode #: [844](https://leetcode.com/problems/backspace-string-compare/)
+
+Difficulty: Easy
+
+Topics: Two Pointers, Stack.
+
+## Problem
+
+Given two strings `S` and `T`, return if they are equal when both are typed into empty text editors. `#` means a backspace character.
+
+Example 1:
+
+```text
+Input: S = "ab#c", T = "ad#c"
+Output: true
+Explanation: Both S and T become "ac".
+```
+
+Example 2:
+
+```text
+Input: S = "ab##", T = "c#d#"
+Output: true
+Explanation: Both S and T become "".
+```
+
+Example 3:
+
+```text
+Input: S = "a##c", T = "#a#c"
+Output: true
+Explanation: Both S and T become "c".
+```
+
+Example 4:
+
+```text
+Input: S = "a#c", T = "b"
+Output: false
+Explanation: S becomes "c" while T becomes "b".
+```
+
+Note:
+
+* `1 <= S.length <= 200`
+* `1 <= T.length <= 200`
+* `S` and `T` only contain lowercase letters and `'#'` characters.
+
+Follow up:
+
+* Can you solve it in `O(N)` time and `O(1)` space?
+
+## Solution Explanation
+
+The solution uses a two-pointer approach and performs the character comparison from the back of the strings.
+
+If there is a `#` character, it will loop and skip towards the start of the string accordingly.
+
+As soon as the string comparison fail, it will return `false` and exit immediately.
+
+## Complexity Analysis
+
+Time complexity: O(length of S + length of T)
+
+Space complexity: O(1)

problems/backspace-string-compare/README.md

@@ -0,0 +1,58 @@
+/**
+ * @param {string} S
+ * @param {string} T
+ * @return {boolean}
+ */
+const backspaceCompare = function (S, T) {
+  let i = S.length - 1
+  let j = T.length - 1
+  let backspaceS = 0
+  let backspaceT = 0
+
+  while (i >= 0 || j >= 0) {
+    while (i >= 0) {
+      const s = S[i]
+
+      if (s === '#') {
+        backspaceS++
+        i--
+        continue
+      }
+
+      if (backspaceS > 0) {
+        backspaceS--
+        i--
+        continue
+      }
+
+      break
+    }
+
+    while (j >= 0) {
+      if (T[j] === '#') {
+        backspaceT++
+        j--
+        continue
+      }
+
+      if (backspaceT > 0) {
+        backspaceT--
+        j--
+        continue
+      }
+
+      break
+    }
+
+    if (S[i] !== T[j]) {
+      return false
+    }
+
+    i--
+    j--
+  }
+
+  return true
+}
+
+module.exports = backspaceCompare

problems/backspace-string-compare/backspaceCompare.js

@@ -0,0 +1,64 @@
+const backspaceCompare = require('./backspaceCompare')
+
+test('Example 1', () => {
+  const S = 'ab#c'
+  const T = 'ad#c'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(true)
+})
+
+test('Example 2', () => {
+  const S = 'ab##'
+  const T = 'c#d#'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(true)
+})
+
+test('Example 3', () => {
+  const S = 'a##c'
+  const T = '#a#c'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(true)
+})
+
+test('Example 4', () => {
+  const S = 'a#c'
+  const T = 'b'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(false)
+})
+
+test('test', () => {
+  const S = '###'
+  const T = 'bbb'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(false)
+})
+
+test('test 2', () => {
+  const S = '###bbb'
+  const T = 'bbb'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(true)
+})
+
+test('test 3', () => {
+  const S = 'bbbextm'
+  const T = 'bbb#extm'
+
+  const result = backspaceCompare(S, T)
+
+  expect(result).toBe(false)
+})

problems/backspace-string-compare/backspaceCompare.test.js

@@ -0,0 +1,43 @@
+# Best Time to Buy and Sell Stock II
+
+LeetCode #: [122](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)
+
+Difficulty: Easy
+
+Topics: Array, Greedy.
+
+## Problem
+
+Say you have an array for which the `i`th element is the price of a given stock on day `i`.
+
+Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).
+
+Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+
+Example 1:
+
+```text
+Input: [7,1,5,3,6,4]
+Output: 7
+Explanation:
+Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+```
+
+Example 2:
+
+```text
+Input: [1,2,3,4,5]
+Output: 4
+Explanation:
+Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again.
+```
+
+Example 3:
+
+```text
+Input: [7,6,4,3,1]
+Output: 0
+Explanation: In this case, no transaction is done, i.e. max profit = 0.
+```

problems/best-time-to-buy-and-sell-stock-ii/README.md

@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+const maxProfit = function (prices) {
+  let sum = 0
+
+  for (let i = 1; i < prices.length; i++) {
+    const profit = prices[i] - prices[i - 1]
+    if (profit > 0) {
+      sum += profit
+    }
+  }
+
+  return sum
+}
+
+module.exports = maxProfit

problems/best-time-to-buy-and-sell-stock-ii/maxProfit.js

@@ -0,0 +1,25 @@
+const maxProfit = require('./maxProfit')
+
+test('Example 1', () => {
+  const prices = [7, 1, 5, 3, 6, 4]
+
+  const result = maxProfit(prices)
+
+  expect(result).toBe(7)
+})
+
+test('Example 2', () => {
+  const prices = [1, 2, 3, 4, 5]
+
+  const result = maxProfit(prices)
+
+  expect(result).toBe(4)
+})
+
+test('Example 3', () => {
+  const prices = [7, 6, 4, 3, 1]
+
+  const result = maxProfit(prices)
+
+  expect(result).toBe(0)
+})

problems/best-time-to-buy-and-sell-stock-ii/maxProfit.test.js

@@ -0,0 +1,39 @@
+# Binary Tree Maximum Path Sum
+
+LeetCode #: [124](https://leetcode.com/problems/binary-tree-maximum-path-sum/)
+
+Difficulty: Hard.
+
+Topics: Tree, Depth-first Search.
+
+## Problem
+
+Given a non-empty binary tree, find the maximum path sum.
+
+For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path must contain at least one node and does not need to go through the root.
+
+Example 1:
+
+```text
+Input: [1,2,3]
+
+       1
+      / \
+     2   3
+
+Output: 6
+```
+
+Example 2:
+
+```text
+Input: [-10,9,20,null,null,15,7]
+
+   -10
+   / \
+  9  20
+    /  \
+   15   7
+
+Output: 42
+```