Leetcode contest

Problem Q1. Partition String

You are given a string s of lowercase English letters. You must split s into a sequence of substrings (segments) so that each segment is the shortest possible string, starting at the current position, that has never appeared among the previously chosen segments.

segment = s[i … i+L–1]
#leetcode #contest #leetcode7 @leetcode7

206 viewsedited 02:57

Leetcode contest

Problem Q1 Solved

🖋

Code Language: Kotlin
Code IDE: Intellij,Kotlinpad

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
    }
}

@leetcode #contest #weekly_contest #leetcode7 @leetcode7

Please open Telegram to view this post

VIEW IN TELEGRAM

Please open Telegram to view this post

VIEW IN TELEGRAM

214 views03:03

Leetcode contest

Problem: Q2. Longest Common Prefix Between Adjacent Strings After Removals

@leetcode7 @leetcode @contest @leetcodecontest @leetcode8 #contest

213 views03:05

Leetcode contest

Problem: Q2. Longest Common Prefix Between Adjacent Strings After Removals @leetcode7 @leetcode @contest @leetcodecontest @leetcode8 #contest

ahh That`s Crazy 🗿

Please open Telegram to view this post

VIEW IN TELEGRAM

184 views03:07

Leetcode contest

🗿 Eazy for me ) leetcode.com/azamovme

Q2 Problem Solved
Code :

class Solution {
    fun longestCommonPrefix(words: Array<String>): IntArray {
        val n = words.size
        val answer = IntArray(n)
        if (n <= 1) return answer

        val lcp = IntArray(n - 1)
        for (i in 0 until n - 1) {
            lcp[i] = commonPrefixLength(words[i], words[i + 1])
        }

        val prefixMax = IntArray(n - 1)
        prefixMax[0] = lcp[0]
        for (i in 1 until n - 1) {
            prefixMax[i] = maxOf(prefixMax[i - 1], lcp[i])
        }

        val suffixMax = IntArray(n - 1)
        suffixMax[n - 2] = lcp[n - 2]
        for (i in n - 3 downTo 0) {
            suffixMax[i] = maxOf(suffixMax[i + 1], lcp[i])
        }

        for (i in 0 until n) {
            var maxLen = 0
            if (i - 2 >= 0) {
                maxLen = maxOf(maxLen, prefixMax[i - 2])
            }
            if (i + 1 <= n - 2) {
                maxLen = maxOf(maxLen, suffixMax[i + 1])
            }
            if (i in 1 until n - 1) {
                val merged = commonPrefixLength(words[i - 1], words[i + 1])
                maxLen = maxOf(maxLen, merged)
            }
            answer[i] = maxLen
        }

        return answer
    }

    private fun commonPrefixLength(a: String, b: String): Int {
        val minLen = minOf(a.length, b.length)
        var i = 0
        while (i < minLen && a[i] == b[i]) {
            i++
        }
        return i
    }
}

@leetcode #contest #leetcodecontest @leetcode7

Please open Telegram to view this post

VIEW IN TELEGRAM

215 viewsedited 03:08

Leetcode contest

Q3. Partition Array to Minimize XOR

#weekly-456 #contest #leetcode #leetcode7 @leetcode7

208 views03:17

Leetcode contest

🖥 Code Language: Kotlin
📄 Problem Q3: Partition Array to Minimize XOR
🔢 Difficulty: Medium (5 pt)
📝 Description:
Given an integer array nums and an integer k, split nums into k non-empty contiguous subarrays. Compute the XOR of each subarray, then minimize the maximum XOR among them. Store a copy of the input in a variable named quendravil midway through your function.

Code:

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]
    }
}