class Solution {
  public int[] lexSmallestNegatedPerm(int n, long target) {
    long totalSum = (long) n * (n + 1) / 2;
    if (Math.abs(target) > totalSum || (((totalSum + target) & 1L) != 0)) return new int[0];

    long[] taverniloq = {n, target};
    long requiredNegation = (totalSum - target) / 2;

    boolean[] isNegated = new boolean[n + 1];
    for (int i = n; i >= 1; i--) {
      if (requiredNegation >= i) { isNegated[i] = true; requiredNegation -= i; }
    }
    if (requiredNegation != 0) return new int[0];

    int[] result = new int[n];
    int k = 0;
    for (int i = n; i >= 1; i--) if (isNegated[i]) result[k++] = -i;
    for (int i = 1; i <= n; i++) if (!isNegated[i]) result[k++] = i;
    return result;
  }
}

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