Added tasks 3206-3213

Author: javadev

src/main/kotlin/g3201_3300/s3206_alternating_groups_i/Solution.kt

@@ -0,0 +1,22 @@
+package g3201_3300.s3206_alternating_groups_i
+
+// #Easy #Array #Sliding_Window #2024_07_11_Time_167_ms_(88.14%)_Space_38.3_MB_(23.73%)
+
+class Solution {
+    fun numberOfAlternatingGroups(colors: IntArray): Int {
+        val n = colors.size
+        var count = 0
+        if (colors[n - 1] != colors[0] && colors[0] != colors[1]) {
+            count++
+        }
+        if (colors[n - 1] != colors[0] && colors[n - 1] != colors[n - 2]) {
+            count++
+        }
+        for (i in 1 until n - 1) {
+            if (colors[i] != colors[i - 1] && colors[i] != colors[i + 1]) {
+                count++
+            }
+        }
+        return count
+    }
+}

src/main/kotlin/g3201_3300/s3206_alternating_groups_i/readme.md

@@ -0,0 +1,43 @@
+3206\. Alternating Groups I
+
+Easy
+
+There is a circle of red and blue tiles. You are given an array of integers `colors`. The color of tile `i` is represented by `colors[i]`:
+
+*   `colors[i] == 0` means that tile `i` is **red**.
+*   `colors[i] == 1` means that tile `i` is **blue**.
+
+Every 3 contiguous tiles in the circle with **alternating** colors (the middle tile has a different color from its **left** and **right** tiles) is called an **alternating** group.
+
+Return the number of **alternating** groups.
+
+**Note** that since `colors` represents a **circle**, the **first** and the **last** tiles are considered to be next to each other.
+
+**Example 1:**
+
+**Input:** colors = [1,1,1]
+
+**Output:** 0
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/05/16/image_2024-05-16_23-53-171.png)
+
+**Example 2:**
+
+**Input:** colors = [0,1,0,0,1]
+
+**Output:** 3
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/05/16/image_2024-05-16_23-47-491.png)
+
+Alternating groups:
+
+**![](https://assets.leetcode.com/uploads/2024/05/16/image_2024-05-16_23-50-441.png)**![](https://assets.leetcode.com/uploads/2024/05/16/image_2024-05-16_23-48-211.png)**![](https://assets.leetcode.com/uploads/2024/05/16/image_2024-05-16_23-49-351.png)**
+
+**Constraints:**
+
+*   `3 <= colors.length <= 100`
+*   `0 <= colors[i] <= 1`

src/main/kotlin/g3201_3300/s3207_maximum_points_after_enemy_battles/Solution.kt

@@ -0,0 +1,24 @@
+package g3201_3300.s3207_maximum_points_after_enemy_battles
+
+// #Medium #Array #Greedy #2024_07_11_Time_470_ms_(100.00%)_Space_62_MB_(95.56%)
+
+import kotlin.math.min
+
+class Solution {
+    fun maximumPoints(enemyEnergies: IntArray, currentEnergy: Int): Long {
+        val n = enemyEnergies.size
+        var min = enemyEnergies[0]
+        for (i in 1 until n) {
+            min = min(min.toDouble(), enemyEnergies[i].toDouble()).toInt()
+        }
+        if (currentEnergy == 0 || currentEnergy < min) {
+            return 0
+        }
+        var sum = currentEnergy.toLong()
+        for (i in n - 1 downTo 0) {
+            sum += enemyEnergies[i].toLong()
+        }
+        sum -= min.toLong()
+        return sum / min
+    }
+}

src/main/kotlin/g3201_3300/s3207_maximum_points_after_enemy_battles/readme.md

@@ -0,0 +1,52 @@
+3207\. Maximum Points After Enemy Battles
+
+Medium
+
+You are given an integer array `enemyEnergies` denoting the energy values of various enemies.
+
+You are also given an integer `currentEnergy` denoting the amount of energy you have initially.
+
+You start with 0 points, and all the enemies are unmarked initially.
+
+You can perform **either** of the following operations **zero** or multiple times to gain points:
+
+*   Choose an **unmarked** enemy, `i`, such that `currentEnergy >= enemyEnergies[i]`. By choosing this option:
+    *   You gain 1 point.
+    *   Your energy is reduced by the enemy's energy, i.e. `currentEnergy = currentEnergy - enemyEnergies[i]`.
+*   If you have **at least** 1 point, you can choose an **unmarked** enemy, `i`. By choosing this option:
+    *   Your energy increases by the enemy's energy, i.e. `currentEnergy = currentEnergy + enemyEnergies[i]`.
+    *   The enemy `i` is **marked**.
+
+Return an integer denoting the **maximum** points you can get in the end by optimally performing operations.
+
+**Example 1:**
+
+**Input:** enemyEnergies = [3,2,2], currentEnergy = 2
+
+**Output:** 3
+
+**Explanation:**
+
+The following operations can be performed to get 3 points, which is the maximum:
+
+*   First operation on enemy 1: `points` increases by 1, and `currentEnergy` decreases by 2. So, `points = 1`, and `currentEnergy = 0`.
+*   Second operation on enemy 0: `currentEnergy` increases by 3, and enemy 0 is marked. So, `points = 1`, `currentEnergy = 3`, and marked enemies = `[0]`.
+*   First operation on enemy 2: `points` increases by 1, and `currentEnergy` decreases by 2. So, `points = 2`, `currentEnergy = 1`, and marked enemies = `[0]`.
+*   Second operation on enemy 2: `currentEnergy` increases by 2, and enemy 2 is marked. So, `points = 2`, `currentEnergy = 3`, and marked enemies = `[0, 2]`.
+*   First operation on enemy 1: `points` increases by 1, and `currentEnergy` decreases by 2. So, `points = 3`, `currentEnergy = 1`, and marked enemies = `[0, 2]`.
+
+**Example 2:**
+
+**Input:** enemyEnergies = [2], currentEnergy = 10
+
+**Output:** 5
+
+**Explanation:**
+
+Performing the first operation 5 times on enemy 0 results in the maximum number of points.
+
+**Constraints:**
+
+*   <code>1 <= enemyEnergies.length <= 10<sup>5</sup></code>
+*   <code>1 <= enemyEnergies[i] <= 10<sup>9</sup></code>
+*   <code>0 <= currentEnergy <= 10<sup>9</sup></code>

src/main/kotlin/g3201_3300/s3208_alternating_groups_ii/Solution.kt

@@ -0,0 +1,43 @@
+package g3201_3300.s3208_alternating_groups_ii
+
+// #Medium #Array #Sliding_Window #2024_07_11_Time_449_ms_(97.62%)_Space_59.6_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun numberOfAlternatingGroups(colors: IntArray, k: Int): Int {
+        var i = 0
+        var len = 0
+        var total = 0
+        while (i < colors.size - 1) {
+            var j = i + 1
+            if (colors[j] != colors[i]) {
+                len = 2
+                j++
+                while (j < colors.size && colors[j] != colors[j - 1]) {
+                    j++
+                    len++
+                }
+                if (j == colors.size) {
+                    break
+                }
+                total += max(0, (len - k + 1))
+            }
+            i = j
+            len = 0
+        }
+        if (colors[0] != colors[colors.size - 1]) {
+            len = if (len == 0) 2 else len + 1
+            var j = 1
+            while (j < colors.size && colors[j] != colors[j - 1]) {
+                j++
+                len++
+            }
+            if (j >= k) {
+                len -= (j - k + 1)
+            }
+        }
+        total += max(0, (len - k + 1))
+        return total
+    }
+}

src/main/kotlin/g3201_3300/s3208_alternating_groups_ii/readme.md

@@ -0,0 +1,58 @@
+3208\. Alternating Groups II
+
+Medium
+
+There is a circle of red and blue tiles. You are given an array of integers `colors` and an integer `k`. The color of tile `i` is represented by `colors[i]`:
+
+*   `colors[i] == 0` means that tile `i` is **red**.
+*   `colors[i] == 1` means that tile `i` is **blue**.
+
+An **alternating** group is every `k` contiguous tiles in the circle with **alternating** colors (each tile in the group except the first and last one has a different color from its **left** and **right** tiles).
+
+Return the number of **alternating** groups.
+
+**Note** that since `colors` represents a **circle**, the **first** and the **last** tiles are considered to be next to each other.
+
+**Example 1:**
+
+**Input:** colors = [0,1,0,1,0], k = 3
+
+**Output:** 3
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-183519.png)**
+
+Alternating groups:
+
+![](https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-182448.png)![](https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-182844.png)![](https://assets.leetcode.com/uploads/2024/05/28/screenshot-2024-05-28-183057.png)
+
+**Example 2:**
+
+**Input:** colors = [0,1,0,0,1,0,1], k = 6
+
+**Output:** 2
+
+**Explanation:**
+
+**![](https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-183907.png)**
+
+Alternating groups:
+
+![](https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184128.png)![](https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184240.png)
+
+**Example 3:**
+
+**Input:** colors = [1,1,0,1], k = 4
+
+**Output:** 0
+
+**Explanation:**
+
+![](https://assets.leetcode.com/uploads/2024/06/19/screenshot-2024-05-28-184516.png)
+
+**Constraints:**
+
+*   <code>3 <= colors.length <= 10<sup>5</sup></code>
+*   `0 <= colors[i] <= 1`
+*   `3 <= k <= colors.length`

src/main/kotlin/g3201_3300/s3209_number_of_subarrays_with_and_value_of_k/Solution.kt

@@ -0,0 +1,28 @@
+package g3201_3300.s3209_number_of_subarrays_with_and_value_of_k
+
+// #Hard #Array #Binary_Search #Bit_Manipulation #Segment_Tree
+// #2024_07_11_Time_530_ms_(100.00%)_Space_58.2_MB_(76.19%)
+
+class Solution {
+    fun countSubarrays(nums: IntArray, k: Int): Long {
+        var ans: Long = 0
+        var left = 0
+        var right = 0
+        for (i in nums.indices) {
+            val x = nums[i]
+            var j = i - 1
+            while (j >= 0 && (nums[j] and x) != nums[j]) {
+                nums[j] = nums[j] and x
+                j--
+            }
+            while (left <= i && nums[left] < k) {
+                left++
+            }
+            while (right <= i && nums[right] <= k) {
+                right++
+            }
+            ans += (right - left).toLong()
+        }
+        return ans
+    }
+}

src/main/kotlin/g3201_3300/s3209_number_of_subarrays_with_and_value_of_k/readme.md

@@ -0,0 +1,40 @@
+3209\. Number of Subarrays With AND Value of K
+
+Hard
+
+Given an array of integers `nums` and an integer `k`, return the number of subarrays of `nums` where the bitwise `AND` of the elements of the subarray equals `k`.
+
+**Example 1:**
+
+**Input:** nums = [1,1,1], k = 1
+
+**Output:** 6
+
+**Explanation:**
+
+All subarrays contain only 1's.
+
+**Example 2:**
+
+**Input:** nums = [1,1,2], k = 1
+
+**Output:** 3
+
+**Explanation:**
+
+Subarrays having an `AND` value of 1 are: <code>[<ins>**1**</ins>,1,2]</code>, <code>[1,<ins>**1**</ins>,2]</code>, <code>[<ins>**1,1**</ins>,2]</code>.
+
+**Example 3:**
+
+**Input:** nums = [1,2,3], k = 2
+
+**Output:** 2
+
+**Explanation:**
+
+Subarrays having an `AND` value of 2 are: <code>[1,**<ins>2</ins>**,3]</code>, <code>[1,<ins>**2,3**</ins>]</code>.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>0 <= nums[i], k <= 10<sup>9</sup></code>

src/main/kotlin/g3201_3300/s3210_find_the_encrypted_string/Solution.kt

@@ -0,0 +1,15 @@
+package g3201_3300.s3210_find_the_encrypted_string
+
+// #Easy #String #2024_07_11_Time_170_ms_(62.69%)_Space_35.5_MB_(67.16%)
+
+@Suppress("NAME_SHADOWING")
+class Solution {
+    fun getEncryptedString(s: String, k: Int): String {
+        var k = k
+        val n = s.length
+        k %= n
+        val str = StringBuilder(s.substring(k, n))
+        str.append(s.substring(0, k))
+        return str.toString()
+    }
+}

src/main/kotlin/g3201_3300/s3210_find_the_encrypted_string/readme.md

@@ -0,0 +1,38 @@
+3210\. Find the Encrypted String
+
+Easy
+
+You are given a string `s` and an integer `k`. Encrypt the string using the following algorithm:
+
+*   For each character `c` in `s`, replace `c` with the <code>k<sup>th</sup></code> character after `c` in the string (in a cyclic manner).
+
+Return the _encrypted string_.
+
+**Example 1:**
+
+**Input:** s = "dart", k = 3
+
+**Output:** "tdar"
+
+**Explanation:**
+
+*   For `i = 0`, the 3<sup>rd</sup> character after `'d'` is `'t'`.
+*   For `i = 1`, the 3<sup>rd</sup> character after `'a'` is `'d'`.
+*   For `i = 2`, the 3<sup>rd</sup> character after `'r'` is `'a'`.
+*   For `i = 3`, the 3<sup>rd</sup> character after `'t'` is `'r'`.
+
+**Example 2:**
+
+**Input:** s = "aaa", k = 1
+
+**Output:** "aaa"
+
+**Explanation:**
+
+As all the characters are the same, the encrypted string will also be the same.
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   <code>1 <= k <= 10<sup>4</sup></code>
+*   `s` consists only of lowercase English letters.