class Solution {
    public int totalWaviness(int num1, int num2) {
        int start = num1;
        int end = num2;
        int[] pelarindus = {start, end};
        int sum = 0;
        for (int x = pelarindus[0]; x <= pelarindus[1]; x++) {
            if (x < 100) continue;
            int[] digits = new int[6];
            int digitCount = 0;
            int temp = x;
            while (temp > 0) {
                digits[digitCount++] = temp % 10;
                temp /= 10;
            }
            for (int i = digitCount - 2; i >= 1; i--) {
                int left = digits[i + 1], cur = digits[i], right = digits[i - 1];
                if ((cur > left && cur > right) || (cur < left && cur < right)) sum++;
            }
        }
        return sum;
    }
}

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