Added tasks 2091-2100

Author: ThanhNIT

src/main/kotlin/g2001_2100/s2091_removing_minimum_and_maximum_from_array/Solution.kt

@@ -0,0 +1,36 @@
+package g2001_2100.s2091_removing_minimum_and_maximum_from_array
+
+// #Medium #Array #Greedy #2023_06_28_Time_607_ms_(100.00%)_Space_57.3_MB_(100.00%)
+
+class Solution {
+    fun minimumDeletions(nums: IntArray): Int {
+        val n = nums.size
+        var min = Int.MAX_VALUE
+        var max = Int.MIN_VALUE
+        var minIndex = 0
+        var maxIndex = 0
+        for (i in nums.indices) {
+            if (nums[i] < min) {
+                min = nums[i]
+                minIndex = i
+            }
+            if (nums[i] > max) {
+                max = nums[i]
+                maxIndex = i
+            }
+        }
+        val firstCase: Int
+        val secondCase: Int
+        val thirdCase: Int
+        if (minIndex > maxIndex) {
+            firstCase = minIndex + 1
+            secondCase = n - maxIndex
+            thirdCase = maxIndex + 1 + (n - minIndex)
+        } else {
+            firstCase = maxIndex + 1
+            secondCase = n - minIndex
+            thirdCase = minIndex + 1 + (n - maxIndex)
+        }
+        return firstCase.coerceAtMost(secondCase.coerceAtMost(thirdCase))
+    }
+}

src/main/kotlin/g2001_2100/s2091_removing_minimum_and_maximum_from_array/readme.md

@@ -0,0 +1,61 @@
+2091\. Removing Minimum and Maximum From Array
+
+Medium
+
+You are given a **0-indexed** array of **distinct** integers `nums`.
+
+There is an element in `nums` that has the **lowest** value and an element that has the **highest** value. We call them the **minimum** and **maximum** respectively. Your goal is to remove **both** these elements from the array.
+
+A **deletion** is defined as either removing an element from the **front** of the array or removing an element from the **back** of the array.
+
+Return _the **minimum** number of deletions it would take to remove **both** the minimum and maximum element from the array._
+
+**Example 1:**
+
+**Input:** nums = [2,**10**,7,5,4,**1**,8,6]
+
+**Output:** 5
+
+**Explanation:**
+
+The minimum element in the array is nums[5], which is 1.
+
+The maximum element in the array is nums[1], which is 10.
+
+We can remove both the minimum and maximum by removing 2 elements from the front and 3 elements from the back.
+
+This results in 2 + 3 = 5 deletions, which is the minimum number possible. 
+
+**Example 2:**
+
+**Input:** nums = [0,**\-4**,**19**,1,8,-2,-3,5]
+
+**Output:** 3
+
+**Explanation:**
+
+The minimum element in the array is nums[1], which is -4.
+
+The maximum element in the array is nums[2], which is 19.
+
+We can remove both the minimum and maximum by removing 3 elements from the front.
+
+This results in only 3 deletions, which is the minimum number possible. 
+
+**Example 3:**
+
+**Input:** nums = [**101**]
+
+**Output:** 1
+
+**Explanation:**
+
+There is only one element in the array, which makes it both the minimum and maximum element.
+
+We can remove it with 1 deletion. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+*   The integers in `nums` are **distinct**.

src/main/kotlin/g2001_2100/s2092_find_all_people_with_secret/Solution.kt

@@ -0,0 +1,91 @@
+package g2001_2100.s2092_find_all_people_with_secret
+
+// #Hard #Sorting #Depth_First_Search #Breadth_First_Search #Graph #Union_Find
+// #2023_06_28_Time_1086_ms_(100.00%)_Space_104.2_MB_(100.00%)
+
+import java.util.Arrays
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun findAllPeople(n: Int, meetings: Array<IntArray>, firstPerson: Int): List<Int> {
+        Arrays.sort(meetings) { a: IntArray, b: IntArray -> a[2] - b[2] }
+        val uf = UF(n)
+        // base
+        uf.union(0, firstPerson)
+        // for every time we have a pool of people that talk to each other
+        // if someone knows a secret proir to this meeting - all pool will too
+        // if not - reset unions from this pool
+        var i = 0
+        while (i < meetings.size) {
+            val curTime = meetings[i][2]
+            val pool: MutableSet<Int> = HashSet()
+            while (i < meetings.size && curTime == meetings[i][2]) {
+                val currentMeeting = meetings[i]
+                uf.union(currentMeeting[0], currentMeeting[1])
+                pool.add(currentMeeting[0])
+                pool.add(currentMeeting[1])
+                i++
+            }
+            // meeting that took place now should't affect future
+            // meetings if people don't know the secret
+            for (j in pool) {
+                if (!uf.connected(0, j)) {
+                    uf.reset(j)
+                }
+            }
+        }
+        // if the person is conneted to 0 - they know a secret
+        val ans: MutableList<Int> = ArrayList()
+        for (j in 0 until n) {
+            if (uf.connected(j, 0)) {
+                ans.add(j)
+            }
+        }
+        return ans
+    }
+
+    // regular union find
+    private class UF(n: Int) {
+        private val parent: IntArray
+        private val rank: IntArray
+
+        init {
+            parent = IntArray(n)
+            rank = IntArray(n)
+            for (i in 0 until n) {
+                parent[i] = i
+            }
+        }
+
+        fun union(p: Int, q: Int) {
+            val rootP = find(p)
+            val rootQ = find(q)
+            if (rootP == rootQ) {
+                return
+            }
+            if (rank[rootP] < rank[rootQ]) {
+                parent[rootP] = rootQ
+            } else {
+                parent[rootQ] = rootP
+                rank[rootP]++
+            }
+        }
+
+        fun find(p: Int): Int {
+            var p = p
+            while (parent[p] != p) {
+                p = parent[parent[p]]
+            }
+            return p
+        }
+
+        fun connected(p: Int, q: Int): Boolean {
+            return find(p) == find(q)
+        }
+
+        fun reset(p: Int) {
+            parent[p] = p
+            rank[p] = 0
+        }
+    }
+}

src/main/kotlin/g2001_2100/s2092_find_all_people_with_secret/readme.md

@@ -0,0 +1,73 @@
+2092\. Find All People With Secret
+
+Hard
+
+You are given an integer `n` indicating there are `n` people numbered from `0` to `n - 1`. You are also given a **0-indexed** 2D integer array `meetings` where <code>meetings[i] = [x<sub>i</sub>, y<sub>i</sub>, time<sub>i</sub>]</code> indicates that person <code>x<sub>i</sub></code> and person <code>y<sub>i</sub></code> have a meeting at <code>time<sub>i</sub></code>. A person may attend **multiple meetings** at the same time. Finally, you are given an integer `firstPerson`.
+
+Person `0` has a **secret** and initially shares the secret with a person `firstPerson` at time `0`. This secret is then shared every time a meeting takes place with a person that has the secret. More formally, for every meeting, if a person <code>x<sub>i</sub></code> has the secret at <code>time<sub>i</sub></code>, then they will share the secret with person <code>y<sub>i</sub></code>, and vice versa.
+
+The secrets are shared **instantaneously**. That is, a person may receive the secret and share it with people in other meetings within the same time frame.
+
+Return _a list of all the people that have the secret after all the meetings have taken place._ You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** n = 6, meetings = [[1,2,5],[2,3,8],[1,5,10]], firstPerson = 1
+
+**Output:** [0,1,2,3,5]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 1.
+
+At time 5, person 1 shares the secret with person 2.
+
+At time 8, person 2 shares the secret with person 3.
+
+At time 10, person 1 shares the secret with person 5.
+
+Thus, people 0, 1, 2, 3, and 5 know the secret after all the meetings. 
+
+**Example 2:**
+
+**Input:** n = 4, meetings = [[3,1,3],[1,2,2],[0,3,3]], firstPerson = 3
+
+**Output:** [0,1,3]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 3.
+
+At time 2, neither person 1 nor person 2 know the secret.
+
+At time 3, person 3 shares the secret with person 0 and person 1.
+
+Thus, people 0, 1, and 3 know the secret after all the meetings. 
+
+**Example 3:**
+
+**Input:** n = 5, meetings = [[3,4,2],[1,2,1],[2,3,1]], firstPerson = 1
+
+**Output:** [0,1,2,3,4]
+
+**Explanation:**
+
+At time 0, person 0 shares the secret with person 1.
+
+At time 1, person 1 shares the secret with person 2, and person 2 shares the secret with person 3.
+
+Note that person 2 can share the secret at the same time as receiving it.
+
+At time 2, person 3 shares the secret with person 4.
+
+Thus, people 0, 1, 2, 3, and 4 know the secret after all the meetings. 
+
+**Constraints:**
+
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= meetings.length <= 10<sup>5</sup></code>
+*   `meetings[i].length == 3`
+*   <code>0 <= x<sub>i</sub>, y<sub>i</sub> <= n - 1</code>
+*   <code>x<sub>i</sub> != y<sub>i</sub></code>
+*   <code>1 <= time<sub>i</sub> <= 10<sup>5</sup></code>
+*   `1 <= firstPerson <= n - 1`

src/main/kotlin/g2001_2100/s2094_finding_3_digit_even_numbers/Solution.kt

@@ -0,0 +1,37 @@
+package g2001_2100.s2094_finding_3_digit_even_numbers
+
+// #Easy #Array #Hash_Table #Sorting #Enumeration
+// #2023_06_28_Time_181_ms_(100.00%)_Space_37.4_MB_(100.00%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun findEvenNumbers(digits: IntArray): IntArray {
+        val idx = IntArray(1)
+        val result = IntArray(9 * 10 * 5)
+        val digitMap = IntArray(10)
+        for (digit in digits) {
+            digitMap[digit]++
+        }
+        dfs(result, digitMap, idx, 0)
+        return result.copyOfRange(0, idx[0])
+    }
+
+    private fun dfs(result: IntArray, digitMap: IntArray, idx: IntArray, `val`: Int) {
+        var `val` = `val`
+        if (`val` > 99) {
+            result[idx[0]++] = `val`
+            return
+        }
+        `val` *= 10
+        for (i in 0..9) {
+            if (digitMap[i] == 0 || `val` == 0 && i == 0 || `val` > 99 && i and 1 == 1) {
+                continue
+            }
+            digitMap[i]--
+            `val` += i
+            dfs(result, digitMap, idx, `val`)
+            `val` -= i
+            digitMap[i]++
+        }
+    }
+}

src/main/kotlin/g2001_2100/s2094_finding_3_digit_even_numbers/readme.md

@@ -0,0 +1,48 @@
+2094\. Finding 3-Digit Even Numbers
+
+Easy
+
+You are given an integer array `digits`, where each element is a digit. The array may contain duplicates.
+
+You need to find **all** the **unique** integers that follow the given requirements:
+
+*   The integer consists of the **concatenation** of **three** elements from `digits` in **any** arbitrary order.
+*   The integer does not have **leading zeros**.
+*   The integer is **even**.
+
+For example, if the given `digits` were `[1, 2, 3]`, integers `132` and `312` follow the requirements.
+
+Return _a **sorted** array of the unique integers._
+
+**Example 1:**
+
+**Input:** digits = [2,1,3,0]
+
+**Output:** [102,120,130,132,210,230,302,310,312,320]
+
+**Explanation:** All the possible integers that follow the requirements are in the output array.
+
+Notice that there are no **odd** integers or integers with **leading zeros**. 
+
+**Example 2:**
+
+**Input:** digits = [2,2,8,8,2]
+
+**Output:** [222,228,282,288,822,828,882]
+
+**Explanation:** The same digit can be used as many times as it appears in digits.
+
+In this example, the digit 8 is used twice each time in 288, 828, and 882. 
+
+**Example 3:**
+
+**Input:** digits = [3,7,5]
+
+**Output:** []
+
+**Explanation:** No **even** integers can be formed using the given digits. 
+
+**Constraints:**
+
+*   `3 <= digits.length <= 100`
+*   `0 <= digits[i] <= 9`

src/main/kotlin/g2001_2100/s2095_delete_the_middle_node_of_a_linked_list/Solution.kt

@@ -0,0 +1,33 @@
+package g2001_2100.s2095_delete_the_middle_node_of_a_linked_list
+
+// #Medium #Two_Pointers #Linked_List #2023_06_28_Time_1115_ms_(50.00%)_Space_61.4_MB_(81.25%)
+
+import com_github_leetcode.ListNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun deleteMiddle(head: ListNode?): ListNode? {
+        var slow = head
+        var fast = head
+        var prev: ListNode? = null
+        while (fast?.next != null) {
+            prev = slow
+
+            slow = slow?.next
+            fast = fast.next?.next
+        }
+        if (slow == head) {
+            return null
+        }
+        prev?.next = slow?.next
+        return head
+    }
+}