Add new hash table problems and notes

Author: enginebai

leetcode/1346.check-if-n-and-its-double-exist.md

@@ -1,19 +1,78 @@
-## [1346. Check If N and Its Double Exist](https://leetcode.com/problems/check-if-n-and-its-double-exist/)
+# [1346. Check If N and Its Double Exist](https://leetcode.com/problems/check-if-n-and-its-double-exist/description/)
 
-### Hash Table
+## Test Cases
+### Normal Cases
+```
+Input: [10, ..., 5, ...]
+Output: true
+
+Input: [7, 1, 2]
+Output: false
+```
+### Edge / Corner Cases
+* The array contains the same number more than once.
+```
+Input: [8, 1, 2, 8, 9]
+Output: false
+```
+* The number is negative.
+```
+Input: [-10, 1, -20, 5]
+Output: true
+```
+* There is one `0's` or multiple `0's`.
+```
+Input: [0, 1, 2, 0]
+Output: true
+
+Input: [3, 2, 0, 5]
+Output: false
+```
+
+## Hash Set
+We iterate every number and check if it's double or half is in the set.
 
 ```kotlin
 fun checkIfExist(arr: IntArray): Boolean {
-    val seen = hashSetOf<Int>()
-    arr.forEach { value ->
-        if (seen.contains(value * 2) || (value % 2 == 0 && seen.contains(value / 2))) {
-            return true
-        }
-        seen.add(value)
+    val set = HashSet<Int>()
+    for (num in arr) {
+        if (num * 2 in set) return true
+        if (num % 2 == 0 && num / 2 in set) return true
+        set.add(num)
     }
     return false
 }
 ```
 
-* **Time Complexity**: `O(n)` for only one for-loop.
-* **Space Complexity**: `O(n)` to store the seen set.
+* **Time Complexity:** `O(n)`
+* **Space Complexity:** `O(n)`
+
+## Binary Search
+We can sort the array, and iterate each number to find its double using binary search.
+
+```kotlin
+fun checkIfExist(arr: IntArray): Boolean {
+    arr.sort()
+    for (i in arr.indices) {
+        val num = arr[i]
+        val foundIndex = binarySearch(arr, num * 2)
+        if (foundIndex != -1 && foundIndex != i) return true
+    }
+    return false
+}
+
+private fun binarySearch(arr: IntArray, target: Int): Int {
+    var left = 0
+    var right = arr.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (arr[middle] == target) return middle
+        if (arr[middle] < target) left = middle + 1
+        else right = middle - 1
+    }
+    return -1 // Not found
+}
+```
+
+* **Time Complexity:** `O(n log n)`
+* **Space Complexity:** `O(log n)`

leetcode/141.linked-list-cycle.md

@@ -1,5 +1,6 @@
-## [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)
+# [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)
 
+## Hash Set
 ```kotlin
 fun hasCycle(head: ListNode?): Boolean {
     val seenNode = hashSetOf<ListNode>()
@@ -15,6 +16,7 @@ fun hasCycle(head: ListNode?): Boolean {
 }
 ```
 
+## Two Pointers
 We can use two pointers approach to solve this with `O(1)` space:
 1. Slow pointer goes 1 step, fast pointer goes 2 step.
 2. Traverse the linked list.

leetcode/1636.sort-array-by-increasing-frequency.md

@@ -0,0 +1,56 @@
+# [1636. Sort Array by Increasing Frequency](https://leetcode.com/problems/sort-array-by-increasing-frequency/description/)
+
+## Hash Table + Sorting
+```kotlin
+// Sort the map directly
+fun frequencySort(nums: IntArray): IntArray {
+    val countMap = HashMap<Int, Int>()
+    for (num in nums) {
+        countMap[num] = (countMap[num] ?: 0) + 1
+    }
+    val sortedMap =
+        countMap
+            .toList()
+            .sortedWith(compareBy<Pair<Int, Int>> { (_, value) -> value }
+                .thenByDescending { it.first })
+            .toMap()
+    val ans = IntArray(nums.size)
+    var i = 0
+    for ((k, v) in sortedMap) {
+        repeat(v) {
+            ans[i++] = k
+        } 
+    }
+    return ans
+}
+
+// Using Java Collections API
+fun frequencySort(nums: IntArray): IntArray {
+    val countMap = HashMap<Int, Int>()
+    for (num in nums) {
+        countMap[num] = (countMap[num] ?: 0) + 1
+    }
+    val ans = MutableList(nums.size) { nums[it] }
+    Collections.sort(ans) { n1, n2 ->
+        val count1 = countMap[n1]!!
+        val count2 = countMap[n2]!!
+        if (count1 == count2) n2 - n1
+        else count1 - count2
+    }
+    return ans.toIntArray()
+}
+
+// Using Kotlin APIs
+fun frequencySort(nums: IntArray): IntArray {
+    val countMap = HashMap<Int, Int>()
+    for (num in nums) {
+        countMap[num] = (countMap[num] ?: 0) + 1
+    }
+
+    val ans = nums.sortedWith(compareBy<Int> { countMap[it] }.thenByDescending { it })
+    // Or equivalently
+    // val ans = nums.sortedWith(compareBy({ countMap[it] }, {-it}))
+
+    return ans.toIntArray()
+}
+```

leetcode/1876.substrings-of-size-three-with-distinct-characters.md

@@ -1,5 +1,7 @@
 ## [1876. Substrings of Size Three with Distinct Characters](https://leetcode.com/problems/substrings-of-size-three-with-distinct-characters)
 
+> TODO: Add solution of fixed size sliding window.
+
 ```kotlin
 fun countGoodSubstrings(s: String): Int {
     if (s.length < 3) return 0

leetcode/202.happy-number.md

@@ -0,0 +1,29 @@
+# [202. Happy Number](https://leetcode.com/problems/happy-number/description/)
+
+## Two Pointers
+We use the same idea of [141. Linked List Cycle](../leetcode/141.linked-list-cycle.md) to solve this problem. We use two pointers to detect the cycle.
+
+```kotlin
+fun isHappy(n: Int): Boolean {
+    var fast = n
+    var slow = n
+    do {
+        fast = sumDigits(sumDigits(fast))
+        slow = sumDigits(slow)
+    } while (fast != slow)
+    return slow == 1
+}
+private fun sumDigits(n: Int): Int {
+    var sum = 0
+    var nn = n
+    while (nn > 0) {
+        sum += (nn * 1.0 % 10).pow(2.0).toInt()
+        nn /= 10
+    }
+    return sum
+}
+```
+
+```js
+
+```

leetcode/209.minimum-size-subarray-sum.md

@@ -21,7 +21,7 @@ Output: 0
 ### Edge / Corner Cases
 > TODO: Can't think of any edge cases.
 
-## Prefix Sum
+## Prefix Sum (Not Optimal)
 We can apply prefix sum approach to find the sum of subarray.
 
 ```js
@@ -64,6 +64,23 @@ fun minSubArrayLen(target: Int, nums: IntArray): Int {
 * Then we reduce the window size by increasing the starting index until `[start..end]` < `target` so that we can get the **minimum** size of subarray that meets the requirement.
 
 ```kotlin
+fun minSubArrayLen(target: Int, nums: IntArray): Int {
+    var sum = 0
+    var left = 0
+    var ans = Int.MAX_VALUE
+    for (right in nums.indices) {
+        sum += nums[right]
+        while (sum >= target) {
+            // We update the result here, because the window is valid
+            ans = minOf(ans, right - left + 1)
+            sum -= nums[left]
+            left++
+        }
+    }
+    return if (ans == Int.MAX_VALUE) 0 else ans
+}
+
+// Or equivalently, followed our general sliding window template.
 fun minSubArrayLen(target: Int, nums: IntArray): Int {
     var minLength = Int.MAX_VALUE
     var start = 0
@@ -91,4 +108,4 @@ fun minSubArrayLen(target: Int, nums: IntArray): Int {
 * **Time Complexity**: `O(n)`, we move ending index and then starting index, that just scaned through array.
 * **Space Complexity**: `O(1)` for no extra space.
 
-> TODO: Add binary search and two pointer solution. https://leetcode.com/problems/minimum-size-subarray-sum/editorial/
+> TODO: Add binary search and two pointer solution. https://leetcode.com/problems/minimum-size-subarray-sum/solutions/59090/c-o-n-and-o-nlogn/

leetcode/290.word-pattern.md

@@ -6,6 +6,8 @@ fun wordPattern(pattern: String, s: String): Boolean {
     if (pattern.length != split.size) return false
 
     val match = Array<String>(26) { "" }
+
+    // Or we can use reversed map to check if the word is already mapped to a character.
     val seen = hashSetOf<String>()
     for (i in 0 until pattern.length) {
         val c = pattern[i]

leetcode/3325.count-substrings-with-k-frequency-characters-i.md

@@ -1,7 +1,8 @@
 # [3325. Count Substrings With K-Frequency Characters I](https://leetcode.com/problems/count-substrings-with-k-frequency-characters-i/description/)
 
 ## Sliding Window
-We maintain a window that contains at least one `k` frequency characters. We expand the window by moving the `right` pointer until the substrings has at least one `k` frequency characters.
+* Window: the substrings that contain at least `k` frequency characters.
+* We expand the window by moving the `right` pointer until the substrings has at least one `k` frequency characters.
 
 ```js
 k = 2

leetcode/350.intersection-of-two-arrays-ii.md

@@ -1,6 +1,7 @@
-## [350. Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)
-### Hash Table
-**Idea!!** Count the occurrence of every elements in both arrays, and iterate the unique elements to find the common part. For example, `[1, 2, 3, 2, 4]` and `[2, 2, 2, 3, 3]`, we will get `count1 = {1: 1, 2: 2, 3: 1, 4: 1}` and `count2 = {2: 3, 3: 2}`. Then we iterate `count1` and find the common part.
+# [350. Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/)
+
+## Hash Table
+**Idea!!** Count the occurrence of every elements in both arrays, and iterate the unique elements to find the common part. For example, `[1, 2, 3, 2, 4]` and `[2, 2, 2, 3, 3]`, we will get `count1 = {1: 1, 2: 2, 3: 1, 4: 1}` and `count2 = {2: 3, 3: 2}`. Then we iterate `count1` and find the common part = `min(count1[key], count2[key])`.
 
 ```js
 value   count1  count2  common
@@ -88,7 +89,7 @@ fun intersect(nums1: IntArray, nums2: IntArray): IntArray {
 * **Time Complexity**: `O(m + n)`.
 * **Space Complexity**: `O(min(m, n))` for hash table.
 
-### Two Pointers
+## Two Pointers
 Or we can sort both the arrays, then use two pointers to find the common part.
 
 ```js

leetcode/381.insert-delete-getrandom-o1-duplicates-allowed.md

@@ -0,0 +1,64 @@
+# [381. Insert Delete GetRandom O(1) - Duplicates allowed](https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/description/)
+
+## Hash Table
+We extend the same idea from [380. Insert Delete GetRandom O(1)](../leetcode/380.insert-delete-getrandom-o1.md). 
+
+
+We store all the index of each element in a hash table. When we remove an element, we swap it with the last element in the list and update the index of the last element in the hash table. This way, we can remove an element in O(1) time.
+
+```kotlin
+class RandomizedCollection() {
+
+    // {value: {index}}
+    private val valueIndexMap = HashMap<Int, HashSet<Int>>()
+    private val values = mutableListOf<Int>()
+
+    // Return true if not exist, false if exist.
+    fun insert(`val`: Int): Boolean {
+        values.add(`val`)
+        if (`val` in valueIndexMap) {
+            valueIndexMap[`val`]!!.add(values.lastIndex)
+            return false
+        } else {
+            valueIndexMap[`val`] = HashSet<Int>()
+            valueIndexMap[`val`]!!.add(values.lastIndex)
+            return true
+        }
+    }
+
+    // Return true if exist, false if not exist.
+    fun remove(`val`: Int): Boolean {
+        if (`val` !in valueIndexMap) {
+            return false
+        }
+        val indexes = valueIndexMap[`val`]!!
+
+        // Take one index of the value to remove
+        val index = indexes.iterator().next()
+
+        // Remove the index of `val` from map, and remove key if the set becomes empty
+        indexes.remove(index)
+        if (indexes.isEmpty()) {
+            valueIndexMap.remove(`val`)
+        }
+
+        // We move the last element to the current index, and update the index of last element in map
+        val lastValue = values.last()
+        values[index] = lastValue
+        
+        // Update the index of last element in map
+        valueIndexMap[lastValue]?.remove(values.lastIndex)
+        valueIndexMap[lastValue]?.add(index)
+
+        // Remove the last element from list
+        values.removeAt(values.lastIndex)
+        return true
+    }
+
+    fun getRandom(): Int {
+        val index = (Math.random() * values.size).toInt()
+        return values[index]
+    }
+
+}
+```