From 4aedb5492870912bba2e7e6d3c52fd442e2d9058 Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Mon, 3 Nov 2025 12:18:21 +0200
Subject: [PATCH 1/5] Added tasks 3731-3734

---
 .../s3731_find_missing_elements/Solution.kt   | 18 ++++
 .../s3731_find_missing_elements/readme.md     | 46 +++++++++
 .../Solution.kt                               | 22 +++++
 .../readme.md                                 | 51 ++++++++++
 .../Solution.kt                               | 43 +++++++++
 .../readme.md                                 | 53 +++++++++++
 .../Solution.kt                               | 94 +++++++++++++++++++
 .../readme.md                                 | 55 +++++++++++
 .../SolutionTest.kt                           | 31 ++++++
 .../SolutionTest.kt                           | 28 ++++++
 .../SolutionTest.kt                           | 31 ++++++
 .../SolutionTest.kt                           | 39 ++++++++
 12 files changed, 511 insertions(+)
 create mode 100644 src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
 create mode 100644 src/main/kotlin/g3701_3800/s3731_find_missing_elements/readme.md
 create mode 100644 src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
 create mode 100644 src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/readme.md
 create mode 100644 src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
 create mode 100644 src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/readme.md
 create mode 100644 src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
 create mode 100644 src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/readme.md
 create mode 100644 src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
 create mode 100644 src/test/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/SolutionTest.kt
 create mode 100644 src/test/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/SolutionTest.kt
 create mode 100644 src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt

diff --git a/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
new file mode 100644
index 00000000..1bb87c3f
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
@@ -0,0 +1,18 @@
+package g3701_3800.s3731_find_missing_elements
+
+// #Easy #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_48.81_MB_(11.11%)
+
+class Solution {
+    fun findMissingElements(nums: IntArray): MutableList<Int> {
+        val list: MutableList<Int> = ArrayList()
+        nums.sort()
+        for (i in 0..<nums.size - 1) {
+            if (nums[i + 1] - nums[i] > 1) {
+                for (j in nums[i] + 1..<nums[i + 1]) {
+                    list.add(j)
+                }
+            }
+        }
+        return list
+    }
+}
diff --git a/src/main/kotlin/g3701_3800/s3731_find_missing_elements/readme.md b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/readme.md
new file mode 100644
index 00000000..e48870f9
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/readme.md
@@ -0,0 +1,46 @@
+3731\. Find Missing Elements
+
+Easy
+
+You are given an integer array `nums` consisting of **unique** integers.
+
+Originally, `nums` contained **every integer** within a certain range. However, some integers might have gone **missing** from the array.
+
+The **smallest** and **largest** integers of the original range are still present in `nums`.
+
+Return a **sorted** list of all the missing integers in this range. If no integers are missing, return an **empty** list.
+
+**Example 1:**
+
+**Input:** nums = [1,4,2,5]
+
+**Output:** [3]
+
+**Explanation:**
+
+The smallest integer is 1 and the largest is 5, so the full range should be `[1,2,3,4,5]`. Among these, only 3 is missing.
+
+**Example 2:**
+
+**Input:** nums = [7,8,6,9]
+
+**Output:** []
+
+**Explanation:**
+
+The smallest integer is 6 and the largest is 9, so the full range is `[6,7,8,9]`. All integers are already present, so no integer is missing.
+
+**Example 3:**
+
+**Input:** nums = [5,1]
+
+**Output:** [2,3,4]
+
+**Explanation:**
+
+The smallest integer is 1 and the largest is 5, so the full range should be `[1,2,3,4,5]`. The missing integers are 2, 3, and 4.
+
+**Constraints:**
+
+*   `2 <= nums.length <= 100`
+*   `1 <= nums[i] <= 100`
\ No newline at end of file
diff --git a/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
new file mode 100644
index 00000000..35bc0dd4
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
@@ -0,0 +1,22 @@
+package g3701_3800.s3732_maximum_product_of_three_elements_after_one_replacement
+
+// #Medium #Weekly_Contest_474 #2025_11_03_Time_6_ms_(100.00%)_Space_75.20_MB_(76.92%)
+
+import kotlin.math.abs
+
+class Solution {
+    fun maxProduct(nums: IntArray): Long {
+        var a: Long = 0
+        var b: Long = 0
+        for (x in nums) {
+            val ax = abs(x).toLong()
+            if (ax >= a) {
+                b = a
+                a = ax
+            } else if (ax > b) {
+                b = ax
+            }
+        }
+        return 100000L * a * b
+    }
+}
diff --git a/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/readme.md b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/readme.md
new file mode 100644
index 00000000..48ad50d9
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/readme.md
@@ -0,0 +1,51 @@
+3732\. Maximum Product of Three Elements After One Replacement
+
+Medium
+
+You are given an integer array `nums`.
+
+You **must** replace **exactly one** element in the array with **any** integer value in the range <code>[-10<sup>5</sup>, 10<sup>5</sup>]</code> (inclusive).
+
+After performing this single replacement, determine the **maximum possible product** of **any three** elements at **distinct indices** from the modified array.
+
+Return an integer denoting the **maximum product** achievable.
+
+**Example 1:**
+
+**Input:** nums = [-5,7,0]
+
+**Output:** 3500000
+
+**Explanation:**
+
+Replacing 0 with -10<sup>5</sup> gives the array <code>[-5, 7, -10<sup>5</sup>]</code>, which has a product <code>(-5) * 7 * (-10<sup>5</sup>) = 3500000</code>. The maximum product is 3500000.
+
+**Example 2:**
+
+**Input:** nums = [-4,-2,-1,-3]
+
+**Output:** 1200000
+
+**Explanation:**
+
+Two ways to achieve the maximum product include:
+
+*   `[-4, -2, -3]` → replace -2 with 10<sup>5</sup> → product = <code>(-4) * 10<sup>5</sup> * (-3) = 1200000</code>.
+*   `[-4, -1, -3]` → replace -1 with 10<sup>5</sup> → product = <code>(-4) * 10<sup>5</sup> * (-3) = 1200000</code>.
+
+The maximum product is 1200000.
+
+**Example 3:**
+
+**Input:** nums = [0,10,0]
+
+**Output:** 0
+
+**Explanation:**
+
+There is no way to replace an element with another integer and not have a 0 in the array. Hence, the product of all three elements will always be 0, and the maximum product is 0.
+
+**Constraints:**
+
+*   <code>3 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
new file mode 100644
index 00000000..42cf610a
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
@@ -0,0 +1,43 @@
+package g3701_3800.s3733_minimum_time_to_complete_all_deliveries
+
+// #Medium #Weekly_Contest_474 #2025_11_03_Time_2_ms_(100.00%)_Space_42.94_MB_(100.00%)
+
+import kotlin.math.max
+
+class Solution {
+    private fun func(mid: Long, d: IntArray, r: IntArray): Boolean {
+        val lcm = r[0].toLong() * r[1] / gcd(r[0].toLong(), r[1].toLong())
+        val a1 = mid / r[0]
+        val a2 = mid / r[1]
+        val a3 = mid / lcm
+        val b = mid - a1 - a2 + a3
+        val o1 = a2 - a3
+        val o2 = a1 - a3
+        val d0 = max(d[0] - o1, 0)
+        val d1 = max(d[1] - o2, 0)
+        return b >= d0 + d1
+    }
+
+    private fun gcd(a: Long, b: Long): Long {
+        if (b == 0L) {
+            return a
+        }
+        return gcd(b, a % b)
+    }
+
+    fun minimumTime(d: IntArray, r: IntArray): Long {
+        var lo: Long = 0
+        var hi = 1e12.toLong()
+        var ans = Long.MAX_VALUE
+        while (lo <= hi) {
+            val mid = (lo + hi) / 2
+            if (func(mid, d, r)) {
+                ans = mid
+                hi = mid - 1
+            } else {
+                lo = mid + 1
+            }
+        }
+        return ans
+    }
+}
diff --git a/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/readme.md b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/readme.md
new file mode 100644
index 00000000..4fbcff72
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/readme.md
@@ -0,0 +1,53 @@
+3733\. Minimum Time to Complete All Deliveries
+
+Medium
+
+You are given two integer arrays of size 2: <code>d = [d<sub>1</sub>, d<sub>2</sub>]</code> and <code>r = [r<sub>1</sub>, r<sub>2</sub>]</code>.
+
+Two delivery drones are tasked with completing a specific number of deliveries. Drone `i` must complete <code>d<sub>i</sub></code> deliveries.
+
+Each delivery takes **exactly** one hour and **only one** drone can make a delivery at any given hour.
+
+Additionally, both drones require recharging at specific intervals during which they cannot make deliveries. Drone `i` must recharge every <code>r<sub>i</sub></code> hours (i.e. at hours that are multiples of <code>r<sub>i</sub></code>).
+
+Return an integer denoting the **minimum** total time (in hours) required to complete all deliveries.
+
+**Example 1:**
+
+**Input:** d = [3,1], r = [2,3]
+
+**Output:** 5
+
+**Explanation:**
+
+*   The first drone delivers at hours 1, 3, 5 (recharges at hours 2, 4).
+*   The second drone delivers at hour 2 (recharges at hour 3).
+
+**Example 2:**
+
+**Input:** d = [1,3], r = [2,2]
+
+**Output:** 7
+
+**Explanation:**
+
+*   The first drone delivers at hour 3 (recharges at hours 2, 4, 6).
+*   The second drone delivers at hours 1, 5, 7 (recharges at hours 2, 4, 6).
+
+**Example 3:**
+
+**Input:** d = [2,1], r = [3,4]
+
+**Output:** 3
+
+**Explanation:**
+
+*   The first drone delivers at hours 1, 2 (recharges at hour 3).
+*   The second drone delivers at hour 3.
+
+**Constraints:**
+
+*   <code>d = [d<sub>1</sub>, d<sub>2</sub>]</code>
+*   <code>1 <= d<sub>i</sub> <= 10<sup>9</sup></code>
+*   <code>r = [r<sub>1</sub>, r<sub>2</sub>]</code>
+*   <code>2 <= r<sub>i</sub> <= 3 * 10<sup>4</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
new file mode 100644
index 00000000..9b03fc3e
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
@@ -0,0 +1,94 @@
+package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_greater_than_target
+
+// #Hard #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_47.24_MB_(100.00%)
+
+class Solution {
+    fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
+        if (l > r) {
+            return String(ans).compareTo(target) > 0
+        }
+        if (l == r) {
+            var left = '#'
+            for (k in 0..25) {
+                if (freq[k] > 0) {
+                    left = (k + 'a'.code).toChar()
+                }
+            }
+            freq[left.code - 'a'.code]--
+            ans[l] = left
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
+                return true
+            }
+            freq[left.code - 'a'.code]++
+            ans[l] = '#'
+            return false
+        }
+        if (end) {
+            for (j in 0..25) {
+                if (freq[j] > 1) {
+                    freq[j] -= 2
+                    ans[r] = (j + 'a'.code).toChar()
+                    ans[l] = ans[r]
+                    if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
+                        return true
+                    }
+                    ans[r] = '#'
+                    ans[l] = ans[r]
+                    freq[j] += 2
+                }
+            }
+            return false
+        }
+        val curr = target.get(i)
+        var next = '1'
+        for (k in target.get(i).code - 'a'.code + 1..25) {
+            if (freq[k] > 1) {
+                next = (k + 'a'.code).toChar()
+                break
+            }
+        }
+        if (freq[curr.code - 'a'.code] > 1) {
+            ans[r] = curr
+            ans[l] = ans[r]
+            freq[curr.code - 'a'.code] -= 2
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
+                return true
+            }
+            freq[curr.code - 'a'.code] += 2
+        }
+        if (next != '1') {
+            ans[r] = next
+            ans[l] = ans[r]
+            freq[next.code - 'a'.code] -= 2
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, true)) {
+                return true
+            }
+            freq[next.code - 'a'.code] += 2
+        }
+        ans[r] = '#'
+        ans[l] = ans[r]
+        return false
+    }
+
+    fun lexPalindromicPermutation(s: String, target: String): String {
+        val freq = IntArray(26)
+        for (i in 0..<s.length) {
+            freq[s.get(i).code - 'a'.code]++
+        }
+        var oddc = 0
+        for (i in 0..25) {
+            if (freq[i] % 2 == 1) {
+                oddc++
+            }
+        }
+        if (oddc > 1) {
+            return ""
+        }
+        val ans = CharArray(s.length)
+        ans.fill('#')
+        if (func(0, target, ans, 0, s.length - 1, freq, false)) {
+            return String(ans)
+        }
+        return ""
+    }
+}
diff --git a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/readme.md b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/readme.md
new file mode 100644
index 00000000..fbf7ec28
--- /dev/null
+++ b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/readme.md
@@ -0,0 +1,55 @@
+3734\. Lexicographically Smallest Palindromic Permutation Greater Than Target
+
+Hard
+
+You are given two strings `s` and `target`, each of length `n`, consisting of lowercase English letters.
+
+Return the **lexicographically smallest string** that is **both** a **palindromic permutation** of `s` and **strictly** greater than `target`. If no such permutation exists, return an empty string.
+
+**Example 1:**
+
+**Input:** s = "baba", target = "abba"
+
+**Output:** "baab"
+
+**Explanation:**
+
+*   The palindromic permutations of `s` (in lexicographical order) are `"abba"` and `"baab"`.
+*   The lexicographically smallest permutation that is strictly greater than `target` is `"baab"`.
+
+**Example 2:**
+
+**Input:** s = "baba", target = "bbaa"
+
+**Output:** ""
+
+**Explanation:**
+
+*   The palindromic permutations of `s` (in lexicographical order) are `"abba"` and `"baab"`.
+*   None of them is lexicographically strictly greater than `target`. Therefore, the answer is `""`.
+
+**Example 3:**
+
+**Input:** s = "abc", target = "abb"
+
+**Output:** ""
+
+**Explanation:**
+
+`s` has no palindromic permutations. Therefore, the answer is `""`.
+
+**Example 4:**
+
+**Input:** s = "aac", target = "abb"
+
+**Output:** "aca"
+
+**Explanation:**
+
+*   The only palindromic permutation of `s` is `"aca"`.
+*   `"aca"` is strictly greater than `target`. Therefore, the answer is `"aca"`.
+
+**Constraints:**
+
+*   `1 <= n == s.length == target.length <= 300`
+*   `s` and `target` consist of only lowercase English letters.
\ No newline at end of file
diff --git a/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
new file mode 100644
index 00000000..404be6d3
--- /dev/null
+++ b/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
@@ -0,0 +1,31 @@
+package g3701_3800.s3731_find_missing_elements
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun findMissingElements() {
+        assertThat<MutableList<Int>>(
+            Solution().findMissingElements(intArrayOf(1, 4, 2, 5)),
+            equalTo<MutableList<Int>>(mutableListOf<Int>(3)),
+        )
+    }
+
+    @Test
+    fun findMissingElements2() {
+        assertThat<MutableList<Int>>(
+            Solution().findMissingElements(intArrayOf(7, 8, 6, 9)),
+            equalTo<MutableList<out Any>>(mutableListOf<Any>()),
+        )
+    }
+
+    @Test
+    fun findMissingElements3() {
+        assertThat<MutableList<Int>>(
+            Solution().findMissingElements(intArrayOf(5, 1)),
+            equalTo<MutableList<Int>>(mutableListOf<Int>(2, 3, 4)),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/SolutionTest.kt
new file mode 100644
index 00000000..7269907e
--- /dev/null
+++ b/src/test/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/SolutionTest.kt
@@ -0,0 +1,28 @@
+package g3701_3800.s3732_maximum_product_of_three_elements_after_one_replacement
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxProduct() {
+        assertThat<Long>(
+            Solution().maxProduct(intArrayOf(-5, 7, 0)),
+            equalTo<Long>(3500000L),
+        )
+    }
+
+    @Test
+    fun maxProduct2() {
+        assertThat<Long>(
+            Solution().maxProduct(intArrayOf(-4, -2, -1, -3)),
+            equalTo<Long>(1200000L),
+        )
+    }
+
+    @Test
+    fun maxProduct3() {
+        assertThat<Long>(Solution().maxProduct(intArrayOf(0, 10, 0)), equalTo<Long>(0L))
+    }
+}
diff --git a/src/test/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/SolutionTest.kt
new file mode 100644
index 00000000..ad9dfc07
--- /dev/null
+++ b/src/test/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/SolutionTest.kt
@@ -0,0 +1,31 @@
+package g3701_3800.s3733_minimum_time_to_complete_all_deliveries
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minimumTime() {
+        assertThat<Long>(
+            Solution().minimumTime(intArrayOf(3, 1), intArrayOf(2, 3)),
+            equalTo<Long>(5L),
+        )
+    }
+
+    @Test
+    fun minimumTime2() {
+        assertThat<Long>(
+            Solution().minimumTime(intArrayOf(1, 3), intArrayOf(2, 2)),
+            equalTo<Long>(7L),
+        )
+    }
+
+    @Test
+    fun minimumTime3() {
+        assertThat<Long>(
+            Solution().minimumTime(intArrayOf(2, 1), intArrayOf(3, 4)),
+            equalTo<Long>(3L),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt
new file mode 100644
index 00000000..52f8975b
--- /dev/null
+++ b/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt
@@ -0,0 +1,39 @@
+package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_greater_than_target
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun lexPalindromicPermutation() {
+        assertThat<String>(
+            Solution().lexPalindromicPermutation("baba", "abba"),
+            equalTo<String>("baab"),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation2() {
+        assertThat<String>(
+            Solution().lexPalindromicPermutation("baba", "bbaa"),
+            equalTo<String>(""),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation3() {
+        assertThat<String>(
+            Solution().lexPalindromicPermutation("abc", "abb"),
+            equalTo<String>(""),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation4() {
+        assertThat<String>(
+            Solution().lexPalindromicPermutation("aac", "abb"),
+            equalTo<String>("aca"),
+        )
+    }
+}

From 0171d29791cc10089f015e2ecec1edebd072ed8e Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Mon, 3 Nov 2025 13:03:17 +0200
Subject: [PATCH 2/5] Fixed sonar

---
 .../Solution.kt                                             | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
index 9b03fc3e..30a5947c 100644
--- a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
@@ -39,9 +39,9 @@ class Solution {
             }
             return false
         }
-        val curr = target.get(i)
+        val curr = target[i]
         var next = '1'
-        for (k in target.get(i).code - 'a'.code + 1..25) {
+        for (k in target[i].code - 'a'.code + 1..25) {
             if (freq[k] > 1) {
                 next = (k + 'a'.code).toChar()
                 break
@@ -73,7 +73,7 @@ class Solution {
     fun lexPalindromicPermutation(s: String, target: String): String {
         val freq = IntArray(26)
         for (i in 0..<s.length) {
-            freq[s.get(i).code - 'a'.code]++
+            freq[s[i].code - 'a'.code]++
         }
         var oddc = 0
         for (i in 0..25) {

From 99be171d04eb1ea1ec545ffd0a12702d0cb7e21b Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Wed, 5 Nov 2025 18:49:46 +0200
Subject: [PATCH 3/5] Added tags

---
 .../s3731_find_missing_elements/Solution.kt   | 27 +++++++----
 .../Solution.kt                               |  3 +-
 .../Solution.kt                               | 48 +++++++++++--------
 .../Solution.kt                               | 38 +++++++--------
 4 files changed, 67 insertions(+), 49 deletions(-)

diff --git a/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
index 1bb87c3f..799091fe 100644
--- a/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3731_find_missing_elements/Solution.kt
@@ -1,17 +1,28 @@
 package g3701_3800.s3731_find_missing_elements
 
-// #Easy #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_48.81_MB_(11.11%)
+// #Easy #Array #Hash_Table #Sorting #Weekly_Contest_474
+// #2025_11_05_Time_2_ms_(100.00%)_Space_46.48_MB_(84.44%)
 
 class Solution {
-    fun findMissingElements(nums: IntArray): MutableList<Int> {
+    fun findMissingElements(nums: IntArray): List<Int> {
+        var maxi = 0
+        var mini = 101
         val list: MutableList<Int> = ArrayList()
-        nums.sort()
-        for (i in 0..<nums.size - 1) {
-            if (nums[i + 1] - nums[i] > 1) {
-                for (j in nums[i] + 1..<nums[i + 1]) {
-                    list.add(j)
-                }
+        val array = BooleanArray(101)
+        for (num in nums) {
+            array[num] = true
+            if (maxi < num) {
+                maxi = num
             }
+            if (mini > num) {
+                mini = num
+            }
+        }
+        for (index in mini + 1..<maxi) {
+            if (array[index]) {
+                continue
+            }
+            list.add(index)
         }
         return list
     }
diff --git a/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
index 35bc0dd4..f507fdfc 100644
--- a/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3732_maximum_product_of_three_elements_after_one_replacement/Solution.kt
@@ -1,6 +1,7 @@
 package g3701_3800.s3732_maximum_product_of_three_elements_after_one_replacement
 
-// #Medium #Weekly_Contest_474 #2025_11_03_Time_6_ms_(100.00%)_Space_75.20_MB_(76.92%)
+// #Medium #Array #Math #Sorting #Greedy #Weekly_Contest_474
+// #2025_11_05_Time_6_ms_(88.00%)_Space_74.51_MB_(84.00%)
 
 import kotlin.math.abs
 
diff --git a/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
index 42cf610a..35aa3448 100644
--- a/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3733_minimum_time_to_complete_all_deliveries/Solution.kt
@@ -1,43 +1,49 @@
 package g3701_3800.s3733_minimum_time_to_complete_all_deliveries
 
-// #Medium #Weekly_Contest_474 #2025_11_03_Time_2_ms_(100.00%)_Space_42.94_MB_(100.00%)
+// #Medium #Math #Binary_Search #Weekly_Contest_474
+// #2025_11_05_Time_2_ms_(100.00%)_Space_42.47_MB_(100.00%)
 
 import kotlin.math.max
 
 class Solution {
-    private fun func(mid: Long, d: IntArray, r: IntArray): Boolean {
-        val lcm = r[0].toLong() * r[1] / gcd(r[0].toLong(), r[1].toLong())
-        val a1 = mid / r[0]
-        val a2 = mid / r[1]
-        val a3 = mid / lcm
-        val b = mid - a1 - a2 + a3
-        val o1 = a2 - a3
-        val o2 = a1 - a3
-        val d0 = max(d[0] - o1, 0)
-        val d1 = max(d[1] - o2, 0)
-        return b >= d0 + d1
+    private fun pos(k: Long, n1: Long, n2: Long, p1: Int, p2: Int, lVal: Long): Boolean {
+        val kP1 = k / p1
+        val kP2 = k / p2
+        val kL = k / lVal
+        val s1 = kP2 - kL
+        val s2 = kP1 - kL
+        val sB = k - kP1 - kP2 + kL
+        val w1 = max(0L, n1 - s1)
+        val w2 = max(0L, n2 - s2)
+        return (w1 + w2) <= sB
     }
 
-    private fun gcd(a: Long, b: Long): Long {
+    private fun findGcd(a: Long, b: Long): Long {
         if (b == 0L) {
             return a
         }
-        return gcd(b, a % b)
+        return findGcd(b, a % b)
     }
 
     fun minimumTime(d: IntArray, r: IntArray): Long {
-        var lo: Long = 0
-        var hi = 1e12.toLong()
-        var ans = Long.MAX_VALUE
+        val n1 = d[0].toLong()
+        val n2 = d[1].toLong()
+        val p1 = r[0]
+        val p2 = r[1]
+        val g = findGcd(p1.toLong(), p2.toLong())
+        val l = p1.toLong() * p2 / g
+        var lo = n1 + n2
+        var hi = (n1 + n2) * max(p1, p2)
+        var res = hi
         while (lo <= hi) {
-            val mid = (lo + hi) / 2
-            if (func(mid, d, r)) {
-                ans = mid
+            val mid = lo + (hi - lo) / 2
+            if (pos(mid, n1, n2, p1, p2, l)) {
+                res = mid
                 hi = mid - 1
             } else {
                 lo = mid + 1
             }
         }
-        return ans
+        return res
     }
 }
diff --git a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
index 30a5947c..d8f20297 100644
--- a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
@@ -1,15 +1,16 @@
 package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_greater_than_target
 
-// #Hard #Weekly_Contest_474 #2025_11_03_Time_12_ms_(100.00%)_Space_47.24_MB_(100.00%)
+// #Hard #String #Two_Pointers #Enumeration #Weekly_Contest_474
+// #2025_11_05_Time_4_ms_(100.00%)_Space_46.12_MB_(77.78%)
 
 class Solution {
-    fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
+    private fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
         if (l > r) {
             return String(ans).compareTo(target) > 0
         }
         if (l == r) {
             var left = '#'
-            for (k in 0..25) {
+            for (k in 0 until 26) {
                 if (freq[k] > 0) {
                     left = (k + 'a'.code).toChar()
                 }
@@ -24,16 +25,17 @@ class Solution {
             return false
         }
         if (end) {
-            for (j in 0..25) {
+            for (j in 0 until 26) {
                 if (freq[j] > 1) {
                     freq[j] -= 2
-                    ans[r] = (j + 'a'.code).toChar()
-                    ans[l] = ans[r]
+                    val charJ = (j + 'a'.code).toChar()
+                    ans[l] = charJ
+                    ans[r] = charJ
                     if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
                         return true
                     }
+                    ans[l] = '#'
                     ans[r] = '#'
-                    ans[l] = ans[r]
                     freq[j] += 2
                 }
             }
@@ -41,42 +43,41 @@ class Solution {
         }
         val curr = target[i]
         var next = '1'
-        for (k in target[i].code - 'a'.code + 1..25) {
+        for (k in (curr.code - 'a'.code + 1) until 26) {
             if (freq[k] > 1) {
                 next = (k + 'a'.code).toChar()
                 break
             }
         }
         if (freq[curr.code - 'a'.code] > 1) {
+            ans[l] = curr
             ans[r] = curr
-            ans[l] = ans[r]
             freq[curr.code - 'a'.code] -= 2
-            if (func(i + 1, target, ans, l + 1, r - 1, freq, end)) {
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, false)) { // end = false
                 return true
             }
             freq[curr.code - 'a'.code] += 2
         }
         if (next != '1') {
+            ans[l] = next
             ans[r] = next
-            ans[l] = ans[r]
             freq[next.code - 'a'.code] -= 2
-            if (func(i + 1, target, ans, l + 1, r - 1, freq, true)) {
+            if (func(i + 1, target, ans, l + 1, r - 1, freq, true)) { // end = true
                 return true
             }
-            freq[next.code - 'a'.code] += 2
         }
+        ans[l] = '#'
         ans[r] = '#'
-        ans[l] = ans[r]
         return false
     }
 
     fun lexPalindromicPermutation(s: String, target: String): String {
         val freq = IntArray(26)
-        for (i in 0..<s.length) {
-            freq[s[i].code - 'a'.code]++
+        for (char in s) {
+            freq[char.code - 'a'.code]++
         }
         var oddc = 0
-        for (i in 0..25) {
+        for (i in 0 until 26) {
             if (freq[i] % 2 == 1) {
                 oddc++
             }
@@ -84,8 +85,7 @@ class Solution {
         if (oddc > 1) {
             return ""
         }
-        val ans = CharArray(s.length)
-        ans.fill('#')
+        val ans = CharArray(s.length) { '#' }
         if (func(0, target, ans, 0, s.length - 1, freq, false)) {
             return String(ans)
         }

From 6efca54b93938c3c320027df1ddc7b1e1b8795ad Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Wed, 5 Nov 2025 18:54:25 +0200
Subject: [PATCH 4/5] Added tests

---
 .../Solution.kt                               |   2 +-
 .../SolutionTest.kt                           | 297 ++++++++++++++++++
 2 files changed, 298 insertions(+), 1 deletion(-)

diff --git a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
index d8f20297..2728cdde 100644
--- a/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
+++ b/src/main/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/Solution.kt
@@ -4,7 +4,7 @@ package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_grea
 // #2025_11_05_Time_4_ms_(100.00%)_Space_46.12_MB_(77.78%)
 
 class Solution {
-    private fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
+    internal fun func(i: Int, target: String, ans: CharArray, l: Int, r: Int, freq: IntArray, end: Boolean): Boolean {
         if (l > r) {
             return String(ans).compareTo(target) > 0
         }
diff --git a/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt
index 52f8975b..7d52f275 100644
--- a/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt
+++ b/src/test/kotlin/g3701_3800/s3734_lexicographically_smallest_palindromic_permutation_greater_than_target/SolutionTest.kt
@@ -2,6 +2,13 @@ package g3701_3800.s3734_lexicographically_smallest_palindromic_permutation_grea
 
 import org.hamcrest.CoreMatchers.equalTo
 import org.hamcrest.MatcherAssert.assertThat
+import org.hamcrest.Matchers.allOf
+import org.hamcrest.Matchers.anyOf
+import org.hamcrest.Matchers.containsString
+import org.hamcrest.Matchers.greaterThanOrEqualTo
+import org.hamcrest.Matchers.hasLength
+import org.hamcrest.Matchers.not
+import org.hamcrest.Matchers.nullValue
 import org.junit.jupiter.api.Test
 
 internal class SolutionTest {
@@ -36,4 +43,294 @@ internal class SolutionTest {
             equalTo<String>("aca"),
         )
     }
+
+    @Test
+    fun lexPalindromicPermutation5() {
+        // Branch: oddc > 1
+        val result = Solution().lexPalindromicPermutation("abc", "a")
+        assertThat<String>(result, equalTo<String>(""))
+    }
+
+    @Test
+    fun lexPalindromicPermutation6() {
+        // Branch: oddc = 1
+        val result = Solution().lexPalindromicPermutation("aab", "a")
+        assertThat<String>(
+            result,
+            allOf<String>(not<String>(equalTo<String>("")), hasLength(3)),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation7() {
+        // Branch: oddc = 0
+        val result = Solution().lexPalindromicPermutation("aabb", "ab")
+        assertThat<String>(result, not<String>(equalTo<String>("")))
+    }
+
+    @Test
+    fun lexPalindromicPermutation8() {
+        // Branch: func returns false
+        val result = Solution().lexPalindromicPermutation("abc", "xyz")
+        assertThat<String>(result, equalTo<String>(""))
+    }
+
+    @Test
+    fun lexPalindromicPermutation9() {
+        // Edge case: length = 1
+        val result = Solution().lexPalindromicPermutation("a", "a")
+        assertThat<String>(result, equalTo<String>(""))
+    }
+
+    @Test
+    fun lexPalindromicPermutation10() {
+        // Branch: l > r and comparison result > 0
+        val target = "a"
+        val freq = IntArray(26)
+        val ans = charArrayOf('b', 'b')
+
+        val result = Solution().func(0, target, ans, 1, 0, freq, false)
+        assertThat<Boolean>(result, equalTo<Boolean>(true))
+    }
+
+    @Test
+    fun lexPalindromicPermutation11() {
+        // Branch: l > r and comparison result <= 0
+        val target = "z"
+        val freq = IntArray(26)
+        val ans = charArrayOf('a', 'a')
+
+        val result = Solution().func(0, target, ans, 1, 0, freq, false)
+        assertThat<Boolean>(result, equalTo<Boolean>(false))
+    }
+
+    @Test
+    fun lexPalindromicPermutation12() {
+        // Branch: l == r with available character
+        val target = "a"
+        val freq = IntArray(26)
+        // 'a' has frequency 1
+        freq[0] = 1
+        val ans = CharArray(1)
+
+        val result = Solution().func(0, target, ans, 0, 0, freq, false)
+        assertThat<Boolean>(result, equalTo<Boolean>(false))
+        assertThat<Char>(ans[0], equalTo<Char>('#'))
+    }
+
+    @Test
+    fun lexPalindromicPermutation13() {
+        // Branch: end = true, finds char with freq > 1
+        val target = "ab"
+        val freq = IntArray(26)
+        // 'a' can form a pair
+        freq[0] = 2
+        freq[1] = 0
+        val ans = CharArray(2)
+
+        val result = Solution().func(1, target, ans, 0, 1, freq, true)
+        assertThat<Boolean>(
+            result,
+            anyOf<Boolean>(equalTo<Boolean>(true), equalTo<Boolean>(false)),
+        )
+        // Frequency restored
+        assertThat<Int>(freq[0], equalTo<Int>(2))
+    }
+
+    @Test
+    fun lexPalindromicPermutation14() {
+        // Branch: end = true, no char has freq > 1
+        val target = "ab"
+        val freq = IntArray(26)
+        freq[0] = 1
+        freq[1] = 1
+        val ans = CharArray(2)
+
+        val result = Solution().func(1, target, ans, 0, 1, freq, true)
+        assertThat<Boolean>(result, equalTo<Boolean>(false))
+    }
+
+    @Test
+    fun lexPalindromicPermutation15() {
+        // Branch: end = true, tries different pairs
+        val target = "abc"
+        val freq = IntArray(26)
+        freq[0] = 2
+        freq[1] = 2
+        freq[2] = 2
+        val ans = CharArray(3)
+
+        Solution().func(1, target, ans, 0, 2, freq, true)
+        assertThat<Int>(freq[0], equalTo<Int>(0))
+        assertThat<Int>(freq[1], equalTo<Int>(2))
+        assertThat<Int>(freq[2], equalTo<Int>(1))
+    }
+
+    @Test
+    fun lexPalindromicPermutation16() {
+        // Branch: end = false, curr has freq > 1
+        val target = "a"
+        val freq = IntArray(26)
+        freq[0] = 2
+        val ans = CharArray(2)
+
+        Solution().func(0, target, ans, 0, 1, freq, false)
+        assertThat<Int>(freq[0], equalTo<Int>(0))
+    }
+
+    @Test
+    fun lexPalindromicPermutation17() {
+        // Branch: end = false, curr has freq <= 1
+        val target = "a"
+        val freq = IntArray(26)
+        freq[0] = 0
+        val ans = CharArray(2)
+
+        Solution().func(0, target, ans, 0, 1, freq, false)
+        assertThat<Int>(freq[0], equalTo<Int>(0))
+    }
+
+    @Test
+    fun lexPalindromicPermutation18() {
+        // Branch: end = false, finds next char with freq > 1
+        val target = "a"
+        val freq = IntArray(26)
+        freq[0] = 0
+        freq[1] = 2
+        val ans = CharArray(2)
+
+        Solution().func(0, target, ans, 0, 1, freq, false)
+        assertThat<Int>(freq[0], equalTo<Int>(0))
+        assertThat<Int>(freq[1], equalTo<Int>(0))
+    }
+
+    @Test
+    fun lexPalindromicPermutation19() {
+        // Branch: end = false, no next char with freq > 1
+        val target = "z"
+        val freq = IntArray(26)
+        freq[25] = 1
+        val ans = CharArray(2)
+
+        val result = Solution().func(0, target, ans, 0, 1, freq, false)
+        assertThat<Boolean>(result, equalTo<Boolean>(false))
+    }
+
+    @Test
+    fun lexPalindromicPermutation20() {
+        // Branch: end = false transitions to end = true
+        val target = "ab"
+        val freq = IntArray(26)
+        freq[0] = 2
+        freq[1] = 2
+        val ans = CharArray(2)
+
+        Solution().func(0, target, ans, 0, 1, freq, false)
+
+        assertThat<Int>(freq[0], equalTo<Int>(2))
+        assertThat<Int>(freq[1], equalTo<Int>(0))
+    }
+
+    @Test
+    fun lexPalindromicPermutation21() {
+        // Verify result is always a palindrome
+        val result = Solution().lexPalindromicPermutation("aabbcc", "abc")
+        if (!result.isEmpty()) {
+            val reversed = StringBuilder(result).reverse().toString()
+            assertThat<String>(result, equalTo<String>(reversed))
+        }
+    }
+
+    @Test
+    fun lexPalindromicPermutation22() {
+        // Verify character frequencies are preserved
+        val input = "aabbcc"
+        val result = Solution().lexPalindromicPermutation(input, "abc")
+
+        if (!result.isEmpty()) {
+            val inputFreq = IntArray(26)
+            val resultFreq = IntArray(26)
+
+            for (c in input.toCharArray()) {
+                inputFreq[c.code - 'a'.code]++
+            }
+            for (c in result.toCharArray()) {
+                resultFreq[c.code - 'a'.code]++
+            }
+
+            assertThat<IntArray>(resultFreq, equalTo<IntArray>(inputFreq))
+        }
+    }
+
+    @Test
+    fun lexPalindromicPermutation23() {
+        // Result length should match input length
+        val input = "aabbccdd"
+        val result = Solution().lexPalindromicPermutation(input, "abcd")
+
+        if (!result.isEmpty()) {
+            assertThat<Int>(result.length, equalTo<Int>(input.length))
+        }
+    }
+
+    @Test
+    fun lexPalindromicPermutation24() {
+        // Result should be >= target in lexicographical order
+        val result = Solution().lexPalindromicPermutation("aabbcc", "abc")
+
+        if (!result.isEmpty()) {
+            assertThat<Int>(result.compareTo("abc"), greaterThanOrEqualTo<Int>(0))
+        }
+    }
+
+    @Test
+    fun lexPalindromicPermutation25() {
+        // Complex scenario with multiple characters
+        val result = Solution().lexPalindromicPermutation("aabbccdd", "abcd")
+
+        assertThat<String>(
+            result,
+            anyOf<String>(
+                equalTo<String>(""),
+                allOf<String>(
+                    hasLength(8),
+                    containsString("a"),
+                    containsString("b"),
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation26() {
+        // Edge case: empty string (if applicable)
+        val result = Solution().lexPalindromicPermutation("", "")
+        assertThat<String>(
+            result,
+            anyOf<String>(equalTo<String>(""), not<Any>(nullValue())),
+        )
+    }
+
+    @Test
+    fun lexPalindromicPermutation27() {
+        // Verify frequency array is restored after recursion
+        val target = "aabb"
+        val freq = IntArray(26)
+        val freqCopy: IntArray = freq.clone()
+
+        val ans = CharArray(4)
+        Solution().func(0, target, ans, 0, 3, freq, false)
+
+        assertThat<IntArray>(freq, equalTo<IntArray>(freqCopy))
+    }
+
+    @Test
+    fun lexPalindromicPermutation28() {
+        // Verify char array is properly initialized
+        val result = Solution().lexPalindromicPermutation("aa", "a")
+
+        if (!result.isEmpty()) {
+            assertThat<String>(result, not<String>(containsString("#")))
+        }
+    }
 }

From 4f0d620d23491020444355d65152451d5bd0d57a Mon Sep 17 00:00:00 2001
From: Valentyn Kolesnikov <javadev75@gmail.com>
Date: Wed, 5 Nov 2025 18:59:04 +0200
Subject: [PATCH 5/5] Fixed compile

---
 .../s3731_find_missing_elements/SolutionTest.kt      | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt b/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
index 404be6d3..1053f307 100644
--- a/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
+++ b/src/test/kotlin/g3701_3800/s3731_find_missing_elements/SolutionTest.kt
@@ -7,25 +7,25 @@ import org.junit.jupiter.api.Test
 internal class SolutionTest {
     @Test
     fun findMissingElements() {
-        assertThat<MutableList<Int>>(
+        assertThat<List<Int>>(
             Solution().findMissingElements(intArrayOf(1, 4, 2, 5)),
-            equalTo<MutableList<Int>>(mutableListOf<Int>(3)),
+            equalTo<List<Int>>(mutableListOf<Int>(3)),
         )
     }
 
     @Test
     fun findMissingElements2() {
-        assertThat<MutableList<Int>>(
+        assertThat<List<Int>>(
             Solution().findMissingElements(intArrayOf(7, 8, 6, 9)),
-            equalTo<MutableList<out Any>>(mutableListOf<Any>()),
+            equalTo<List<Int>>(mutableListOf<Int>()),
         )
     }
 
     @Test
     fun findMissingElements3() {
-        assertThat<MutableList<Int>>(
+        assertThat<List<Int>>(
             Solution().findMissingElements(intArrayOf(5, 1)),
-            equalTo<MutableList<Int>>(mutableListOf<Int>(2, 3, 4)),
+            equalTo<List<Int>>(mutableListOf<Int>(2, 3, 4)),
         )
     }
 }