Added tasks 3020-3046

Author: javadev

src/main/kotlin/g2801_2900/s2815_max_pair_sum_in_an_array/Solution.kt

@@ -23,7 +23,7 @@ class Solution {
                 continue
             }
             val sum = value.poll() + value.poll()
-            maxSum = max(maxSum.toDouble(), sum.toDouble()).toInt()
+            maxSum = max(maxSum, sum)
         }
         return maxSum
     }

src/main/kotlin/g3001_3100/s3020_find_the_maximum_number_of_elements_in_subset/Solution.kt

@@ -0,0 +1,47 @@
+package g3001_3100.s3020_find_the_maximum_number_of_elements_in_subset
+
+// #Medium #Array #Hash_Table #Enumeration #2024_03_03_Time_626_ms_(82.22%)_Space_57.8_MB_(80.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maximumLength(nums: IntArray): Int {
+        return withHashMap(nums)
+    }
+
+    private fun withHashMap(nums: IntArray): Int {
+        val map: MutableMap<Int, Int> = HashMap()
+        for (i in nums) {
+            map[i] = map.getOrDefault(i, 0) + 1
+        }
+        var ans = 0
+        if (map.containsKey(1)) {
+            ans = if (map[1]!! % 2 == 0) {
+                map[1]!! - 1
+            } else {
+                map[1]!!
+            }
+        }
+        for (key in map.keys) {
+            if (key == 1) {
+                continue
+            }
+            val len = findSeries(map, key)
+            ans = max(ans, len)
+        }
+        return ans
+    }
+
+    private fun findSeries(map: Map<Int, Int>, key: Int): Int {
+        val sqr = key * key
+        return if (map.containsKey(sqr)) {
+            if (map[key]!! >= 2) {
+                2 + findSeries(map, sqr)
+            } else {
+                1
+            }
+        } else {
+            1
+        }
+    }
+}

src/main/kotlin/g3001_3100/s3020_find_the_maximum_number_of_elements_in_subset/readme.md

@@ -0,0 +1,32 @@
+3020\. Find the Maximum Number of Elements in Subset
+
+Medium
+
+You are given an array of **positive** integers `nums`.
+
+You need to select a subset of `nums` which satisfies the following condition:
+
+*   You can place the selected elements in a **0-indexed** array such that it follows the pattern: <code>[x, x<sup>2</sup>, x<sup>4</sup>, ..., x<sup>k/2</sup>, x<sup>k</sup>, x<sup>k/2</sup>, ..., x<sup>4</sup>, x<sup>2</sup>, x]</code> (**Note** that `k` can be be any **non-negative** power of `2`). For example, `[2, 4, 16, 4, 2]` and `[3, 9, 3]` follow the pattern while `[2, 4, 8, 4, 2]` does not.
+
+Return _the **maximum** number of elements in a subset that satisfies these conditions._
+
+**Example 1:**
+
+**Input:** nums = [5,4,1,2,2]
+
+**Output:** 3
+
+**Explanation:** We can select the subset {4,2,2}, which can be placed in the array as [2,4,2] which follows the pattern and 2<sup>2</sup> == 4. Hence the answer is 3.
+
+**Example 2:**
+
+**Input:** nums = [1,3,2,4]
+
+**Output:** 1
+
+**Explanation:** We can select the subset {1}, which can be placed in the array as [1] which follows the pattern. Hence the answer is 1. Note that we could have also selected the subsets {2}, {3}, or {4}, there may be multiple subsets which provide the same answer.
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>5</sup></code>
+*   <code>1 <= nums[i] <= 10<sup>9</sup></code>

src/main/kotlin/g3001_3100/s3021_alice_and_bob_playing_flower_game/Solution.kt

@@ -0,0 +1,13 @@
+package g3001_3100.s3021_alice_and_bob_playing_flower_game
+
+// #Medium #Math #2024_03_03_Time_141_ms_(43.24%)_Space_33.2_MB_(86.49%)
+
+class Solution {
+    fun flowerGame(n: Int, m: Int): Long {
+        val nEven = n.toLong() / 2
+        val nOdd = n - nEven
+        val mEven = m.toLong() / 2
+        val mOdd = m - mEven
+        return nEven * mOdd + nOdd * mEven
+    }
+}

src/main/kotlin/g3001_3100/s3021_alice_and_bob_playing_flower_game/readme.md

@@ -0,0 +1,39 @@
+3021\. Alice and Bob Playing Flower Game
+
+Medium
+
+Alice and Bob are playing a turn-based game on a circular field surrounded by flowers. The circle represents the field, and there are `x` flowers in the clockwise direction between Alice and Bob, and `y` flowers in the anti-clockwise direction between them.
+
+The game proceeds as follows:
+
+1.  Alice takes the first turn.
+2.  In each turn, a player must choose either the clockwise or anti-clockwise direction and pick one flower from that side.
+3.  At the end of the turn, if there are no flowers left at all, the **current** player captures their opponent and wins the game.
+
+Given two integers, `n` and `m`, the task is to compute the number of possible pairs `(x, y)` that satisfy the conditions:
+
+*   Alice must win the game according to the described rules.
+*   The number of flowers `x` in the clockwise direction must be in the range `[1,n]`.
+*   The number of flowers `y` in the anti-clockwise direction must be in the range `[1,m]`.
+
+Return _the number of possible pairs_ `(x, y)` _that satisfy the conditions mentioned in the statement_.
+
+**Example 1:**
+
+**Input:** n = 3, m = 2
+
+**Output:** 3
+
+**Explanation:** The following pairs satisfy conditions described in the statement: (1,2), (3,2), (2,1).
+
+**Example 2:**
+
+**Input:** n = 1, m = 1
+
+**Output:** 0
+
+**Explanation:** No pairs satisfy the conditions described in the statement.
+
+**Constraints:**
+
+*   <code>1 <= n, m <= 10<sup>5</sup></code>

src/main/kotlin/g3001_3100/s3022_minimize_or_of_remaining_elements_using_operations/Solution.kt

@@ -0,0 +1,27 @@
+package g3001_3100.s3022_minimize_or_of_remaining_elements_using_operations
+
+// #Hard #Array #Greedy #Bit_Manipulation #2024_03_03_Time_516_ms_(77.78%)_Space_62.7_MB_(100.00%)
+
+class Solution {
+    fun minOrAfterOperations(nums: IntArray, k: Int): Int {
+        var ans = 0
+        var mask = 0
+        for (j in 30 downTo 0) {
+            mask = mask or (1 shl j)
+            var consecutiveAnd = mask
+            var mergeCount = 0
+            for (i in nums) {
+                consecutiveAnd = consecutiveAnd and i
+                if ((consecutiveAnd or ans) != ans) {
+                    mergeCount++
+                } else {
+                    consecutiveAnd = mask
+                }
+            }
+            if (mergeCount > k) {
+                ans = ans or (1 shl j)
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g3001_3100/s3022_minimize_or_of_remaining_elements_using_operations/readme.md

@@ -0,0 +1,53 @@
+3022\. Minimize OR of Remaining Elements Using Operations
+
+Hard
+
+You are given a **0-indexed** integer array `nums` and an integer `k`.
+
+In one operation, you can pick any index `i` of `nums` such that `0 <= i < nums.length - 1` and replace `nums[i]` and `nums[i + 1]` with a single occurrence of `nums[i] & nums[i + 1]`, where `&` represents the bitwise `AND` operator.
+
+Return _the **minimum** possible value of the bitwise_ `OR` _of the remaining elements of_ `nums` _after applying **at most**_ `k` _operations_.
+
+**Example 1:**
+
+**Input:** nums = [3,5,3,2,7], k = 2
+
+**Output:** 3
+
+**Explanation:** Let's do the following operations: 
+1. Replace nums[0] and nums[1] with (nums[0] & nums[1]) so that nums becomes equal to [1,3,2,7]. 
+2. Replace nums[2] and nums[3] with (nums[2] & nums[3]) so that nums becomes equal to [1,3,2]. 
+
+The bitwise-or of the final array is 3. 
+
+It can be shown that 3 is the minimum possible value of the bitwise OR of the remaining elements of nums after applying at most k operations.
+
+**Example 2:**
+
+**Input:** nums = [7,3,15,14,2,8], k = 4
+
+**Output:** 2
+
+**Explanation:** Let's do the following operations: 
+1. Replace nums[0] and nums[1] with (nums[0] & nums[1]) so that nums becomes equal to [3,15,14,2,8]. 
+2. Replace nums[0] and nums[1] with (nums[0] & nums[1]) so that nums becomes equal to [3,14,2,8]. 
+3. Replace nums[0] and nums[1] with (nums[0] & nums[1]) so that nums becomes equal to [2,2,8]. 
+4. Replace nums[1] and nums[2] with (nums[1] & nums[2]) so that nums becomes equal to [2,0]. 
+
+The bitwise-or of the final array is 2. 
+
+It can be shown that 2 is the minimum possible value of the bitwise OR of the remaining elements of nums after applying at most k operations.
+
+**Example 3:**
+
+**Input:** nums = [10,7,10,3,9,14,9,4], k = 1
+
+**Output:** 15
+
+**Explanation:** Without applying any operations, the bitwise-or of nums is 15. It can be shown that 15 is the minimum possible value of the bitwise OR of the remaining elements of nums after applying at most k operations.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i] < 2<sup>30</sup></code>
+*   `0 <= k < nums.length`

src/main/kotlin/g3001_3100/s3024_type_of_triangle/Solution.kt

@@ -0,0 +1,18 @@
+package g3001_3100.s3024_type_of_triangle
+
+// #Easy #Array #Math #Sorting #2024_03_03_Time_163_ms_(81.03%)_Space_34.7_MB_(93.10%)
+
+class Solution {
+    fun triangleType(nums: IntArray): String {
+        if (nums[0] + nums[1] > nums[2] && nums[1] + nums[2] > nums[0] && nums[2] + nums[0] > nums[1]) {
+            return if (nums[0] == nums[1] && nums[1] == nums[2]) {
+                "equilateral"
+            } else if (nums[0] == nums[1] || nums[0] == nums[2] || nums[2] == nums[1]) {
+                "isosceles"
+            } else {
+                "scalene"
+            }
+        }
+        return "none"
+    }
+}

src/main/kotlin/g3001_3100/s3024_type_of_triangle/readme.md

@@ -0,0 +1,42 @@
+3024\. Type of Triangle
+
+Easy
+
+You are given a **0-indexed** integer array `nums` of size `3` which can form the sides of a triangle.
+
+*   A triangle is called **equilateral** if it has all sides of equal length.
+*   A triangle is called **isosceles** if it has exactly two sides of equal length.
+*   A triangle is called **scalene** if all its sides are of different lengths.
+
+Return _a string representing_ _the type of triangle that can be formed_ _or_ `"none"` _if it **cannot** form a triangle._
+
+**Example 1:**
+
+**Input:** nums = [3,3,3]
+
+**Output:** "equilateral"
+
+**Explanation:** Since all the sides are of equal length, therefore, it will form an equilateral triangle.
+
+**Example 2:**
+
+**Input:** nums = [3,4,5]
+
+**Output:** "scalene"
+
+**Explanation:** 
+
+nums[0] + nums[1] = 3 + 4 = 7, which is greater than nums[2] = 5. 
+
+nums[0] + nums[2] = 3 + 5 = 8, which is greater than nums[1] = 4. 
+
+nums[1] + nums[2] = 4 + 5 = 9, which is greater than nums[0] = 3. 
+
+Since the sum of the two sides is greater than the third side for all three cases, therefore, it can form a triangle. 
+
+As all the sides are of different lengths, it will form a scalene triangle.
+
+**Constraints:**
+
+*   `nums.length == 3`
+*   `1 <= nums[i] <= 100`

src/main/kotlin/g3001_3100/s3025_find_the_number_of_ways_to_place_people_i/Solution.kt

@@ -0,0 +1,26 @@
+package g3001_3100.s3025_find_the_number_of_ways_to_place_people_i
+
+// #Medium #Array #Math #Sorting #Enumeration #Geometry
+// #2024_03_03_Time_252_ms_(44.12%)_Space_44.1_MB_(73.53%)
+
+class Solution {
+    fun numberOfPairs(points: Array<IntArray>): Int {
+        points.sortWith { a: IntArray, b: IntArray -> if (a[0] == b[0]) b[1] - a[1] else a[0] - b[0] }
+        var cnt = 0
+        for (i in points.indices) {
+            var bot = Int.MIN_VALUE
+            var top = points[i][1]
+            for (j in i + 1 until points.size) {
+                val y1 = points[j][1]
+                if (y1 <= top && y1 > bot) {
+                    cnt++
+                    bot = y1
+                    if (y1 == top) {
+                        top--
+                    }
+                }
+            }
+        }
+        return cnt
+    }
+}

src/main/kotlin/g3001_3100/s3025_find_the_number_of_ways_to_place_people_i/readme.md

@@ -0,0 +1,69 @@
+3025\. Find the Number of Ways to Place People I
+
+Medium
+
+You are given a 2D array `points` of size `n x 2` representing integer coordinates of some points on a 2D-plane, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>.
+
+We define the **right** direction as positive x-axis (**increasing x-coordinate**) and the **left** direction as negative x-axis (**decreasing x-coordinate**). Similarly, we define the **up** direction as positive y-axis (**increasing y-coordinate**) and the **down** direction as negative y-axis (**decreasing y-coordinate**)
+
+You have to place `n` people, including Alice and Bob, at these points such that there is **exactly one** person at every point. Alice wants to be alone with Bob, so Alice will build a rectangular fence with Alice's position as the **upper left corner** and Bob's position as the **lower right corner** of the fence (**Note** that the fence **might not** enclose any area, i.e. it can be a line). If any person other than Alice and Bob is either **inside** the fence or **on** the fence, Alice will be sad.
+
+Return _the number of **pairs of points** where you can place Alice and Bob, such that Alice **does not** become sad on building the fence_.
+
+**Note** that Alice can only build a fence with Alice's position as the upper left corner, and Bob's position as the lower right corner. For example, Alice cannot build either of the fences in the picture below with four corners `(1, 1)`, `(1, 3)`, `(3, 1)`, and `(3, 3)`, because:
+
+*   With Alice at `(3, 3)` and Bob at `(1, 1)`, Alice's position is not the upper left corner and Bob's position is not the lower right corner of the fence.
+*   With Alice at `(1, 3)` and Bob at `(1, 1)`, Bob's position is not the lower right corner of the fence.
+
+![](https://assets.leetcode.com/uploads/2024/01/04/example0alicebob-1.png)
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png)
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** 0
+
+**Explanation:** There is no way to place Alice and Bob such that Alice can build a fence with Alice's position as the upper left corner and Bob's position as the lower right corner. Hence we return 0.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2024/02/04/example2alicebob.png)
+
+**Input:** points = [[6,2],[4,4],[2,6]]
+
+**Output:** 2
+
+**Explanation:** There are two ways to place Alice and Bob such that Alice will not be sad:
+
+- Place Alice at (4, 4) and Bob at (6, 2).
+
+- Place Alice at (2, 6) and Bob at (4, 4).
+
+You cannot place Alice at (2, 6) and Bob at (6, 2) because the person at (4, 4) will be inside the fence.
+
+**Example 3:**
+
+![](https://assets.leetcode.com/uploads/2024/02/04/example4alicebob.png)
+
+**Input:** points = [[3,1],[1,3],[1,1]]
+
+**Output:** 2
+
+**Explanation:** There are two ways to place Alice and Bob such that Alice will not be sad:
+
+- Place Alice at (1, 1) and Bob at (3, 1).
+
+- Place Alice at (1, 3) and Bob at (1, 1).
+
+You cannot place Alice at (1, 3) and Bob at (3, 1) because the person at (1, 1) will be on the fence.
+
+Note that it does not matter if the fence encloses any area, the first and second fences in the image are valid.
+
+**Constraints:**
+
+*   `2 <= n <= 50`
+*   `points[i].length == 2`
+*   `0 <= points[i][0], points[i][1] <= 50`
+*   All `points[i]` are distinct.