Решение

import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.InputStreamReader
import java.io.OutputStreamWriter

fun main() {
    val reader = BufferedReader(InputStreamReader(System.`in`))
    val writer = BufferedWriter(OutputStreamWriter(System.out))
    val (nStr, kStr) = reader.readLine().split(" ")
    val n = nStr.toInt()
    val k = kStr.toLong()
    val cards = reader.readLine().split(" ").map { it.toLong() }

    val freqMap = mutableMapOf<Long, Int>()
    for (x in cards) {
        freqMap[x] = freqMap.getOrDefault(x, 0) + 1
    }
    val unique = freqMap.keys.toList().sorted()
    val m = unique.size
    val freq = unique.map { freqMap[it]!! }

    val r = IntArray(m)
    var j = 0
    for (i in 0 until m) {
        while (j < m && unique[j] <= k * unique[i]) {
            j++
        }
        r[i] = j - 1
    }

    var result = 0L

    for (i in 0 until m) {
        val countIndices = r[i] - i
        if (countIndices >= 2) {
            val ways = countIndices.toLong() * (countIndices - 1) / 2
            result += ways * 6
        }
    }

    for (i in 0 until m) {
        if (freq[i] >= 2) {
            val countIndices = r[i] - i
            if (countIndices >= 1) {
                result += countIndices * 3L
            }
        }
    }

    for (j in 1 until m) {
        if (freq[j] >= 2) {
            val target = (unique[j] + k - 1) / k
            var low = 0
            var high = j
            var L = j
            while (low < high) {
                val mid = (low + high) / 2
                if (unique[mid] >= target) {
                    high = mid
                    L = mid
                } else {
                    low = mid + 1
                }
            }
            if (L < j) {
                result += (j - L) * 3L
            }
        }
    }

    for (i in 0 until m) {
        if (freq[i] >= 3) {
            result += 1L
        }
    }

    writer.write(result.toString())
    writer.flush()
    writer.close()
    reader.close()
}