Added tasks 371, 372, 373, 374.

Author: ThanhNIT

README.md

@@ -1029,6 +1029,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 0191 |[Number of 1 Bits](src.save/main/kotlin/g0101_0200/s0191_number_of_1_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation | 237 | 68.44
 | 0190 |[Reverse Bits](src.save/main/kotlin/g0101_0200/s0190_reverse_bits/Solution.kt)| Easy | Top_Interview_Questions, Bit_Manipulation, Divide_and_Conquer | 198 | 81.82
 | 0338 |[Counting Bits](src/main/kotlin/g0301_0400/s0338_counting_bits/Solution.kt)| Easy | Top_100_Liked_Questions, Dynamic_Programming, Bit_Manipulation | 186 | 99.26
+| 0371 |[Sum of Two Integers](src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 129 | 95.45
 | 0029 |[Divide Two Integers](src.save/main/kotlin/g0001_0100/s0029_divide_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation | 281 | 31.67
 
 #### Udemy Design
@@ -1522,6 +1523,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0374 |[Guess Number Higher or Lower](src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/GuessGame.kt)| |||
 
 #### Day 2
 
@@ -1606,6 +1608,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.6'
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
 | 0394 |[Decode String](src/main/kotlin/g0301_0400/s0394_decode_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Stack, Recursion, Level_1_Day_14_Stack, Udemy_Strings | 224 | 64.86
 | 0378 |[Kth Smallest Element in a Sorted Matrix](src/main/kotlin/g0301_0400/s0378_kth_smallest_element_in_a_sorted_matrix/Solution.kt)| Medium | Top_Interview_Questions, Array, Sorting, Binary_Search, Matrix, Heap_Priority_Queue | 522 | 59.78
+| 0374 |[Guess Number Higher or Lower](src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/GuessGame.kt)| |||
+| 0373 |[Find K Pairs with Smallest Sums](src/main/kotlin/g0301_0400/s0373_find_k_pairs_with_smallest_sums/Solution.kt)| Medium | Array, Heap_Priority_Queue | 1809 | 80.95
+| 0372 |[Super Pow](src/main/kotlin/g0301_0400/s0372_super_pow/Solution.kt)| Medium | Math, Divide_and_Conquer | 196 | 100.00
+| 0371 |[Sum of Two Integers](src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/Solution.kt)| Medium | Top_Interview_Questions, Math, Bit_Manipulation, Udemy_Bit_Manipulation | 129 | 95.45
 | 0368 |[Largest Divisible Subset](src/main/kotlin/g0301_0400/s0368_largest_divisible_subset/Solution.kt)| Medium | Array, Dynamic_Programming, Math, Sorting | 412 | 73.33
 | 0367 |[Valid Perfect Square](src/main/kotlin/g0301_0400/s0367_valid_perfect_square/Solution.kt)| Easy | Math, Binary_Search, Binary_Search_I_Day_3 | 137 | 94.55
 | 0365 |[Water and Jug Problem](src/main/kotlin/g0301_0400/s0365_water_and_jug_problem/Solution.kt)| Medium | Math, Depth_First_Search, Breadth_First_Search, Graph_Theory_I_Day_11_Breadth_First_Search | 130 | 100.00

src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/Solution.kt

@@ -0,0 +1,46 @@
+package g0301_0400.s0371_sum_of_two_integers
+
+// #Medium #Top_Interview_Questions #Math #Bit_Manipulation #Udemy_Bit_Manipulation
+// #2022_11_22_Time_129_ms_(95.45%)_Space_32.9_MB_(90.91%)
+
+class Solution {
+    fun getSum(a: Int, b: Int): Int {
+        var a = a
+        var b = b
+        var ans = 0
+        var memo = 0
+        var exp = 0
+        var count = 0
+        while (count < 32) {
+            val val1 = a and 1
+            val val2 = b and 1
+            var `val` = sum(val1, val2, memo)
+            memo = `val` shr 1
+            `val` = `val` and 1
+            a = a shr 1
+            b = b shr 1
+            ans = ans or (`val` shl exp)
+            exp = plusOne(exp)
+            count = plusOne(count)
+        }
+        return ans
+    }
+
+    private fun sum(val1: Int, val2: Int, val3: Int): Int {
+        var count = 0
+        if (val1 == 1) {
+            count = plusOne(count)
+        }
+        if (val2 == 1) {
+            count = plusOne(count)
+        }
+        if (val3 == 1) {
+            count = plusOne(count)
+        }
+        return count
+    }
+
+    private fun plusOne(`val`: Int): Int {
+        return -`val`.inv()
+    }
+}

src/main/kotlin/g0301_0400/s0371_sum_of_two_integers/readme.md

@@ -0,0 +1,21 @@
+371\. Sum of Two Integers
+
+Medium
+
+Given two integers `a` and `b`, return _the sum of the two integers without using the operators_ `+` _and_ `-`.
+
+**Example 1:**
+
+**Input:** a = 1, b = 2
+
+**Output:** 3
+
+**Example 2:**
+
+**Input:** a = 2, b = 3
+
+**Output:** 5
+
+**Constraints:**
+
+*   `-1000 <= a, b <= 1000`

src/main/kotlin/g0301_0400/s0372_super_pow/Solution.kt

@@ -0,0 +1,77 @@
+package g0301_0400.s0372_super_pow
+
+// #Medium #Math #Divide_and_Conquer #2022_11_22_Time_196_ms_(100.00%)_Space_36.9_MB_(100.00%)
+
+class Solution {
+    fun superPow(a: Int, b: IntArray): Int {
+        val phi = phi(MOD)
+        val arrMod = arrMod(b, phi)
+        return if (isGreaterOrEqual(b, phi)) {
+            // Cycle has started
+            // cycle starts at phi with length phi
+            exp(a % MOD, phi + arrMod)
+        } else exp(a % MOD, arrMod)
+    }
+
+    private fun phi(n: Int): Int {
+        var n = n
+        var result = n.toDouble()
+        var p = 2
+        while (p * p <= n) {
+            if (n % p > 0) {
+                p++
+                continue
+            }
+            while (n % p == 0) {
+                n /= p
+            }
+            result *= 1.0 - 1.0 / p
+            p++
+        }
+        if (n > 1) {
+            // if starting n was also prime (so it was greater than sqrt(n))
+            result *= 1.0 - 1.0 / n
+        }
+        return result.toInt()
+    }
+
+    // Returns true if number in array is greater than integer named phi
+    private fun isGreaterOrEqual(b: IntArray, phi: Int): Boolean {
+        var cur = 0
+        for (j in b) {
+            cur = cur * 10 + j
+            if (cur >= phi) {
+                return true
+            }
+        }
+        return false
+    }
+
+    // Returns number in array mod phi
+    private fun arrMod(b: IntArray, phi: Int): Int {
+        var res = 0
+        for (j in b) {
+            res = (res * 10 + j) % phi
+        }
+        return res
+    }
+
+    // Binary exponentiation
+    private fun exp(a: Int, b: Int): Int {
+        var a = a
+        var b = b
+        var y = 1
+        while (b > 0) {
+            if (b % 2 == 1) {
+                y = y * a % MOD
+            }
+            a = a * a % MOD
+            b /= 2
+        }
+        return y
+    }
+
+    companion object {
+        private const val MOD = 1337
+    }
+}

src/main/kotlin/g0301_0400/s0372_super_pow/readme.md

@@ -0,0 +1,30 @@
+372\. Super Pow
+
+Medium
+
+Your task is to calculate <code>a<sup>b</sup></code> mod `1337` where `a` is a positive integer and `b` is an extremely large positive integer given in the form of an array.
+
+**Example 1:**
+
+**Input:** a = 2, b = [3]
+
+**Output:** 8
+
+**Example 2:**
+
+**Input:** a = 2, b = [1,0]
+
+**Output:** 1024
+
+**Example 3:**
+
+**Input:** a = 1, b = [4,3,3,8,5,2]
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= a <= 2<sup>31</sup> - 1</code>
+*   `1 <= b.length <= 2000`
+*   `0 <= b[i] <= 9`
+*   `b` does not contain leading zeros.

src/main/kotlin/g0301_0400/s0373_find_k_pairs_with_smallest_sums/Solution.kt

@@ -0,0 +1,46 @@
+package g0301_0400.s0373_find_k_pairs_with_smallest_sums
+
+import java.util.PriorityQueue
+import kotlin.collections.ArrayList
+
+// #Medium #Array #Heap_Priority_Queue #2022_11_22_Time_1809_ms_(80.95%)_Space_119.1_MB_(66.67%)
+
+class Solution {
+    private class Node(index: Int, num1: Int, num2: Int) {
+        var sum: Long
+        var al: MutableList<Int>
+        var index: Int
+
+        init {
+            sum = num1.toLong() + num2.toLong()
+            al = ArrayList()
+            al.add(num1)
+            al.add(num2)
+            this.index = index
+        }
+    }
+
+    fun kSmallestPairs(nums1: IntArray, nums2: IntArray, k: Int): List<List<Int>> {
+        val queue = PriorityQueue { a: Node, b: Node -> if (a.sum < b.sum) -1 else 1 }
+        val res: MutableList<List<Int>> = ArrayList()
+        run {
+            var i = 0
+            while (i < nums1.size && i < k) {
+                queue.add(Node(0, nums1[i], nums2[0]))
+                i++
+            }
+        }
+        var i = 1
+        while (i <= k && !queue.isEmpty()) {
+            val cur = queue.poll()
+            res.add(cur.al)
+            val next = cur.index
+            val lastNum1 = cur.al[0]
+            if (next + 1 < nums2.size) {
+                queue.add(Node(next + 1, lastNum1, nums2[next + 1]))
+            }
+            i++
+        }
+        return res
+    }
+}

src/main/kotlin/g0301_0400/s0373_find_k_pairs_with_smallest_sums/readme.md

@@ -0,0 +1,40 @@
+373\. Find K Pairs with Smallest Sums
+
+Medium
+
+You are given two integer arrays `nums1` and `nums2` sorted in **ascending order** and an integer `k`.
+
+Define a pair `(u, v)` which consists of one element from the first array and one element from the second array.
+
+Return _the_ `k` _pairs_ <code>(u<sub>1</sub>, v<sub>1</sub>), (u<sub>2</sub>, v<sub>2</sub>), ..., (u<sub>k</sub>, v<sub>k</sub>)</code> _with the smallest sums_.
+
+**Example 1:**
+
+**Input:** nums1 = [1,7,11], nums2 = [2,4,6], k = 3
+
+**Output:** [[1,2],[1,4],[1,6]]
+
+**Explanation:** The first 3 pairs are returned from the sequence: [1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
+
+**Example 2:**
+
+**Input:** nums1 = [1,1,2], nums2 = [1,2,3], k = 2
+
+**Output:** [[1,1],[1,1]]
+
+**Explanation:** The first 2 pairs are returned from the sequence: [1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
+
+**Example 3:**
+
+**Input:** nums1 = [1,2], nums2 = [3], k = 3
+
+**Output:** [[1,3],[2,3]]
+
+**Explanation:** All possible pairs are returned from the sequence: [1,3],[2,3]
+
+**Constraints:**
+
+*   <code>1 <= nums1.length, nums2.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums1[i], nums2[i] <= 10<sup>9</sup></code>
+*   `nums1` and `nums2` both are sorted in **ascending order**.
+*   <code>1 <= k <= 10<sup>4</sup></code>

src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/GuessGame.kt

@@ -0,0 +1,7 @@
+package g0301_0400.s0374_guess_number_higher_or_lower
+
+open class GuessGame {
+    fun guess(number: Int): Int {
+        return Integer.compare(7, number)
+    }
+}

src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/Solution.kt

@@ -0,0 +1,31 @@
+package g0301_0400.s0374_guess_number_higher_or_lower
+
+// #Easy #Binary_Search #Interactive #Binary_Search_I_Day_1
+// #2022_11_22_Time_134_ms_(94.19%)_Space_32.6_MB_(98.60%)
+
+/*
+ * The API guess is defined in the parent class.
+ * @param num   your guess
+ * @return -1 if num is higher than the picked number
+ *			      1 if num is lower than the picked number
+ *               otherwise return 0
+ * fun guess(num:Int):Int {}
+ */
+
+class Solution : GuessGame() {
+    fun guessNumber(n: Int): Int {
+        var start = 0
+        var end = n
+        while (start <= end) {
+            val mid = start + (end - start) / 2
+            if (guess(mid) == 0) {
+                return mid
+            } else if (guess(mid) == -1) {
+                end = mid - 1
+            } else {
+                start = mid + 1
+            }
+        }
+        return -1
+    }
+}

src/main/kotlin/g0301_0400/s0374_guess_number_higher_or_lower/readme.md

@@ -0,0 +1,40 @@
+374\. Guess Number Higher or Lower
+
+Easy
+
+We are playing the Guess Game. The game is as follows:
+
+I pick a number from `1` to `n`. You have to guess which number I picked.
+
+Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.
+
+You call a pre-defined API `int guess(int num)`, which returns three possible results:
+
+*   `-1`: Your guess is higher than the number I picked (i.e. `num > pick`).
+*   `1`: Your guess is lower than the number I picked (i.e. `num < pick`).
+*   `0`: your guess is equal to the number I picked (i.e. `num == pick`).
+
+Return _the number that I picked_.
+
+**Example 1:**
+
+**Input:** n = 10, pick = 6
+
+**Output:** 6
+
+**Example 2:**
+
+**Input:** n = 1, pick = 1
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** n = 2, pick = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>
+*   `1 <= pick <= n`