Added tasks 3002-3019

Author: javadev

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

@@ -0,0 +1,36 @@
+package g3001_3100.s3002_maximum_size_of_a_set_after_removals
+
+// #Medium #Array #Hash_Table #Greedy #2024_02_28_Time_467_ms_(100.00%)_Space_51.9_MB_(100.00%)
+
+import kotlin.math.min
+
+class Solution {
+    fun maximumSetSize(nums1: IntArray, nums2: IntArray): Int {
+        val uniq1 = HashSet<Int>()
+        val uniq2 = HashSet<Int>()
+        for (i in nums1.indices) {
+            uniq1.add(nums1[i])
+            uniq2.add(nums2[i])
+        }
+        var common = 0
+        if (uniq1.size <= uniq2.size) {
+            for (u in uniq1) {
+                if (uniq2.contains(u)) {
+                    common++
+                }
+            }
+        } else {
+            for (u in uniq2) {
+                if (uniq1.contains(u)) {
+                    common++
+                }
+            }
+        }
+        val half = nums1.size / 2
+        val from1 = min(uniq1.size - common, half)
+        val from2 = min(uniq2.size - common, half)
+        val takeFromCommon1 = half - from1
+        val takeFromCommon2 = half - from2
+        return from1 + from2 + min(takeFromCommon1 + takeFromCommon2, common)
+    }
+}

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

@@ -0,0 +1,46 @@
+3002\. Maximum Size of a Set After Removals
+
+Medium
+
+You are given two **0-indexed** integer arrays `nums1` and `nums2` of even length `n`.
+
+You must remove `n / 2` elements from `nums1` and `n / 2` elements from `nums2`. After the removals, you insert the remaining elements of `nums1` and `nums2` into a set `s`.
+
+Return _the **maximum** possible size of the set_ `s`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,1,2], nums2 = [1,1,1,1]
+
+**Output:** 2
+
+**Explanation:** We remove two occurences of 1 from nums1 and nums2. After the removals, the arrays become equal to nums1 = [2,2] and nums2 = [1,1]. Therefore, s = {1,2}.
+
+It can be shown that 2 is the maximum possible size of the set s after the removals.
+
+**Example 2:**
+
+**Input:** nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3]
+
+**Output:** 5
+
+**Explanation:** We remove 2, 3, and 6 from nums1, as well as 2 and two occurrences of 3 from nums2. After the removals, the arrays become equal to nums1 = [1,4,5] and nums2 = [2,3,2]. Therefore, s = {1,2,3,4,5}.
+
+It can be shown that 5 is the maximum possible size of the set s after the removals.
+
+**Example 3:**
+
+**Input:** nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6]
+
+**Output:** 6
+
+**Explanation:** We remove 1, 2, and 3 from nums1, as well as 4, 5, and 6 from nums2. After the removals, the arrays become equal to nums1 = [1,2,3] and nums2 = [4,5,6]. Therefore, s = {1,2,3,4,5,6}.
+
+It can be shown that 6 is the maximum possible size of the set s after the removals.
+
+**Constraints:**
+
+*   `n == nums1.length == nums2.length`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   `n` is even.
+*   <code>1 <= nums1[i], nums2[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,92 @@
+package g3001_3100.s3003_maximize_the_number_of_partitions_after_operations
+
+// #Hard #String #Dynamic_Programming #Bit_Manipulation #Bitmask
+// #2024_02_28_Time_147_ms_(100.00%)_Space_35.7_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxPartitionsAfterOperations(s: String, k: Int): Int {
+        if (k == ALPHABET_SIZE) {
+            return 1
+        }
+        val n = s.length
+        val ansr = IntArray(n)
+        val usedr = IntArray(n)
+        var used = 0
+        var cntUsed = 0
+        var ans = 1
+        for (i in n - 1 downTo 0) {
+            val ch = s[i].code - 'a'.code
+            if ((used and (1 shl ch)) == 0) {
+                if (cntUsed == k) {
+                    cntUsed = 0
+                    used = 0
+                    ans++
+                }
+                used = used or (1 shl ch)
+                cntUsed++
+            }
+            ansr[i] = ans
+            usedr[i] = used
+        }
+        var ansl = 0
+        ans = ansr[0]
+        var l = 0
+        while (l < n) {
+            used = 0
+            cntUsed = 0
+            var usedBeforeLast = 0
+            var usedTwiceBeforeLast = 0
+            var last = -1
+            var r = l
+            while (r < n) {
+                val ch = s[r].code - 'a'.code
+                if ((used and (1 shl ch)) == 0) {
+                    if (cntUsed == k) {
+                        break
+                    }
+                    usedBeforeLast = used
+                    last = r
+                    used = used or (1 shl ch)
+                    cntUsed++
+                } else if (cntUsed < k) {
+                    usedTwiceBeforeLast = usedTwiceBeforeLast or (1 shl ch)
+                }
+                r++
+            }
+            if (cntUsed == k) {
+                if (last - l > Integer.bitCount(usedBeforeLast)) {
+                    ans = max(ans, (ansl + 1 + ansr[last]))
+                }
+                if (last + 1 < r) {
+                    if (last + 2 >= n) {
+                        ans = max(ans, (ansl + 1 + 1))
+                    } else {
+                        if (Integer.bitCount(usedr[last + 2]) == k) {
+                            val canUse = ((1 shl ALPHABET_SIZE) - 1) and used.inv() and usedr[last + 2].inv()
+                            ans = if (canUse > 0) {
+                                max(ans, (ansl + 1 + 1 + ansr[last + 2]))
+                            } else {
+                                max(ans, (ansl + 1 + ansr[last + 2]))
+                            }
+                            val l1 = s[last + 1].code - 'a'.code
+                            if ((usedTwiceBeforeLast and (1 shl l1)) == 0) {
+                                ans = max(ans, (ansl + 1 + ansr[last + 1]))
+                            }
+                        } else {
+                            ans = max(ans, (ansl + 1 + ansr[last + 2]))
+                        }
+                    }
+                }
+            }
+            l = r
+            ansl++
+        }
+        return ans
+    }
+
+    companion object {
+        private const val ALPHABET_SIZE = 'z'.code - 'a'.code + 1
+    }
+}

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

@@ -0,0 +1,66 @@
+3003\. Maximize the Number of Partitions After Operations
+
+Hard
+
+You are given a **0-indexed** string `s` and an integer `k`.
+
+You are to perform the following partitioning operations until `s` is **empty**:
+
+*   Choose the **longest** **prefix** of `s` containing at most `k` **distinct** characters.
+*   **Delete** the prefix from `s` and increase the number of partitions by one. The remaining characters (if any) in `s` maintain their initial order.
+
+**Before** the operations, you are allowed to change **at most** **one** index in `s` to another lowercase English letter.
+
+Return _an integer denoting the **maximum** number of resulting partitions after the operations by optimally choosing at most one index to change._
+
+**Example 1:**
+
+**Input:** s = "accca", k = 2
+
+**Output:** 3
+
+**Explanation:** In this example, to maximize the number of resulting partitions, s[2] can be changed to 'b'. s becomes "acbca". The operations can now be performed as follows until s becomes empty: 
+- Choose the longest prefix containing at most 2 distinct characters, "<ins>ac</ins>bca". 
+- Delete the prefix, and s becomes "bca". The number of partitions is now 1.
+- Choose the longest prefix containing at most 2 distinct characters, "<ins>bc</ins>a". 
+- Delete the prefix, and s becomes "a". The number of partitions is now 2. 
+- Choose the longest prefix containing at most 2 distinct characters, "<ins>a</ins>". 
+- Delete the prefix, and s becomes empty. The number of partitions is now 3. 
+
+Hence, the answer is 3. It can be shown that it is not possible to obtain more than 3 partitions.
+
+**Example 2:**
+
+**Input:** s = "aabaab", k = 3
+
+**Output:** 1
+
+**Explanation:** In this example, to maximize the number of resulting partitions we can leave s as it is. The operations can now be performed as follows until s becomes empty: 
+- Choose the longest prefix containing at most 3 distinct characters, "<ins>aabaab</ins>". 
+- Delete the prefix, and s becomes empty. The number of partitions becomes 1.
+
+Hence, the answer is 1. It can be shown that it is not possible to obtain more than 1 partition.
+
+**Example 3:**
+
+**Input:** s = "xxyz", k = 1
+
+**Output:** 4
+
+**Explanation:** In this example, to maximize the number of resulting partitions, s[1] can be changed to 'a'. s becomes "xayz". The operations can now be performed as follows until s becomes empty: 
+- Choose the longest prefix containing at most 1 distinct character, "<ins>x</ins>ayz". 
+- Delete the prefix, and s becomes "ayz". The number of partitions is now 1. 
+- Choose the longest prefix containing at most 1 distinct character, "<ins>a</ins>yz". 
+- Delete the prefix, and s becomes "yz". The number of partitions is now 2. 
+- Choose the longest prefix containing at most 1 distinct character, "<ins>y</ins>z". 
+- Delete the prefix, and s becomes "z". The number of partitions is now 3. 
+- Choose the longest prefix containing at most 1 distinct character, "<ins>z</ins>". 
+- Delete the prefix, and s becomes empty. The number of partitions is now 4. 
+
+Hence, the answer is 4. It can be shown that it is not possible to obtain more than 4 partitions.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists only of lowercase English letters.
+*   `1 <= k <= 26`

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

@@ -0,0 +1,41 @@
+package g3001_3100.s3005_count_elements_with_maximum_frequency
+
+// #Easy #Array #Hash_Table #Counting #2024_02_28_Time_168_ms_(80.00%)_Space_34.8_MB_(99.09%)
+
+class Solution {
+    fun maxFrequencyElements(nums: IntArray): Int {
+        if (nums.size == 1) {
+            return 1
+        }
+        val list: MutableList<Int> = ArrayList()
+        var co = 0
+        var prev = 0
+        for (num in nums) {
+            if (list.contains(num)) {
+                continue
+            }
+            list.add(num)
+            if (list.size == nums.size) {
+                break
+            }
+            var c = 0
+            for (i in nums) {
+                if (num == i) {
+                    c++
+                }
+            }
+            if (c > 1) {
+                if (c > prev) {
+                    co = c
+                    prev = c
+                } else if (c == prev) {
+                    co += c
+                }
+            }
+        }
+        if (co == 0) {
+            return nums.size
+        }
+        return co
+    }
+}

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

@@ -0,0 +1,30 @@
+3005\. Count Elements With Maximum Frequency
+
+Easy
+
+You are given an array `nums` consisting of **positive** integers.
+
+Return _the **total frequencies** of elements in_ `nums` _such that those elements all have the **maximum** frequency_.
+
+The **frequency** of an element is the number of occurrences of that element in the array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,3,1,4]
+
+**Output:** 4
+
+**Explanation:** The elements 1 and 2 have a frequency of 2 which is the maximum frequency in the array. So the number of elements in the array with maximum frequency is 4.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4,5]
+
+**Output:** 5
+
+**Explanation:** All elements of the array have a frequency of 1 which is the maximum. So the number of elements in the array with maximum frequency is 5.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`