diff --git a/src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt b/src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt
index 2ac8e7d3a..6c9a3355e 100644
--- a/src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt
+++ b/src/main/kotlin/g3401_3500/s3462_maximum_sum_with_at_most_k_elements/Solution.kt
@@ -1,6 +1,6 @@
 package g3401_3500.s3462_maximum_sum_with_at_most_k_elements
 
-// #Medium #Array #Sorting #Greedy #Matrix #Heap_(Priority_Queue)
+// #Medium #Array #Sorting #Greedy #Matrix #Heap_Priority_Queue
 // #2025_02_25_Time_139_ms_(100.00%)_Space_88.84_MB_(79.31%)
 
 class Solution {
diff --git a/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/Solution.kt b/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/Solution.kt
new file mode 100644
index 000000000..22902fa10
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/Solution.kt
@@ -0,0 +1,20 @@
+package g3401_3500.s3467_transform_array_by_parity
+
+// #Easy #Array #Sorting #Counting #2025_03_06_Time_1_ms_(100.00%)_Space_45.41_MB_(5.41%)
+
+class Solution {
+    fun transformArray(nums: IntArray): IntArray {
+        val size = nums.size
+        val ans = IntArray(size)
+        var countEven = 0
+        for (i in nums.indices) {
+            if (nums[i] and 1 == 0) {
+                countEven++
+            }
+        }
+        for (i in countEven until size) {
+            ans[i] = 1
+        }
+        return ans
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/readme.md b/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/readme.md
new file mode 100644
index 000000000..7583bc57d
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3467_transform_array_by_parity/readme.md
@@ -0,0 +1,38 @@
+3467\. Transform Array by Parity
+
+Easy
+
+You are given an integer array `nums`. Transform `nums` by performing the following operations in the **exact** order specified:
+
+1.  Replace each even number with 0.
+2.  Replace each odd numbers with 1.
+3.  Sort the modified array in **non-decreasing** order.
+
+Return the resulting array after performing these operations.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,1]
+
+**Output:** [0,0,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (3 and 1) with 1. Now, `nums = [0, 1, 0, 1]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1]`.
+
+**Example 2:**
+
+**Input:** nums = [1,5,1,4,2]
+
+**Output:** [0,0,1,1,1]
+
+**Explanation:**
+
+*   Replace the even numbers (4 and 2) with 0 and the odd numbers (1, 5 and 1) with 1. Now, `nums = [1, 1, 1, 0, 0]`.
+*   After sorting `nums` in non-descending order, `nums = [0, 0, 1, 1, 1]`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `1 <= nums[i] <= 1000`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/Solution.kt b/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/Solution.kt
new file mode 100644
index 000000000..aa67822f6
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/Solution.kt
@@ -0,0 +1,21 @@
+package g3401_3500.s3468_find_the_number_of_copy_arrays
+
+// #Medium #Array #Math #2025_03_06_Time_3_ms_(100.00%)_Space_111.85_MB_(22.73%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun countArrays(original: IntArray, bounds: Array<IntArray>): Int {
+        var low = bounds[0][0]
+        var high = bounds[0][1]
+        var ans = high - low + 1
+        for (i in 1..<original.size) {
+            val diff = original[i] - original[i - 1]
+            low = max((low + diff), bounds[i][0])
+            high = min((high + diff), bounds[i][1])
+            ans = min(ans, (high - low + 1)).toInt()
+        }
+        return max(ans, 0)
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md b/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md
new file mode 100644
index 000000000..7ec22ab01
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/readme.md
@@ -0,0 +1,58 @@
+3468\. Find the Number of Copy Arrays
+
+Medium
+
+You are given an array `original` of length `n` and a 2D array `bounds` of length `n x 2`, where <code>bounds[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>.
+
+You need to find the number of **possible** arrays `copy` of length `n` such that:
+
+1.  `(copy[i] - copy[i - 1]) == (original[i] - original[i - 1])` for `1 <= i <= n - 1`.
+2.  <code>u<sub>i</sub> <= copy[i] <= v<sub>i</sub></code> for `0 <= i <= n - 1`.
+
+Return the number of such arrays.
+
+**Example 1:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+
+**Example 2:**
+
+**Input:** original = [1,2,3,4], bounds = [[1,10],[2,9],[3,8],[4,7]]
+
+**Output:** 4
+
+**Explanation:**
+
+The possible arrays are:
+
+*   `[1, 2, 3, 4]`
+*   `[2, 3, 4, 5]`
+*   `[3, 4, 5, 6]`
+*   `[4, 5, 6, 7]`
+
+**Example 3:**
+
+**Input:** original = [1,2,1,2], bounds = [[1,1],[2,3],[3,3],[2,3]]
+
+**Output:** 0
+
+**Explanation:**
+
+No array is possible.
+
+**Constraints:**
+
+*   <code>2 <= n == original.length <= 10<sup>5</sup></code>
+*   <code>1 <= original[i] <= 10<sup>9</sup></code>
+*   `bounds.length == n`
+*   `bounds[i].length == 2`
+*   <code>1 <= bounds[i][0] <= bounds[i][1] <= 10<sup>9</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt b/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt
new file mode 100644
index 000000000..58e539bbe
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/Solution.kt
@@ -0,0 +1,41 @@
+package g3401_3500.s3469_find_minimum_cost_to_remove_array_elements
+
+// #Medium #Array #Dynamic_Programming #2025_03_06_Time_27_ms_(100.00%)_Space_49.13_MB_(93.33%)
+
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun minCost(nums: IntArray): Int {
+        var nums = nums
+        var n = nums.size
+        if (n % 2 == 0) {
+            nums = nums.copyOf(++n)
+        }
+        val dp = IntArray(n)
+        var j = 1
+        while (j < n - 1) {
+            var cost1: Int = INF
+            var cost2: Int = INF
+            val max = max(nums[j], nums[j + 1])
+            for (i in 0..<j) {
+                cost1 =
+                    min(cost1, dp[i] + max(nums[i], nums[j + 1]))
+                cost2 = min(cost2, dp[i] + max(nums[i], nums[j]))
+                dp[i] += max
+            }
+            dp[j] = cost1
+            dp[j + 1] = cost2
+            j += 2
+        }
+        var result: Int = INF
+        for (i in 0..<n) {
+            result = min(result, dp[i] + nums[i])
+        }
+        return result
+    }
+
+    companion object {
+        private const val INF = 1e9.toInt()
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/readme.md b/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/readme.md
new file mode 100644
index 000000000..9f1be574e
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/readme.md
@@ -0,0 +1,45 @@
+3469\. Find Minimum Cost to Remove Array Elements
+
+Medium
+
+You are given an integer array `nums`. Your task is to remove **all elements** from the array by performing one of the following operations at each step until `nums` is empty:
+
+*   Choose any two elements from the first three elements of `nums` and remove them. The cost of this operation is the **maximum** of the two elements removed.
+*   If fewer than three elements remain in `nums`, remove all the remaining elements in a single operation. The cost of this operation is the **maximum** of the remaining elements.
+
+Return the **minimum** cost required to remove all the elements.
+
+**Example 1:**
+
+**Input:** nums = [6,2,8,4]
+
+**Output:** 12
+
+**Explanation:**
+
+Initially, `nums = [6, 2, 8, 4]`.
+
+*   In the first operation, remove `nums[0] = 6` and `nums[2] = 8` with a cost of `max(6, 8) = 8`. Now, `nums = [2, 4]`.
+*   In the second operation, remove the remaining elements with a cost of `max(2, 4) = 4`.
+
+The cost to remove all elements is `8 + 4 = 12`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 12.
+
+**Example 2:**
+
+**Input:** nums = [2,1,3,3]
+
+**Output:** 5
+
+**Explanation:**
+
+Initially, `nums = [2, 1, 3, 3]`.
+
+*   In the first operation, remove `nums[0] = 2` and `nums[1] = 1` with a cost of `max(2, 1) = 2`. Now, `nums = [3, 3]`.
+*   In the second operation remove the remaining elements with a cost of `max(3, 3) = 3`.
+
+The cost to remove all elements is `2 + 3 = 5`. This is the minimum cost to remove all elements in `nums`. Hence, the output is 5.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>6</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3470_permutations_iv/Solution.kt b/src/main/kotlin/g3401_3500/s3470_permutations_iv/Solution.kt
new file mode 100644
index 000000000..80abd4507
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3470_permutations_iv/Solution.kt
@@ -0,0 +1,75 @@
+package g3401_3500.s3470_permutations_iv
+
+// #Hard #Array #Math #Enumeration #Combinatorics
+// #2025_03_06_Time_4_ms_(96.77%)_Space_45.40_MB_(9.68%)
+
+class Solution {
+    private val maxFac = 100_000_000L
+
+    fun permute(n: Int, k: Long): IntArray {
+        var res = IntArray(n)
+        var k = k - 1
+        val fac = LongArray(n / 2 + 1)
+        fac[0] = 1
+        for (i in 1..n / 2) {
+            fac[i] = fac[i - 1] * i
+            if (fac[i] >= maxFac) {
+                fac[i] = maxFac
+            }
+        }
+        var evenNum = n / 2
+        var oddNum = n - evenNum
+        var evens = mutableListOf<Int>()
+        var odds = mutableListOf<Int>()
+        for (i in 1..n) {
+            if (i % 2 == 0) {
+                evens.add(i)
+            } else {
+                odds.add(i)
+            }
+        }
+        for (i in 0..<n) {
+            if (i == 0) {
+                if (n % 2 == 0) {
+                    val trailCombs = fac[evenNum] * fac[evenNum - 1]
+                    val leadIdx = (k / trailCombs).toInt()
+                    if (leadIdx + 1 > n) return IntArray(0)
+                    res[i] = leadIdx + 1
+                    if ((leadIdx + 1) % 2 == 0) {
+                        evens.remove(leadIdx + 1)
+                    } else {
+                        odds.remove(leadIdx + 1)
+                    }
+                    k = k % trailCombs
+                } else {
+                    val trailCombs = fac[oddNum - 1] * fac[evenNum]
+                    val leadIdx = (k / trailCombs).toInt()
+                    if (leadIdx >= odds.size) return IntArray(0)
+                    val num = odds.removeAt(leadIdx)
+                    res[i] = num
+                    k = k % trailCombs
+                }
+            } else {
+                if (res[i - 1] % 2 == 0) {
+                    val trailCombs = fac[evenNum] * fac[oddNum - 1]
+                    val leadIdx = (k / trailCombs).toInt()
+                    val num = odds.removeAt(leadIdx)
+                    res[i] = num
+                    k = k % trailCombs
+                } else {
+                    val trailCombs = fac[evenNum - 1] * fac[oddNum ]
+                    val leadIdx = (k / trailCombs).toInt()
+                    val num = evens.removeAt(leadIdx)
+                    res[i] = num
+                    k = k % trailCombs
+                }
+            }
+            if (res[i] % 2 == 0) {
+                evenNum--
+            } else {
+                oddNum--
+            }
+        }
+        return res
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3470_permutations_iv/readme.md b/src/main/kotlin/g3401_3500/s3470_permutations_iv/readme.md
new file mode 100644
index 000000000..6ab843e88
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3470_permutations_iv/readme.md
@@ -0,0 +1,63 @@
+3470\. Permutations IV
+
+Hard
+
+Given two integers, `n` and `k`, an **alternating permutation** is a permutation of the first `n` positive integers such that no **two** adjacent elements are both odd or both even.
+
+Return the **k-th** **alternating permutation** sorted in _lexicographical order_. If there are fewer than `k` valid **alternating permutations**, return an empty list.
+
+**Example 1:**
+
+**Input:** n = 4, k = 6
+
+**Output:** [3,4,1,2]
+
+**Explanation:**
+
+The lexicographically-sorted alternating permutations of `[1, 2, 3, 4]` are:
+
+1.  `[1, 2, 3, 4]`
+2.  `[1, 4, 3, 2]`
+3.  `[2, 1, 4, 3]`
+4.  `[2, 3, 4, 1]`
+5.  `[3, 2, 1, 4]`
+6.  `[3, 4, 1, 2]` ← 6th permutation
+7.  `[4, 1, 2, 3]`
+8.  `[4, 3, 2, 1]`
+
+Since `k = 6`, we return `[3, 4, 1, 2]`.
+
+**Example 2:**
+
+**Input:** n = 3, k = 2
+
+**Output:** [3,2,1]
+
+**Explanation:**
+
+The lexicographically-sorted alternating permutations of `[1, 2, 3]` are:
+
+1.  `[1, 2, 3]`
+2.  `[3, 2, 1]` ← 2nd permutation
+
+Since `k = 2`, we return `[3, 2, 1]`.
+
+**Example 3:**
+
+**Input:** n = 2, k = 3
+
+**Output:** []
+
+**Explanation:**
+
+The lexicographically-sorted alternating permutations of `[1, 2]` are:
+
+1.  `[1, 2]`
+2.  `[2, 1]`
+
+There are only 2 alternating permutations, but `k = 3`, which is out of range. Thus, we return an empty list `[]`.
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   <code>1 <= k <= 10<sup>15</sup></code>
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/Solution.kt b/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/Solution.kt
new file mode 100644
index 000000000..76fb915a2
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/Solution.kt
@@ -0,0 +1,24 @@
+package g3401_3500.s3471_find_the_largest_almost_missing_integer
+
+// #Easy #Array #Hash_Table #2025_03_06_Time_6_ms_(86.49%)_Space_46.27_MB_(5.41%)
+
+class Solution {
+    fun largestInteger(nums: IntArray, k: Int): Int {
+        val freq = IntArray(51)
+        for (i in 0..nums.size - k) {
+            val set: MutableSet<Int> = HashSet<Int>()
+            for (j in i..<i + k) {
+                set.add(nums[j])
+            }
+            for (key in set) {
+                freq[key]++
+            }
+        }
+        for (i in 50 downTo 0) {
+            if (freq[i] == 1) {
+                return i
+            }
+        }
+        return -1
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/readme.md b/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/readme.md
new file mode 100644
index 000000000..eab24033c
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/readme.md
@@ -0,0 +1,59 @@
+3471\. Find the Largest Almost Missing Integer
+
+Easy
+
+You are given an integer array `nums` and an integer `k`.
+
+An integer `x` is **almost missing** from `nums` if `x` appears in _exactly_ one subarray of size `k` within `nums`.
+
+Return the **largest** **almost missing** integer from `nums`. If no such integer exists, return `-1`.
+
+A **subarray** is a contiguous sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** nums = [3,9,2,1,7], k = 3
+
+**Output:** 7
+
+**Explanation:**
+
+*   1 appears in 2 subarrays of size 3: `[9, 2, 1]` and `[2, 1, 7]`.
+*   2 appears in 3 subarrays of size 3: `[3, 9, 2]`, `[9, 2, 1]`, `[2, 1, 7]`.
+*   3 appears in 1 subarray of size 3: `[3, 9, 2]`.
+*   7 appears in 1 subarray of size 3: `[2, 1, 7]`.
+*   9 appears in 2 subarrays of size 3: `[3, 9, 2]`, and `[9, 2, 1]`.
+
+We return 7 since it is the largest integer that appears in exactly one subarray of size `k`.
+
+**Example 2:**
+
+**Input:** nums = [3,9,7,2,1,7], k = 4
+
+**Output:** 3
+
+**Explanation:**
+
+*   1 appears in 2 subarrays of size 4: `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   2 appears in 3 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   3 appears in 1 subarray of size 4: `[3, 9, 7, 2]`.
+*   7 appears in 3 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`, `[7, 2, 1, 7]`.
+*   9 appears in 2 subarrays of size 4: `[3, 9, 7, 2]`, `[9, 7, 2, 1]`.
+
+We return 3 since it is the largest and only integer that appears in exactly one subarray of size `k`.
+
+**Example 3:**
+
+**Input:** nums = [0,0], k = 1
+
+**Output:** \-1
+
+**Explanation:**
+
+There is no integer that appears in only one subarray of size 1.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 50`
+*   `0 <= nums[i] <= 50`
+*   `1 <= k <= nums.length`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/Solution.kt b/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/Solution.kt
new file mode 100644
index 000000000..cdd131ecd
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/Solution.kt
@@ -0,0 +1,42 @@
+package g3401_3500.s3472_longest_palindromic_subsequence_after_at_most_k_operations
+
+// #Medium #String #Dynamic_Programming #2025_03_06_Time_142_ms_(55.00%)_Space_116.30_MB_(10.00%)
+
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+
+class Solution {
+    fun longestPalindromicSubsequence(s: String, k: Int): Int {
+        val n = s.length
+        val arr = Array<IntArray>(26) { IntArray(26) }
+        for (i in 0..25) {
+            for (j in 0..25) {
+                arr[i][j] = min(abs(i - j), (26 - abs(i - j)))
+            }
+        }
+        val dp = Array<Array<IntArray>>(n) { Array<IntArray>(n) { IntArray(k + 1) } }
+        for (i in 0..<n) {
+            for (it in 0..k) {
+                dp[i][i][it] = 1
+            }
+        }
+        for (length in 2..n) {
+            for (i in 0..n - length) {
+                val j = i + length - 1
+                for (it in 0..k) {
+                    if (s[i] == s[j]) {
+                        dp[i][j][it] = 2 + dp[i + 1][j - 1][it]
+                    } else {
+                        val num1 = dp[i + 1][j][it]
+                        val num2 = dp[i][j - 1][it]
+                        val c = arr[s[i].code - 'a'.code][s[j].code - 'a'.code]
+                        val num3 = if (it >= c) 2 + dp[i + 1][j - 1][it - c] else 0
+                        dp[i][j][it] = max(max(num1, num2), num3)
+                    }
+                }
+            }
+        }
+        return dp[0][n - 1][k]
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/readme.md b/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/readme.md
new file mode 100644
index 000000000..c37fe73bb
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/readme.md
@@ -0,0 +1,42 @@
+3472\. Longest Palindromic Subsequence After at Most K Operations
+
+Medium
+
+You are given a string `s` and an integer `k`.
+
+In one operation, you can replace the character at any position with the next or previous letter in the alphabet (wrapping around so that `'a'` is after `'z'`). For example, replacing `'a'` with the next letter results in `'b'`, and replacing `'a'` with the previous letter results in `'z'`. Similarly, replacing `'z'` with the next letter results in `'a'`, and replacing `'z'` with the previous letter results in `'y'`.
+
+Return the length of the **longest palindromic subsequence** of `s` that can be obtained after performing **at most** `k` operations.
+
+**Example 1:**
+
+**Input:** s = "abced", k = 2
+
+**Output:** 3
+
+**Explanation:**
+
+*   Replace `s[1]` with the next letter, and `s` becomes `"acced"`.
+*   Replace `s[4]` with the previous letter, and `s` becomes `"accec"`.
+
+The subsequence `"ccc"` forms a palindrome of length 3, which is the maximum.
+
+**Example 2:**
+
+**Input:** s = "aaazzz", k = 4
+
+**Output:** 6
+
+**Explanation:**
+
+*   Replace `s[0]` with the previous letter, and `s` becomes `"zaazzz"`.
+*   Replace `s[4]` with the next letter, and `s` becomes `"zaazaz"`.
+*   Replace `s[3]` with the next letter, and `s` becomes `"zaaaaz"`.
+
+The entire string forms a palindrome of length 6.
+
+**Constraints:**
+
+*   `1 <= s.length <= 200`
+*   `1 <= k <= 200`
+*   `s` consists of only lowercase English letters.
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/Solution.kt b/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/Solution.kt
new file mode 100644
index 000000000..ddb5fb49d
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/Solution.kt
@@ -0,0 +1,45 @@
+package g3401_3500.s3473_sum_of_k_subarrays_with_length_at_least_m
+
+// #Medium #Array #Dynamic_Programming #Prefix_Sum
+// #2025_03_06_Time_227_ms_(24.47%)_Space_99.61_MB_(48.94%)
+
+import kotlin.math.max
+
+class Solution {
+    fun maxSum(nums: IntArray, k: Int, m: Int): Int {
+        val n = nums.size
+        // Calculate prefix sums
+        val prefixSum = IntArray(n + 1)
+        for (i in 0..<n) {
+            prefixSum[i + 1] = prefixSum[i] + nums[i]
+        }
+        // using elements from nums[0...i-1]
+        val dp = Array<IntArray>(n + 1) { IntArray(k + 1) }
+        // Initialize dp array
+        for (j in 1..k) {
+            for (i in 0..n) {
+                dp[i][j] = Int.Companion.MIN_VALUE / 2
+            }
+        }
+        // Fill dp array
+        for (j in 1..k) {
+            val maxPrev = IntArray(n + 1)
+            for (i in 0..<n + 1) {
+                maxPrev[i] =
+                    if (i == 0) {
+                        dp[0][j - 1] - prefixSum[0]
+                    } else {
+                        max(maxPrev[i - 1], dp[i][j - 1] - prefixSum[i])
+                    }
+            }
+            for (i in m..n) {
+                // Option 1: Don't include the current element in any new subarray
+                dp[i][j] = dp[i - 1][j]
+                // Option 2: Form a new subarray ending at position i
+                // Find the best starting position for the subarray
+                dp[i][j] = max(dp[i][j], prefixSum[i] + maxPrev[i - m])
+            }
+        }
+        return dp[n][k]
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/readme.md b/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/readme.md
new file mode 100644
index 000000000..1ea11fbbf
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/readme.md
@@ -0,0 +1,39 @@
+3473\. Sum of K Subarrays With Length at Least M
+
+Medium
+
+You are given an integer array `nums` and two integers, `k` and `m`.
+
+Return the **maximum** sum of `k` non-overlapping subarrays of `nums`, where each subarray has a length of **at least** `m`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,-1,3,3,4], k = 2, m = 2
+
+**Output:** 13
+
+**Explanation:**
+
+The optimal choice is:
+
+*   Subarray `nums[3..5]` with sum `3 + 3 + 4 = 10` (length is `3 >= m`).
+*   Subarray `nums[0..1]` with sum `1 + 2 = 3` (length is `2 >= m`).
+
+The total sum is `10 + 3 = 13`.
+
+**Example 2:**
+
+**Input:** nums = [-10,3,-1,-2], k = 4, m = 1
+
+**Output:** \-10
+
+**Explanation:**
+
+The optimal choice is choosing each element as a subarray. The output is `(-10) + 3 + (-1) + (-2) = -10`.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 2000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `1 <= k <= floor(nums.length / m)`
+*   `1 <= m <= 3`
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/Solution.kt b/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/Solution.kt
new file mode 100644
index 000000000..38197d032
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/Solution.kt
@@ -0,0 +1,64 @@
+package g3401_3500.s3474_lexicographically_smallest_generated_string
+
+// #Hard #String #Greedy #String_Matching #2025_03_06_Time_30_ms_(100.00%)_Space_46.67_MB_(20.00%)
+
+class Solution {
+    fun generateString(str1: String, str2: String): String {
+        val n = str1.length
+        val m = str2.length
+        val l = n + m - 1
+        val word = arrayOfNulls<Char>(l)
+        for (i in 0..<n) {
+            if (str1[i] == 'T') {
+                for (j in 0..<m) {
+                    val pos = i + j
+                    if (word[pos] != null && word[pos] != str2[j]) {
+                        return ""
+                    }
+                    word[pos] = str2[j]
+                }
+            }
+        }
+        val free = BooleanArray(l)
+        for (i in 0..<l) {
+            if (word[i] == null) {
+                word[i] = 'a'
+                free[i] = true
+            }
+        }
+        if (n == 0) {
+            return "a".repeat(l)
+        }
+        for (i in 0..<n) {
+            if (str1[i] == 'F' && intervalEquals(word, str2, i, m)) {
+                var fixed = false
+                for (j in m - 1 downTo 0) {
+                    val pos = i + j
+                    if (free[pos]) {
+                        word[pos] = 'b'
+                        free[pos] = false
+                        fixed = true
+                        break
+                    }
+                }
+                if (!fixed) {
+                    return ""
+                }
+            }
+        }
+        val sb = StringBuilder()
+        for (c in word) {
+            sb.append(c)
+        }
+        return sb.toString()
+    }
+
+    private fun intervalEquals(word: Array<Char?>, str2: String, i: Int, m: Int): Boolean {
+        for (j in 0..<m) {
+            if (word[i + j] == null || word[i + j] != str2[j]) {
+                return false
+            }
+        }
+        return true
+    }
+}
diff --git a/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/readme.md b/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/readme.md
new file mode 100644
index 000000000..6eae25336
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/readme.md
@@ -0,0 +1,56 @@
+3474\. Lexicographically Smallest Generated String
+
+Hard
+
+You are given two strings, `str1` and `str2`, of lengths `n` and `m`, respectively.
+
+A string `word` of length `n + m - 1` is defined to be **generated** by `str1` and `str2` if it satisfies the following conditions for **each** index `0 <= i <= n - 1`:
+
+*   If `str1[i] == 'T'`, the **substring** of `word` with size `m` starting at index `i` is **equal** to `str2`, i.e., `word[i..(i + m - 1)] == str2`.
+*   If `str1[i] == 'F'`, the **substring** of `word` with size `m` starting at index `i` is **not equal** to `str2`, i.e., `word[i..(i + m - 1)] != str2`.
+
+Return the **lexicographically smallest** possible string that can be **generated** by `str1` and `str2`. If no string can be generated, return an empty string `""`.
+
+**Example 1:**
+
+**Input:** str1 = "TFTF", str2 = "ab"
+
+**Output:** "ababa"
+
+**Explanation:**
+
+#### The table below represents the string `"ababa"`
+
+| Index | T/F | Substring of length `m` |
+|-------|-----|-------------------------|
+| 0     | 'T' | "ab"                    |
+| 1     | 'F' | "ba"                    |
+| 2     | 'T' | "ab"                    |
+| 3     | 'F' | "ba"                    |
+
+The strings `"ababa"` and `"ababb"` can be generated by `str1` and `str2`.
+
+Return `"ababa"` since it is the lexicographically smaller string.
+
+**Example 2:**
+
+**Input:** str1 = "TFTF", str2 = "abc"
+
+**Output:** ""
+
+**Explanation:**
+
+No string that satisfies the conditions can be generated.
+
+**Example 3:**
+
+**Input:** str1 = "F", str2 = "d"
+
+**Output:** "a"
+
+**Constraints:**
+
+*   <code>1 <= n == str1.length <= 10<sup>4</sup></code>
+*   `1 <= m == str2.length <= 500`
+*   `str1` consists only of `'T'` or `'F'`.
+*   `str2` consists only of lowercase English characters.
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/readme.md b/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/readme.md
new file mode 100644
index 000000000..34cf7c2a0
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/readme.md
@@ -0,0 +1,98 @@
+3475\. DNA Pattern Recognition
+
+Medium
+
+Table: `Samples`
+
+    +----------------+---------+
+    | Column Name    | Type    |
+    +----------------+---------+
+    | sample_id      | int     |
+    | dna_sequence   | varchar |
+    | species        | varchar |
+    +----------------+---------+
+    sample_id is the unique key for this table.
+    Each row contains a DNA sequence represented as a string of characters (A, T, G, C) and the species it was collected from. 
+
+Biologists are studying basic patterns in DNA sequences. Write a solution to identify `sample_id` with the following patterns:
+
+*   Sequences that **start** with **ATG** (a common **start codon**)
+*   Sequences that **end** with either **TAA**, **TAG**, or **TGA** (**stop codons**)
+*   Sequences containing the motif **ATAT** (a simple repeated pattern)
+*   Sequences that have **at least** `3` **consecutive** **G** (like **GGG** or **GGGG**)
+
+Return _the result table ordered by __sample\_id in **ascending** order_.
+
+The result format is in the following example.
+
+**Example:**
+
+**Input:**
+
+Samples table:
+
+    +-----------+------------------+-----------+
+    | sample_id | dna_sequence     | species   |
+    +-----------+------------------+-----------+
+    | 1         | ATGCTAGCTAGCTAA  | Human     |
+    | 2         | GGGTCAATCATC     | Human     |
+    | 3         | ATATATCGTAGCTA   | Human     |
+    | 4         | ATGGGGTCATCATAA  | Mouse     |
+    | 5         | TCAGTCAGTCAG     | Mouse     |
+    | 6         | ATATCGCGCTAG     | Zebrafish |
+    | 7         | CGTATGCGTCGTA    | Zebrafish |
+    +-----------+------------------+-----------+ 
+
+**Output:**
+
+    +-----------+------------------+-------------+-------------+------------+------------+------------+
+    | sample_id | dna_sequence     | species     | has_start   | has_stop   | has_atat   | has_ggg    |
+    +-----------+------------------+-------------+-------------+------------+------------+------------+
+    | 1         | ATGCTAGCTAGCTAA  | Human       | 1           | 1          | 0          | 0          |
+    | 2         | GGGTCAATCATC     | Human       | 0           | 0          | 0          | 1          |
+    | 3         | ATATATCGTAGCTA   | Human       | 0           | 0          | 1          | 0          |
+    | 4         | ATGGGGTCATCATAA  | Mouse       | 1           | 1          | 0          | 1          |
+    | 5         | TCAGTCAGTCAG     | Mouse       | 0           | 0          | 0          | 0          |
+    | 6         | ATATCGCGCTAG     | Zebrafish   | 0           | 1          | 1          | 0          |
+    | 7         | CGTATGCGTCGTA    | Zebrafish   | 0           | 0          | 0          | 0          |
+    +-----------+------------------+-------------+-------------+------------+------------+------------+ 
+
+**Explanation:**
+
+*   Sample 1 (ATGCTAGCTAGCTAA):
+    *   Starts with ATG (has\_start = 1)
+    *   Ends with TAA (has\_stop = 1)
+    *   Does not contain ATAT (has\_atat = 0)
+    *   Does not contain at least 3 consecutive 'G's (has\_ggg = 0)
+*   Sample 2 (GGGTCAATCATC):
+    *   Does not start with ATG (has\_start = 0)
+    *   Does not end with TAA, TAG, or TGA (has\_stop = 0)
+    *   Does not contain ATAT (has\_atat = 0)
+    *   Contains GGG (has\_ggg = 1)
+*   Sample 3 (ATATATCGTAGCTA):
+    *   Does not start with ATG (has\_start = 0)
+    *   Does not end with TAA, TAG, or TGA (has\_stop = 0)
+    *   Contains ATAT (has\_atat = 1)
+    *   Does not contain at least 3 consecutive 'G's (has\_ggg = 0)
+*   Sample 4 (ATGGGGTCATCATAA):
+    *   Starts with ATG (has\_start = 1)
+    *   Ends with TAA (has\_stop = 1)
+    *   Does not contain ATAT (has\_atat = 0)
+    *   Contains GGGG (has\_ggg = 1)
+*   Sample 5 (TCAGTCAGTCAG):
+    *   Does not match any patterns (all fields = 0)
+*   Sample 6 (ATATCGCGCTAG):
+    *   Does not start with ATG (has\_start = 0)
+    *   Ends with TAG (has\_stop = 1)
+    *   Starts with ATAT (has\_atat = 1)
+    *   Does not contain at least 3 consecutive 'G's (has\_ggg = 0)
+*   Sample 7 (CGTATGCGTCGTA):
+    *   Does not start with ATG (has\_start = 0)
+    *   Does not end with TAA, "TAG", or "TGA" (has\_stop = 0)
+    *   Does not contain ATAT (has\_atat = 0)
+    *   Does not contain at least 3 consecutive 'G's (has\_ggg = 0)
+
+**Note:**
+
+*   The result is ordered by sample\_id in ascending order
+*   For each pattern, 1 indicates the pattern is present and 0 indicates it is not present
\ No newline at end of file
diff --git a/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/script.sql b/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/script.sql
new file mode 100644
index 000000000..d5bb52a20
--- /dev/null
+++ b/src/main/kotlin/g3401_3500/s3475_dna_pattern_recognition/script.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+# #Medium #Database #2025_03_06_Time_362_ms_(83.49%)_Space_0.0_MB_(100.00%)
+WITH SampleAnalysisCte AS (
+    SELECT sample_id, dna_sequence, species,
+        dna_sequence REGEXP '^ATG' AS has_start,
+        dna_sequence REGEXP 'TAA$|TAG$|TGA$' AS has_stop,
+        dna_sequence REGEXP '.*ATAT.*' AS has_atat,
+        dna_sequence REGEXP '.*GGG.*' AS has_ggg
+    FROM Samples
+)
+
+SELECT sample_id, dna_sequence, species, has_start, has_stop, has_atat, has_ggg
+FROM SampleAnalysisCte
+ORDER BY sample_id ASC;
diff --git a/src/test/kotlin/g3401_3500/s3467_transform_array_by_parity/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3467_transform_array_by_parity/SolutionTest.kt
new file mode 100644
index 000000000..357d64c1e
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3467_transform_array_by_parity/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3467_transform_array_by_parity
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun transformArray() {
+        assertThat<IntArray>(
+            Solution().transformArray(intArrayOf(4, 3, 2, 1)),
+            equalTo<IntArray>(intArrayOf(0, 0, 1, 1)),
+        )
+    }
+
+    @Test
+    fun transformArray2() {
+        assertThat<IntArray>(
+            Solution().transformArray(intArrayOf(1, 5, 1, 4, 2)),
+            equalTo<IntArray>(intArrayOf(0, 0, 1, 1, 1)),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/SolutionTest.kt
new file mode 100644
index 000000000..5498cee56
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3468_find_the_number_of_copy_arrays/SolutionTest.kt
@@ -0,0 +1,43 @@
+package g3401_3500.s3468_find_the_number_of_copy_arrays
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun countArrays() {
+        assertThat<Int>(
+            Solution()
+                .countArrays(
+                    intArrayOf(1, 2, 3, 4),
+                    arrayOf<IntArray>(intArrayOf(1, 2), intArrayOf(2, 3), intArrayOf(3, 4), intArrayOf(4, 5)),
+                ),
+            equalTo<Int>(2),
+        )
+    }
+
+    @Test
+    fun countArrays2() {
+        assertThat<Int>(
+            Solution()
+                .countArrays(
+                    intArrayOf(1, 2, 3, 4),
+                    arrayOf<IntArray>(intArrayOf(1, 10), intArrayOf(2, 9), intArrayOf(3, 8), intArrayOf(4, 7)),
+                ),
+            equalTo<Int>(4),
+        )
+    }
+
+    @Test
+    fun countArrays3() {
+        assertThat<Int>(
+            Solution()
+                .countArrays(
+                    intArrayOf(1, 2, 1, 2),
+                    arrayOf<IntArray>(intArrayOf(1, 1), intArrayOf(2, 3), intArrayOf(3, 3), intArrayOf(2, 3)),
+                ),
+            equalTo<Int>(0),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/SolutionTest.kt
new file mode 100644
index 000000000..6fde0a60e
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3469_find_minimum_cost_to_remove_array_elements/SolutionTest.kt
@@ -0,0 +1,25 @@
+package g3401_3500.s3469_find_minimum_cost_to_remove_array_elements
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minCost() {
+        assertThat<Int>(Solution().minCost(intArrayOf(6, 2, 8, 4)), equalTo<Int>(12))
+    }
+
+    @Test
+    fun minCost2() {
+        assertThat<Int>(Solution().minCost(intArrayOf(2, 1, 3, 3)), equalTo<Int>(5))
+    }
+
+    @Test
+    fun minCost3() {
+        assertThat<Int>(
+            Solution().minCost(intArrayOf(83, 47, 66, 24, 57, 85, 16)),
+            equalTo<Int>(224),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3470_permutations_iv/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3470_permutations_iv/SolutionTest.kt
new file mode 100644
index 000000000..2116c0520
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3470_permutations_iv/SolutionTest.kt
@@ -0,0 +1,42 @@
+package g3401_3500.s3470_permutations_iv
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun permute() {
+        assertThat<IntArray>(
+            Solution().permute(4, 6L),
+            equalTo<IntArray>(intArrayOf(3, 4, 1, 2)),
+        )
+    }
+
+    @Test
+    fun permute2() {
+        assertThat<IntArray>(
+            Solution().permute(3, 2L),
+            equalTo<IntArray>(intArrayOf(3, 2, 1)),
+        )
+    }
+
+    @Test
+    fun permute3() {
+        assertThat<IntArray>(Solution().permute(2, 3L), equalTo<IntArray>(intArrayOf()))
+    }
+
+    @Test
+    fun permute4() {
+        assertThat<IntArray>(
+            Solution().permute(43, 142570305460935L),
+            equalTo<IntArray>(
+                intArrayOf(
+                    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+                    21, 22, 43, 40, 27, 36, 25, 34, 31, 32, 29, 28, 33, 24, 23, 26, 41, 42,
+                    35, 38, 37, 30, 39,
+                ),
+            ),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/SolutionTest.kt
new file mode 100644
index 000000000..2313e62b7
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3471_find_the_largest_almost_missing_integer/SolutionTest.kt
@@ -0,0 +1,28 @@
+package g3401_3500.s3471_find_the_largest_almost_missing_integer
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun largestInteger() {
+        assertThat<Int>(
+            Solution().largestInteger(intArrayOf(3, 9, 2, 1, 7), 3),
+            equalTo<Int>(7),
+        )
+    }
+
+    @Test
+    fun largestInteger2() {
+        assertThat<Int>(
+            Solution().largestInteger(intArrayOf(3, 9, 7, 2, 1, 7), 4),
+            equalTo<Int>(3),
+        )
+    }
+
+    @Test
+    fun largestInteger3() {
+        assertThat<Int>(Solution().largestInteger(intArrayOf(0, 0), 1), equalTo<Int>(-1))
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/SolutionTest.kt
new file mode 100644
index 000000000..dfcbdf427
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3472_longest_palindromic_subsequence_after_at_most_k_operations/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3472_longest_palindromic_subsequence_after_at_most_k_operations
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun longestPalindromicSubsequence() {
+        assertThat<Int>(
+            Solution().longestPalindromicSubsequence("abced", 2),
+            equalTo<Int>(3),
+        )
+    }
+
+    @Test
+    fun longestPalindromicSubsequence2() {
+        assertThat<Int>(
+            Solution().longestPalindromicSubsequence("aaazzz", 4),
+            equalTo<Int>(6),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/SolutionTest.kt
new file mode 100644
index 000000000..9e43e115e
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3473_sum_of_k_subarrays_with_length_at_least_m/SolutionTest.kt
@@ -0,0 +1,23 @@
+package g3401_3500.s3473_sum_of_k_subarrays_with_length_at_least_m
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxSum() {
+        assertThat<Int>(
+            Solution().maxSum(intArrayOf(1, 2, -1, 3, 3, 4), 2, 2),
+            equalTo<Int>(13),
+        )
+    }
+
+    @Test
+    fun maxSum2() {
+        assertThat<Int>(
+            Solution().maxSum(intArrayOf(-10, 3, -1, -2), 4, 1),
+            equalTo<Int>(-10),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/SolutionTest.kt b/src/test/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/SolutionTest.kt
new file mode 100644
index 000000000..15b8ff5bf
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3474_lexicographically_smallest_generated_string/SolutionTest.kt
@@ -0,0 +1,38 @@
+package g3401_3500.s3474_lexicographically_smallest_generated_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun generateString() {
+        assertThat<String>(
+            Solution().generateString("TFTF", "ab"),
+            equalTo<String>("ababa"),
+        )
+    }
+
+    @Test
+    fun generateString2() {
+        assertThat<String>(Solution().generateString("TFTF", "abc"), equalTo<String>(""))
+    }
+
+    @Test
+    fun generateString3() {
+        assertThat<String>(Solution().generateString("F", "d"), equalTo<String>("a"))
+    }
+
+    @Test
+    fun generateString4() {
+        assertThat<String>(Solution().generateString("TTFFT", "fff"), equalTo<String>(""))
+    }
+
+    @Test
+    fun generateString5() {
+        assertThat<String>(
+            Solution().generateString("FFTFFF", "a"),
+            equalTo<String>("bbabbb"),
+        )
+    }
+}
diff --git a/src/test/kotlin/g3401_3500/s3475_dna_pattern_recognition/MysqlTest.kt b/src/test/kotlin/g3401_3500/s3475_dna_pattern_recognition/MysqlTest.kt
new file mode 100644
index 000000000..cd5b2da45
--- /dev/null
+++ b/src/test/kotlin/g3401_3500/s3475_dna_pattern_recognition/MysqlTest.kt
@@ -0,0 +1,101 @@
+package g3401_3500.s3475_dna_pattern_recognition
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import org.zapodot.junit.db.annotations.EmbeddedDatabase
+import org.zapodot.junit.db.annotations.EmbeddedDatabaseTest
+import org.zapodot.junit.db.common.CompatibilityMode
+import java.io.BufferedReader
+import java.io.FileNotFoundException
+import java.io.FileReader
+import java.sql.ResultSet
+import java.sql.SQLException
+import java.util.stream.Collectors
+import javax.sql.DataSource
+
+@EmbeddedDatabaseTest(
+    compatibilityMode = CompatibilityMode.MySQL,
+    initialSqls = [
+        (
+            "    CREATE TABLE Samples (" +
+                "    sample_id INT," +
+                "    dna_sequence VARCHAR(100)," +
+                "    species VARCHAR(100)" +
+                ");" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(1, 'ATGCTAGCTAGCTAA', 'Human');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(2, 'GGGTCAATCATC', 'Human');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(3, 'ATATATCGTAGCTA', 'Human');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(4, 'ATGGGGTCATCATAA', 'Human');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(5, 'TCAGTCAGTCAG', 'Human');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(6, 'ATATCGCGCTAG', 'Zebrafish');" +
+                "insert into Samples (sample_id, dna_sequence, species) values " +
+                "(7, 'CGTATGCGTCGTA', 'Zebrafish');"
+            ),
+    ],
+)
+internal class MysqlTest {
+    @Test
+    @Throws(SQLException::class, FileNotFoundException::class)
+    fun testScript(@EmbeddedDatabase dataSource: DataSource) {
+        dataSource.connection.use { connection ->
+            connection.createStatement().use { statement ->
+                statement.executeQuery(
+                    BufferedReader(
+                        FileReader(
+                            (
+                                "src/main/kotlin/g3401_3500/" +
+                                    "s3475_dna_pattern_recognition/" +
+                                    "script.sql"
+                                ),
+                        ),
+                    )
+                        .lines()
+                        .collect(Collectors.joining("\n"))
+                        .replace("#.*?\\r?\\n".toRegex(), ""),
+                ).use { resultSet ->
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 1, "ATGCTAGCTAGCTAA", "Human", "TRUE", "TRUE", "FALSE", "FALSE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 2, "GGGTCAATCATC", "Human", "FALSE", "FALSE", "FALSE", "TRUE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 3, "ATATATCGTAGCTA", "Human", "FALSE", "FALSE", "TRUE", "FALSE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 4, "ATGGGGTCATCATAA", "Human", "TRUE", "TRUE", "FALSE", "TRUE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 5, "TCAGTCAGTCAG", "Human", "FALSE", "FALSE", "FALSE", "FALSE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 6, "ATATCGCGCTAG", "Zebrafish", "FALSE", "TRUE", "TRUE", "FALSE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(true))
+                    checkRow(resultSet, 7, "CGTATGCGTCGTA", "Zebrafish", "FALSE", "FALSE", "FALSE", "FALSE")
+                    assertThat<Boolean>(resultSet.next(), equalTo<Boolean>(false))
+                }
+            }
+        }
+    }
+
+    private fun checkRow(
+        resultSet: ResultSet,
+        sampleId: Int,
+        dnaSequence: String,
+        species: String,
+        hasStart: String,
+        hasStop: String,
+        hasAtat: String,
+        hasGgg: String,
+    ) {
+        assertThat<Int>(resultSet.getInt(1), equalTo<Int>(sampleId))
+        assertThat<String>(resultSet.getNString(2), equalTo<String>(dnaSequence))
+        assertThat<String>(resultSet.getNString(3), equalTo<String>(species))
+        assertThat<String>(resultSet.getNString(4), equalTo<String>(hasStart))
+        assertThat<String>(resultSet.getNString(5), equalTo<String>(hasStop))
+        assertThat<String>(resultSet.getNString(6), equalTo<String>(hasAtat))
+        assertThat<String>(resultSet.getNString(7), equalTo<String>(hasGgg))
+    }
+}