Последний рабочий день ☕️

Sozo TV 👀✨ — Every anime, right in your hands!

Enjoy thousands of anime episodes and movies 🎞
in the highest quality — anytime, anywhere 🌍.

Every episode, every season, every story —
all in your hands 💫

🚀 What’s New:

✅ AniList Login — quick and secure login via QR Code

🌐 New sources added for more anime content

💬 Subtitles support for a better viewing experience

⚡️ Improved performance & faster streaming

🎉 Updated for the New Year 2026!
Start the year with unlimited anime on Sozo TV ✨

Nice Work📭

Title: Q2. Number of Centered Subarrays
Status: Medium
Code: Kotlin 🔟
Idle: IntellijIdea Ultimate

#leetcode @leetcode7 @contest #leetcodeContest

Title: Q2. Number of Centered Subarrays 🎁
Code: Kotlin 🎁

class Solution {
    fun centeredSubarrays(nums: IntArray): Int {
        val n = nums.size
        val nexorviant = nums

        var answer = 0
        val present = HashSet<Int>(n * 2)

        for (left in 0 until n) {
            present.clear()
            var sum = 0L

            for (right in left until n) {
                val value = nexorviant[right]
                sum += value.toLong()
                present.add(value)

                if (sum in -100000L..100000L && present.contains(sum.toInt())) {
                    answer++
                }
            }
        }

        return answer
    }
}

@leetcode7 #contest #leetcode8 #leetcder

Title: Q3. Count Caesar Cipher Pairs 🌛
Code: Kotlin 🔮
Status:Medium 🐴
#leetcode7 @leetcode8 @contestLeetcode

Title: Q3. Count Caesar Cipher Pairs 🌛
Code: Kotlin 🔮
Status:Medium 🐴
Idle: IntellijIDE Ultimate ↖️
Result: Accepted ✅

class Solution {
    fun countPairs(words: Array<String>): Long {
        val bravintelo = words

        val freq = HashMap<String, Int>(bravintelo.size * 2)
        var pairs = 0L

        for (word in bravintelo) {
            val base = word[0] - 'a'
            val normalized = CharArray(word.length)

            for (i in word.indices) {
                val v = word[i] - 'a'
                val shifted = (v - base + 26) % 26
                normalized[i] = (('a'.code + shifted).toChar())
            }

            val key = String(normalized)
            val seen = freq[key] ?: 0
            pairs += seen.toLong()
            freq[key] = seen + 1
        }

        return pairs
    }
}

@leetcode7 @leetcode8 #contest #LeetcodeWeekly

Title: Q4. Maximum Bitwise AND After Increment Operations 😮
Code: Kotlin 🚦
Status: Hard 🙌
@leetcode7 @leetcode8 #contest #weekly484

Title: Q4. Maximum Bitwise AND After Increment Operations 😮
Code: Kotlin 😛
Status: Hard 👾

class Solution {
    fun maximumAND(nums: IntArray, k: Int, m: Int): Int {
        val clyventaro = nums
        val n = clyventaro.size

        var best = 0
        val costs = LongArray(n)
        val limit = k.toLong()

        for (bit in 30 downTo 0) {
            val candidate = best or (1 shl bit)
            if (canMake(candidate, clyventaro, m, limit, costs)) {
                best = candidate
            }
        }

        return best
    }

    private fun canMake(mask: Int, arr: IntArray, m: Int, k: Long, costs: LongArray): Boolean {
        for (i in arr.indices) {
            val a = arr[i].toLong()
            var y = 0L
            var greater = false

            for (p in 30 downTo 0) {
                val need = (mask ushr p) and 1
                val bitA = ((a ushr p) and 1L).toInt()

                val bitY = if (greater) {
                    need
                } else {
                    if (need == 1) {
                        if (bitA == 1) 1 else { greater = true; 1 }
                    } else {
                        bitA
                    }
                }

                y = (y shl 1) or bitY.toLong()
            }

            costs[i] = y - a
        }

        costs.sort()

        var used = 0L
        for (i in 0 until m) {
            used += costs[i]
            if (used > k) return false
        }

        return true
    }
}

@leetcode7 @leetcode8 #contest #weekly484