Added tasks 2101-2150

Author: javadev

src/main/kotlin/g2101_2200/s2101_detonate_the_maximum_bombs/Solution.kt

@@ -0,0 +1,51 @@
+package g2101_2200.s2101_detonate_the_maximum_bombs
+
+// #Medium #Array #Math #Depth_First_Search #Breadth_First_Search #Graph #Geometry
+// #2023_06_25_Time_262_ms_(98.96%)_Space_40.7_MB_(78.76%)
+
+class Solution {
+    fun maximumDetonation(bombs: Array<IntArray>): Int {
+        val n = bombs.size
+        val graph: Array<MutableList<Int>?> = arrayOfNulls(n)
+        for (i in 0 until n) {
+            graph[i] = ArrayList()
+        }
+        for (i in 0 until n) {
+            for (j in i + 1 until n) {
+                val dx = bombs[i][0] - bombs[j][0].toDouble()
+                val dy = bombs[i][1] - bombs[j][1].toDouble()
+                val r1 = bombs[i][2].toDouble()
+                val r2 = bombs[j][2].toDouble()
+                val dist = dx * dx + dy * dy
+                if (dist <= r1 * r1) {
+                    graph[i]?.add(j)
+                }
+                if (dist <= r2 * r2) {
+                    graph[j]?.add(i)
+                }
+            }
+        }
+        val visited = BooleanArray(n)
+        var ans = 0
+        for (i in 0 until n) {
+            ans = Math.max(ans, dfs(graph, i, visited))
+            if (ans == n) {
+                return ans
+            }
+            visited.fill(false)
+        }
+        return ans
+    }
+
+    private fun dfs(graph: Array<MutableList<Int>?>, i: Int, visited: BooleanArray): Int {
+        var cc = 0
+        if (visited[i]) {
+            return 0
+        }
+        visited[i] = true
+        for (neigh in graph[i]!!) {
+            cc += dfs(graph, neigh, visited)
+        }
+        return cc + 1
+    }
+}

src/main/kotlin/g2101_2200/s2101_detonate_the_maximum_bombs/readme.md

@@ -0,0 +1,63 @@
+2101\. Detonate the Maximum Bombs
+
+Medium
+
+You are given a list of bombs. The **range** of a bomb is defined as the area where its effect can be felt. This area is in the shape of a **circle** with the center as the location of the bomb.
+
+The bombs are represented by a **0-indexed** 2D integer array `bombs` where <code>bombs[i] = [x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub>]</code>. <code>x<sub>i</sub></code> and <code>y<sub>i</sub></code> denote the X-coordinate and Y-coordinate of the location of the <code>i<sup>th</sup></code> bomb, whereas <code>r<sub>i</sub></code> denotes the **radius** of its range.
+
+You may choose to detonate a **single** bomb. When a bomb is detonated, it will detonate **all bombs** that lie in its range. These bombs will further detonate the bombs that lie in their ranges.
+
+Given the list of `bombs`, return _the **maximum** number of bombs that can be detonated if you are allowed to detonate **only one** bomb_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-3.png)
+
+**Input:** bombs = [[2,1,3],[6,1,4]]
+
+**Output:** 2
+
+**Explanation:** 
+
+The above figure shows the positions and ranges of the 2 bombs. 
+
+If we detonate the left bomb, the right bomb will not be affected. 
+
+But if we detonate the right bomb, both bombs will be detonated. 
+
+So the maximum bombs that can be detonated is max(1, 2) = 2.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-2.png)
+
+**Input:** bombs = [[1,1,5],[10,10,5]]
+
+**Output:** 1
+
+**Explanation:** Detonating either bomb will not detonate the other bomb, so the maximum number of bombs that can be detonated is 1.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2021/11/07/desmos-eg1.png)
+
+**Input:** bombs = [[1,2,3],[2,3,1],[3,4,2],[4,5,3],[5,6,4]]
+
+**Output:** 5
+
+**Explanation:** The best bomb to detonate is bomb 0 because: 
+
+- Bomb 0 detonates bombs 1 and 2. The red circle denotes the range of bomb 0. 
+
+- Bomb 2 detonates bomb 3. The blue circle denotes the range of bomb 2. 
+
+- Bomb 3 detonates bomb 4. The green circle denotes the range of bomb 3. 
+  
+Thus all 5 bombs are detonated.
+
+**Constraints:**
+
+*   `1 <= bombs.length <= 100`
+*   `bombs[i].length == 3`
+*   <code>1 <= x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub> <= 10<sup>5</sup></code>

src/main/kotlin/g2101_2200/s2102_sequentially_ordinal_rank_tracker/SORTracker.kt

@@ -0,0 +1,52 @@
+package g2101_2200.s2102_sequentially_ordinal_rank_tracker
+
+// #Hard #Design #Heap_Priority_Queue #Ordered_Set #Data_Stream
+// #2023_06_25_Time_1208_ms_(100.00%)_Space_88.2_MB_(100.00%)
+
+import java.util.TreeSet
+
+class SORTracker {
+    class Location(var name: String, var score: Int)
+
+    private var tSet1: TreeSet<Location?>
+    private var tSet2: TreeSet<Location?>
+
+    init {
+        tSet1 = TreeSet(
+            Comparator { a: Location?, b: Location? ->
+                return@Comparator if (a!!.score != b!!.score) {
+                    b.score - a.score
+                } else {
+                    a.name.compareTo(b.name)
+                }
+            }
+        )
+        tSet2 = TreeSet(
+            Comparator { a: Location?, b: Location? ->
+                return@Comparator if (a!!.score != b!!.score) {
+                    b.score - a.score
+                } else {
+                    a.name.compareTo(b.name)
+                }
+            }
+        )
+    }
+
+    fun add(name: String, score: Int) {
+        tSet1.add(Location(name, score))
+        tSet2.add(tSet1.pollLast())
+    }
+
+    fun get(): String {
+        val res = tSet2.pollFirst()
+        tSet1.add(res)
+        assert(res != null)
+        return res!!.name
+    }
+}
+/*
+ * Your SORTracker object will be instantiated and called as such:
+ * var obj = SORTracker()
+ * obj.add(name,score)
+ * var param_2 = obj.get()
+ */

src/main/kotlin/g2101_2200/s2102_sequentially_ordinal_rank_tracker/readme.md

@@ -0,0 +1,59 @@
+2102\. Sequentially Ordinal Rank Tracker
+
+Hard
+
+A scenic location is represented by its `name` and attractiveness `score`, where `name` is a **unique** string among all locations and `score` is an integer. Locations can be ranked from the best to the worst. The **higher** the score, the better the location. If the scores of two locations are equal, then the location with the **lexicographically smaller** name is better.
+
+You are building a system that tracks the ranking of locations with the system initially starting with no locations. It supports:
+
+*   **Adding** scenic locations, **one at a time**.
+*   **Querying** the <code>i<sup>th</sup></code> **best** location of **all locations already added**, where `i` is the number of times the system has been queried (including the current query).
+    *   For example, when the system is queried for the <code>4<sup>th</sup></code> time, it returns the <code>4<sup>th</sup></code> best location of all locations already added.
+
+Note that the test data are generated so that **at any time**, the number of queries **does not exceed** the number of locations added to the system.
+
+Implement the `SORTracker` class:
+
+*   `SORTracker()` Initializes the tracker system.
+*   `void add(string name, int score)` Adds a scenic location with `name` and `score` to the system.
+*   `string get()` Queries and returns the <code>i<sup>th</sup></code> best location, where `i` is the number of times this method has been invoked (including this invocation).
+
+**Example 1:**
+
+**Input** ["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "add", "get", "get"] [[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], ["alpine", 2], [], []]
+
+**Output:** [null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"]
+
+**Explanation:** 
+
+    SORTracker tracker = new SORTracker(); // Initialize the tracker system.
+    tracker.add("bradford", 2); // Add location with name="bradford" and score=2 to the system.
+    tracker.add("branford", 3); // Add location with name="branford" and score=3 to the system.
+    tracker.get(); // The sorted locations, from best to worst, are: branford, bradford.
+                // Note that branford precedes bradford due to its **higher score** (3 > 2).
+                // This is the 1<sup>st</sup> time get() is called, so return the best location: "branford". 
+    tracker.add("alps", 2); // Add location with name="alps" and score=2 to the system. 
+    tracker.get(); // Sorted locations: branford, alps, bradford. 
+                    // Note that alps precedes bradford even though they have the same score (2). 
+                    // This is because "alps" is **lexicographically smaller** than "bradford". 
+                    // Return the 2<sup>nd</sup> best location "alps", as it is the 2<sup>nd</sup> time get() is called. 
+    tracker.add("orland", 2); // Add location with name="orland" and score=2 to the system. 
+    tracker.get(); // Sorted locations: branford, alps, bradford, orland. 
+                    // Return "bradford", as it is the 3<sup>rd</sup> time get() is called. 
+    tracker.add("orlando", 3); // Add location with name="orlando" and score=3 to the system. 
+    tracker.get(); // Sorted locations: branford, orlando, alps, bradford, orland. 
+                    // Return "bradford". 
+    tracker.add("alpine", 2); // Add location with name="alpine" and score=2 to the system. 
+    tracker.get(); // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
+                    // Return "bradford". 
+    tracker.get(); 
+                    // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
+                    // Return "orland".
+
+**Constraints:**
+
+*   `name` consists of lowercase English letters, and is unique among all locations.
+*   `1 <= name.length <= 10`
+*   <code>1 <= score <= 10<sup>5</sup></code>
+*   At any time, the number of calls to `get` does not exceed the number of calls to `add`.
+*   At most <code>4 * 10<sup>4</sup></code> calls **in total** will be made to `add` and `get`.

src/main/kotlin/g2101_2200/s2103_rings_and_rods/Solution.kt

@@ -0,0 +1,36 @@
+package g2101_2200.s2103_rings_and_rods
+
+// #Easy #String #Hash_Table #2023_06_25_Time_131_ms_(89.47%)_Space_33.9_MB_(100.00%)
+
+class Solution {
+    fun countPoints(rings: String): Int {
+        val redHashMap: MutableMap<Int, Int> = HashMap()
+        val greenHashMap: MutableMap<Int, Int> = HashMap()
+        val blueHashMap: MutableMap<Int, Int> = HashMap()
+        run {
+            var i = 0
+            while (i <= rings.length - 2) {
+                val charOne = rings[i]
+                val charTwo = rings[i + 1]
+                if (charOne == 'R') {
+                    redHashMap[Character.getNumericValue(charTwo)] = 123
+                } else if (charOne == 'G') {
+                    greenHashMap[Character.getNumericValue(charTwo)] = 123
+                } else {
+                    blueHashMap[Character.getNumericValue(charTwo)] = 123
+                }
+                i = i + 2
+            }
+        }
+        var result = 0
+        for (i in 0..9) {
+            if (redHashMap.containsKey(i) &&
+                greenHashMap.containsKey(i) &&
+                blueHashMap.containsKey(i)
+            ) {
+                result++
+            }
+        }
+        return result
+    }
+}

src/main/kotlin/g2101_2200/s2103_rings_and_rods/readme.md

@@ -0,0 +1,63 @@
+2103\. Rings and Rods
+
+Easy
+
+There are `n` rings and each ring is either red, green, or blue. The rings are distributed **across ten rods** labeled from `0` to `9`.
+
+You are given a string `rings` of length `2n` that describes the `n` rings that are placed onto the rods. Every two characters in `rings` forms a **color-position pair** that is used to describe each ring where:
+
+*   The **first** character of the <code>i<sup>th</sup></code> pair denotes the <code>i<sup>th</sup></code> ring's **color** (`'R'`, `'G'`, `'B'`).
+*   The **second** character of the <code>i<sup>th</sup></code> pair denotes the **rod** that the <code>i<sup>th</sup></code> ring is placed on (`'0'` to `'9'`).
+
+For example, `"R3G2B1"` describes `n == 3` rings: a red ring placed onto the rod labeled 3, a green ring placed onto the rod labeled 2, and a blue ring placed onto the rod labeled 1.
+
+Return _the number of rods that have **all three colors** of rings on them._
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/11/23/ex1final.png)
+
+**Input:** rings = "B0B6G0R6R0R6G9"
+
+**Output:** 1
+
+**Explanation:** 
+
+- The rod labeled 0 holds 3 rings with all colors: red, green, and blue. 
+
+- The rod labeled 6 holds 3 rings, but it only has red and blue. 
+
+- The rod labeled 9 holds only a green ring. 
+  
+Thus, the number of rods with all three colors is 1.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/11/23/ex2final.png)
+
+**Input:** rings = "B0R0G0R9R0B0G0"
+
+**Output:** 1
+
+**Explanation:** 
+
+- The rod labeled 0 holds 6 rings with all colors: red, green, and blue. 
+
+- The rod labeled 9 holds only a red ring. 
+  
+Thus, the number of rods with all three colors is 1.
+
+**Example 3:**
+
+**Input:** rings = "G4"
+
+**Output:** 0
+
+**Explanation:** Only one ring is given. Thus, no rods have all three colors.
+
+**Constraints:**
+
+*   `rings.length == 2 * n`
+*   `1 <= n <= 100`
+*   `rings[i]` where `i` is **even** is either `'R'`, `'G'`, or `'B'` (**0-indexed**).
+*   `rings[i]` where `i` is **odd** is a digit from `'0'` to `'9'` (**0-indexed**).

src/main/kotlin/g2101_2200/s2104_sum_of_subarray_ranges/Solution.kt

@@ -0,0 +1,34 @@
+package g2101_2200.s2104_sum_of_subarray_ranges
+
+// #Medium #Array #Stack #Monotonic_Stack #2023_06_25_Time_212_ms_(100.00%)_Space_38_MB_(30.77%)
+
+import java.util.ArrayDeque
+import java.util.Deque
+
+class Solution {
+    fun subArrayRanges(nums: IntArray): Long {
+        val n = nums.size
+        var sum: Long = 0
+        val q: Deque<Int> = ArrayDeque()
+        q.add(-1)
+        for (i in 0..n) {
+            while (q.peekLast() != -1 && (i == n || nums[q.peekLast()] <= nums[i])) {
+                val cur = q.removeLast()
+                val left = q.peekLast()
+                sum += 1L * (cur - left) * (i - cur) * nums[cur]
+            }
+            q.add(i)
+        }
+        q.clear()
+        q.add(-1)
+        for (i in 0..n) {
+            while (q.peekLast() != -1 && (i == n || nums[q.peekLast()] >= nums[i])) {
+                val cur = q.removeLast()
+                val left = q.peekLast()
+                sum -= 1L * (cur - left) * (i - cur) * nums[cur]
+            }
+            q.add(i)
+        }
+        return sum
+    }
+}