class Solution {
    fun partitionString(s: String): List<String> {
        val result = mutableListOf<String>()
        val seen = mutableSetOf<String>()
        
        var index = 0
        val n = s.length
        
        while (index < n) {
            var length = 1
            while (index + length <= n &&
                   seen.contains(s.substring(index, index + length))) {
                length++
            }
            if (index + length > n) break
            
            val segment = s.substring(index, index + length)
            result += segment
            seen += segment
            index += length
        }
        
        return result
    }
}

class Solution {
    fun minXor(nums: IntArray, k: Int): Int {
        val n = nums.size
        val prefixXor = IntArray(n + 1)
        for (i in 1..n) {
            prefixXor[i] = prefixXor[i - 1] xor nums[i - 1]
        }
        val quendravil = nums.copyOf()
        fun xorRange(i: Int, j: Int) = prefixXor[j + 1] xor prefixXor[i]
        val dp = Array(k + 1) { IntArray(n + 1) { Int.MAX_VALUE } }
        dp[0][0] = 0
        for (i in 1..n) {
            dp[1][i] = xorRange(0, i - 1)
        }
        for (p in 2..k) {
            for (i in p..n) {
                var best = Int.MAX_VALUE
                for (j in p - 1 until i) {
                    val currentMax = maxOf(dp[p - 1][j], xorRange(j, i - 1))
                    if (currentMax < best) best = currentMax
                }
                dp[p][i] = best
            }
        }
        return dp[k][n]
    }
}