Problem:
Score : 500 points

Problem Statement

Find the number of integers between 1 and N (inclusive) that contains exactly K non-zero digits when written in base ten.

Constraints

1 \leq N < 10^{100}

1 \leq K \leq 3

Input

Input is given from Standard Input in the following format:

N
K

Output

Print the count.

Sample Input 1

100
1

Sample Output 1

19

The following 19 integers satisfy the condition:

1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100

Sample Input 2

25
2

Sample Output 2

14

The following 14 integers satisfy the condition:

11,12,13,14,15,16,17,18,19,21,22,23,24,25

Sample Input 3

314159
2

Sample Output 3

937

Sample Input 4

9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999
3

Sample Output 4

117879300

Solution in Kotlin (1.0.0) (judge verdict: Wrong Answer)

import java.lang.Math

fun main(args: Array<String>) {
    val mod = 1000000007L
    val N = readInputLine().toCharArray()
    val K = readInputLine().toInt()

    if (N.size < K) {
        println(0)
        return
    }

    val factorial = LongArray(N.size + 1)
    val inverse = LongArray(N.size + 1)
    val factorialInverse = LongArray(N.size + 1)
    factorial[0] = 1L
    factorial[1] = 1L
    inverse[0] = 1L
    inverse[1] = 1L
    factorialInverse[0] = 1L
    factorialInverse[1] = 1L
    for (i in 2..N.size) {
        factorial[i] = (factorial[i - 1] * i.toLong() % mod)
        inverse[i] = (mod - inverse[mod.toInt() % i] * (mod / i.toLong()) % mod)
        factorialInverse[i] = (factorialInverse[i - 1] * inverse[i] % mod)
    }

    // まずはNの桁数の値すべてを使える場合の組み合わせ数を求める
    var ans = factorial[N.size] * (factorialInverse[K] * factorialInverse[N.size - K] % mod) % mod
    for (i in 1..K) {
        ans *= 9L
        ans %= mod
    }

    // 指定数を超過する数を消す
    var usedCnt = 0

    for (i in N.indices) {
        if (N[i] != '0') {
            usedCnt++
        }

        if (N.size - (i + 1) >= 0) {
            var subTmp =
                factorial[N.size - (i + 1)] * (factorialInverse[K - usedCnt] * factorialInverse[Math.max(0, N.size - (i + 1) - (K - usedCnt))] % mod) % mod * (9L - (N[i] - '0')) % mod
            for (j in 1..K - usedCnt - if (N[i] == '0') 1 else 0) {
                subTmp *= 9L
            }

            ans -= subTmp
            if (ans < 0L) {
                println(0)
                return
            }
        }

        if (usedCnt == K) {
            break
        }
    }

    println(ans)
}

fun readInputLine(): String {
    return readLine()!!
}