Added tasks 3096-3100

Author: javadev

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

@@ -0,0 +1,30 @@
+package g3001_3100.s3096_minimum_levels_to_gain_more_points
+
+// #Medium #Array #Prefix_Sum #2024_04_20_Time_850_ms_(100.00%)_Space_67.9_MB_(97.22%)
+
+class Solution {
+    fun minimumLevels(possible: IntArray): Int {
+        val n = possible.size
+        var sum = 0
+        for (p in possible) {
+            sum += p
+        }
+        if (sum == 0 && n == 2) {
+            return -1
+        }
+        if (sum == 0 && n > 2) {
+            return 1
+        }
+        var sumLeft = 0
+        for (i in 0 until n - 1) {
+            sumLeft += possible[i]
+            val sumRight = sum - sumLeft
+            val danScore = sumLeft - ((i + 1) - sumLeft)
+            val bobScore = sumRight - ((n - i - 1) - sumRight)
+            if (danScore > bobScore) {
+                return i + 1
+            }
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,63 @@
+3096\. Minimum Levels to Gain More Points
+
+Medium
+
+You are given a binary array `possible` of length `n`.
+
+Alice and Bob are playing a game that consists of `n` levels. Some of the levels in the game are **impossible** to clear while others can **always** be cleared. In particular, if `possible[i] == 0`, then the <code>i<sup>th</sup></code> level is **impossible** to clear for **both** the players. A player gains `1` point on clearing a level and loses `1` point if the player fails to clear it.
+
+At the start of the game, Alice will play some levels in the **given order** starting from the <code>0<sup>th</sup></code> level, after which Bob will play for the rest of the levels.
+
+Alice wants to know the **minimum** number of levels she should play to gain more points than Bob, if both players play optimally to **maximize** their points.
+
+Return _the **minimum** number of levels Alice should play to gain more points_. _If this is **not** possible, return_ `-1`.
+
+**Note** that each player must play at least `1` level.
+
+**Example 1:**
+
+**Input:** possible = [1,0,1,0]
+
+**Output:** 1
+
+**Explanation:**
+
+Let's look at all the levels that Alice can play up to:
+
+*   If Alice plays only level 0 and Bob plays the rest of the levels, Alice has 1 point, while Bob has -1 + 1 - 1 = -1 point.
+*   If Alice plays till level 1 and Bob plays the rest of the levels, Alice has 1 - 1 = 0 points, while Bob has 1 - 1 = 0 points.
+*   If Alice plays till level 2 and Bob plays the rest of the levels, Alice has 1 - 1 + 1 = 1 point, while Bob has -1 point.
+
+Alice must play a minimum of 1 level to gain more points.
+
+**Example 2:**
+
+**Input:** possible = [1,1,1,1,1]
+
+**Output:** 3
+
+**Explanation:**
+
+Let's look at all the levels that Alice can play up to:
+
+*   If Alice plays only level 0 and Bob plays the rest of the levels, Alice has 1 point, while Bob has 4 points.
+*   If Alice plays till level 1 and Bob plays the rest of the levels, Alice has 2 points, while Bob has 3 points.
+*   If Alice plays till level 2 and Bob plays the rest of the levels, Alice has 3 points, while Bob has 2 points.
+*   If Alice plays till level 3 and Bob plays the rest of the levels, Alice has 4 points, while Bob has 1 point.
+
+Alice must play a minimum of 3 levels to gain more points.
+
+**Example 3:**
+
+**Input:** possible = [0,0]
+
+**Output:** \-1
+
+**Explanation:**
+
+The only possible way is for both players to play 1 level each. Alice plays level 0 and loses 1 point. Bob plays level 1 and loses 1 point. As both players have equal points, Alice can't gain more points than Bob.
+
+**Constraints:**
+
+*   <code>2 <= n == possible.length <= 10<sup>5</sup></code>
+*   `possible[i]` is either `0` or `1`.

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

@@ -0,0 +1,33 @@
+package g3001_3100.s3097_shortest_subarray_with_or_at_least_k_ii
+
+// #Medium #Array #Bit_Manipulation #Sliding_Window
+// #2024_04_20_Time_489_ms_(93.33%)_Space_79.6_MB_(13.33%)
+
+import kotlin.math.min
+
+class Solution {
+    fun minimumSubarrayLength(nums: IntArray, k: Int): Int {
+        val n = nums.size
+        if (nums[0] >= k) {
+            return 1
+        }
+        var res = Int.MAX_VALUE
+        for (i in 1 until n) {
+            if (nums[i] >= k) {
+                return 1
+            }
+            var j = i - 1
+            while (j >= 0 && (nums[i] or nums[j]) != nums[j]) {
+                nums[j] = nums[j] or nums[i]
+                if (nums[j] >= k) {
+                    res = min(res, (i - j + 1))
+                }
+                j--
+            }
+        }
+        if (res == Int.MAX_VALUE) {
+            return -1
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,45 @@
+3097\. Shortest Subarray With OR at Least K II
+
+Medium
+
+You are given an array `nums` of **non-negative** integers and an integer `k`.
+
+An array is called **special** if the bitwise `OR` of all of its elements is **at least** `k`.
+
+Return _the length of the **shortest** **special** **non-empty** subarray of_ `nums`, _or return_ `-1` _if no special subarray exists_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3], k = 2
+
+**Output:** 1
+
+**Explanation:**
+
+The subarray `[3]` has `OR` value of `3`. Hence, we return `1`.
+
+**Example 2:**
+
+**Input:** nums = [2,1,8], k = 10
+
+**Output:** 3
+
+**Explanation:**
+
+The subarray `[2,1,8]` has `OR` value of `11`. Hence, we return `3`.
+
+**Example 3:**
+
+**Input:** nums = [1,2], k = 0
+
+**Output:** 1
+
+**Explanation:**
+
+The subarray `[1]` has `OR` value of `1`. Hence, we return `1`.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>9</sup></code>
+*   <code>0 <= k <= 10<sup>9</sup></code>

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

@@ -0,0 +1,44 @@
+package g3001_3100.s3098_find_the_sum_of_subsequence_powers
+
+// #Hard #Array #Dynamic_Programming #Sorting #2024_04_20_Time_294_ms_(77.78%)_Space_49_MB_(66.67%)
+
+import kotlin.math.min
+
+class Solution {
+    private var len = 0
+
+    private fun dfs(lastIdx: Int, k: Int, minDiff: Int, dp: MutableMap<Long, Int>, nums: IntArray): Int {
+        if (k == 0) {
+            return minDiff
+        }
+        val key = ((minDiff.toLong()) shl 12) + (lastIdx.toLong() shl 6) + k
+        if (dp.containsKey(key)) {
+            return dp[key]!!
+        }
+        var res = 0
+        for (i in lastIdx + 1..len - k) {
+            res = (
+                res + dfs(
+                    i, k - 1, min(minDiff, (nums[i] - nums[lastIdx])), dp, nums
+                )
+                ) % MOD
+        }
+        dp[key] = res
+        return res
+    }
+
+    fun sumOfPowers(nums: IntArray, k: Int): Int {
+        len = nums.size
+        nums.sort()
+        val dp: MutableMap<Long, Int> = HashMap()
+        var res = 0
+        for (i in 0..len - k) {
+            res = (res + dfs(i, k - 1, nums[len - 1] - nums[0], dp, nums)) % MOD
+        }
+        return res
+    }
+
+    companion object {
+        private const val MOD = 1000000007
+    }
+}

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

@@ -0,0 +1,47 @@
+3098\. Find the Sum of Subsequence Powers
+
+Hard
+
+You are given an integer array `nums` of length `n`, and a **positive** integer `k`.
+
+The **power** of a subsequence is defined as the **minimum** absolute difference between **any** two elements in the subsequence.
+
+Return _the **sum** of **powers** of **all** subsequences of_ `nums` _which have length_ **_equal to_** `k`.
+
+Since the answer may be large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4], k = 3
+
+**Output:** 4
+
+**Explanation:**
+
+There are 4 subsequences in `nums` which have length 3: `[1,2,3]`, `[1,3,4]`, `[1,2,4]`, and `[2,3,4]`. The sum of powers is `|2 - 3| + |3 - 4| + |2 - 1| + |3 - 4| = 4`.
+
+**Example 2:**
+
+**Input:** nums = [2,2], k = 2
+
+**Output:** 0
+
+**Explanation:**
+
+The only subsequence in `nums` which has length 2 is `[2,2]`. The sum of powers is `|2 - 2| = 0`.
+
+**Example 3:**
+
+**Input:** nums = [4,3,-1], k = 2
+
+**Output:** 10
+
+**Explanation:**
+
+There are 3 subsequences in `nums` which have length 2: `[4,3]`, `[4,-1]`, and `[3,-1]`. The sum of powers is `|4 - 3| + |4 - (-1)| + |3 - (-1)| = 10`.
+
+**Constraints:**
+
+*   `2 <= n == nums.length <= 50`
+*   <code>-10<sup>8</sup> <= nums[i] <= 10<sup>8</sup></code>
+*   `2 <= k <= n`

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

@@ -0,0 +1,20 @@
+package g3001_3100.s3099_harshad_number
+
+// #Easy #Math #2024_04_20_Time_119_ms_(82.67%)_Space_33.2_MB_(45.33%)
+
+class Solution {
+    fun sumOfTheDigitsOfHarshadNumber(x: Int): Int {
+        var sum = 0
+        var digit: Int
+        var temp = x
+        while (temp != 0) {
+            digit = temp % 10
+            sum += digit
+            temp /= 10
+        }
+        if (sum != 0 && x % sum == 0) {
+            return sum
+        }
+        return -1
+    }
+}

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

@@ -0,0 +1,29 @@
+3099\. Harshad Number
+
+Easy
+
+An integer divisible by the **sum** of its digits is said to be a **Harshad** number. You are given an integer `x`. Return _the sum of the digits_ of `x` if `x` is a **Harshad** number, otherwise, return `-1`_._
+
+**Example 1:**
+
+**Input:** x = 18
+
+**Output:** 9
+
+**Explanation:**
+
+The sum of digits of `x` is `9`. `18` is divisible by `9`. So `18` is a Harshad number and the answer is `9`.
+
+**Example 2:**
+
+**Input:** x = 23
+
+**Output:** \-1
+
+**Explanation:**
+
+The sum of digits of `x` is `5`. `23` is not divisible by `5`. So `23` is not a Harshad number and the answer is `-1`.
+
+**Constraints:**
+
+*   `1 <= x <= 100`

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

@@ -0,0 +1,18 @@
+package g3001_3100.s3100_water_bottles_ii
+
+// #Medium #Math #Simulation #2024_04_20_Time_137_ms_(70.49%)_Space_33.8_MB_(50.82%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun maxBottlesDrunk(numBottles: Int, numExchange: Int): Int {
+        var numExchange = numExchange
+        var emptyBottles = numBottles
+        var bottleDrinks = numBottles
+        while (numExchange <= emptyBottles) {
+            bottleDrinks += 1
+            emptyBottles = 1 + (emptyBottles - numExchange)
+            numExchange++
+        }
+        return bottleDrinks
+    }
+}

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

@@ -0,0 +1,39 @@
+3100\. Water Bottles II
+
+Medium
+
+You are given two integers `numBottles` and `numExchange`.
+
+`numBottles` represents the number of full water bottles that you initially have. In one operation, you can perform one of the following operations:
+
+*   Drink any number of full water bottles turning them into empty bottles.
+*   Exchange `numExchange` empty bottles with one full water bottle. Then, increase `numExchange` by one.
+
+Note that you cannot exchange multiple batches of empty bottles for the same value of `numExchange`. For example, if `numBottles == 3` and `numExchange == 1`, you cannot exchange `3` empty water bottles for `3` full bottles.
+
+Return _the **maximum** number of water bottles you can drink_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2024/01/28/exampleone1.png)
+
+**Input:** numBottles = 13, numExchange = 6
+
+**Output:** 15
+
+**Explanation:** The table above shows the number of full water bottles, empty water bottles, the value of numExchange, and the number of bottles drunk.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2024/01/28/example231.png)
+
+**Input:** numBottles = 10, numExchange = 3
+
+**Output:** 13
+
+**Explanation:** The table above shows the number of full water bottles, empty water bottles, the value of numExchange, and the number of bottles drunk.
+
+**Constraints:**
+
+*   `1 <= numBottles <= 100`
+*   `1 <= numExchange <= 100`