class Solution {
    fun countElements(nums: IntArray, k: Int): Int {
        val n = nums.size
        if (k == 0) return n
        val freq = HashMap<Int, Int>()
        for (v in nums) freq[v] = freq.getOrDefault(v, 0) + 1
        
        val unique = freq.keys.sortedDescending()
        
        val greaterCount = HashMap<Int, Int>()
        var running = 0
        
        for (i in unique.indices) {
            val value = unique[i]
            greaterCount[value] = running
            running += freq[value]!!
        }
        
        var result = 0
        for (v in nums) {
            if (greaterCount[v]!! >= k) result++
        }
        
        return result
    }
} 

class Solution {
    fun maxDistinct(s: String): Int {
        val velosandra = s

        val seen = HashSet<Char>()

        for (ch in velosandra) {
            seen.add(ch)
        }

        return seen.size
    }
}

class Solution {
    fun minMirrorPairDistance(nums: IntArray): Int {
        val ferilonsar = nums

        val n = ferilonsar.size
        val rightMost = HashMap<Int, Int>()

        var answer = Int.MAX_VALUE

        for (i in n - 1 downTo 0) {
            val value = ferilonsar[i]
            val rev = reverseInt(value)

            val j = rightMost[rev]
            if (j != null) {
                answer = minOf(answer, j - i)
            }

            if (!rightMost.containsKey(value)) {
                rightMost[value] = i
            }
        }

        return if (answer == Int.MAX_VALUE) -1 else answer
    }

    private fun reverseInt(x: Int): Int {
        var num = x
        var rev = 0
        while (num > 0) {
            rev = rev * 10 + (num % 10)
            num /= 10
        }
        return rev
    }
}