import sys

read = sys.stdin.buffer.read

readline = sys.stdin.buffer.readline

readlines = sys.stdin.buffer.readlines



from functools import lru_cache



N, K = list(map(int,read().split()))



@lru_cache(None)

def F(N, K):

    """N以下で0でないものがちょうどK個。0を含める"""

    assert N >= 0

    if N < 10:

        if K == 0:

            return 1

        if K == 1:

            return N

        return 0

    q,r = divmod(N,10)

    ret = 0

    if K >= 1:

        # 1の位が nonzero

        ret += F(q, K-1) * r

        ret += F(q-1, K-1) * (9-r)

    # 1の位が zero

    ret += F(q, K)

    return ret



# F(100, 1), F(25, 2), F(314159, 2)



print((F(N, K)))

import sys

import math

sys.setrecursionlimit(10 ** 7)



# 桁DP

# 非再帰



S = eval(input())

K = int(eval(input()))

N = len(S)



# dp[n桁目まで決まってる][Non-Zeroの個数][Nと一致? 0:一致している 1:一致していない]

dp = [[[0] * 2 for _ in range(4)] for _ in range(N + 1)]



# n=0 桁目の値は、0として、それはKの値には関係なく、Nと一致している

dp[0][0][0] = 1



# i,j,kのうち、小さい方から埋めていく

for i in range(N):

    for j in range(4):

        for k in range(2):

            # 今決めようとしているの桁の値

            d = int(S[i])



            # 次の桁の値のループ(0-9)

            for nextd in range(10):

                # 次の桁を決めたあとのj,k

                nextj = j

                nextk = k



                # 次の桁がNon-Zero

                if nextd != 0:

                    nextj += 1

                # K個を超えたらいらない

                if nextj > K:

                    continue



                # 前の桁までNと一致していた場合

                # 使える数に制限あり

                if k == 0:

                    if d < nextd:

                        continue

                    elif nextd < d:

                        nextk = 1



                        # 前までの個数と同じ分の場合の数

                dp[i + 1][nextj][nextk] += dp[i][j][k]





ans = dp[N][K][0] + dp[N][K][1]

print(ans)

import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from functools import lru_cache

N, K = list(map(int, read().split()))


@lru_cache(None)
def F(N, K):
    """N以下で0でないものがちょうどK個。0を含める"""
    assert N >= 0
    if N < 10:
        if K == 0:
            return 1
        if K == 1:
            return N
        return 0
    q, r = divmod(N, 10)
    ret = 0
    if K >= 1:
        # 1の位が nonzero
        ret += F(q, K - 1) * r
        ret += F(q - 1, K - 1) * (9 - r)
    # 1の位が zero
    ret += F(q, K)
    return ret


# F(100, 1), F(25, 2), F(314159, 2)
print((F(N, K)))

import sys
import math

sys.setrecursionlimit(10**7)
# 桁DP
# 非再帰
S = eval(input())
K = int(eval(input()))
N = len(S)
# dp[n桁目まで決まってる][Non-Zeroの個数][Nと一致? 0:一致している 1:一致していない]
dp = [[[0] * 2 for _ in range(4)] for _ in range(N + 1)]
# n=0 桁目の値は、0として、それはKの値には関係なく、Nと一致している
dp[0][0][0] = 1
# i,j,kのうち、小さい方から埋めていく
for i in range(N):
    for j in range(4):
        for k in range(2):
            # 今決めようとしているの桁の値
            d = int(S[i])
            # 次の桁の値のループ(0-9)
            for nextd in range(10):
                # 次の桁を決めたあとのj,k
                nextj = j
                nextk = k
                # 次の桁がNon-Zero
                if nextd != 0:
                    nextj += 1
                # K個を超えたらいらない
                if nextj > K:
                    continue
                # 前の桁までNと一致していた場合
                # 使える数に制限あり
                if k == 0:
                    if d < nextd:
                        continue
                    elif nextd < d:
                        nextk = 1
                        # 前までの個数と同じ分の場合の数
                dp[i + 1][nextj][nextk] += dp[i][j][k]
ans = dp[N][K][0] + dp[N][K][1]
print(ans)

+import math -read = sys.stdin.buffer.read -readline = sys.stdin.buffer.readline -readlines = sys.stdin.buffer.readlines -from functools import lru_cache - -N, K = list(map(int, read().split())) - - -@lru_cache(None) -def F(N, K): -    """N以下で0でないものがちょうどK個。0を含める""" -    assert N >= 0 -    if N < 10: -        if K == 0: -            return 1 -        if K == 1: -            return N -        return 0 -    q, r = divmod(N, 10) -    ret = 0 -    if K >= 1: -        # 1の位が nonzero -        ret += F(q, K - 1) * r -        ret += F(q - 1, K - 1) * (9 - r) -    # 1の位が zero -    ret += F(q, K) -    return ret - - -# F(100, 1), F(25, 2), F(314159, 2) -print((F(N, K))) +sys.setrecursionlimit(10**7) +# 桁DP +# 非再帰 +S = eval(input()) +K = int(eval(input())) +N = len(S) +# dp[n桁目まで決まってる][Non-Zeroの個数][Nと一致? 0:一致している 1:一致していない] +dp = [[[0] * 2 for _ in range(4)] for _ in range(N + 1)] +# n=0 桁目の値は、0として、それはKの値には関係なく、Nと一致している +dp[0][0][0] = 1 +# i,j,kのうち、小さい方から埋めていく +for i in range(N): +    for j in range(4): +        for k in range(2): +            # 今決めようとしているの桁の値 +            d = int(S[i]) +            # 次の桁の値のループ(0-9) +            for nextd in range(10): +                # 次の桁を決めたあとのj,k +                nextj = j +                nextk = k +                # 次の桁がNon-Zero +                if nextd != 0: +                    nextj += 1 +                # K個を超えたらいらない +                if nextj > K: +                    continue +                # 前の桁までNと一致していた場合 +                # 使える数に制限あり +                if k == 0: +                    if d < nextd: +                        continue +                    elif nextd < d: +                        nextk = 1 +                        # 前までの個数と同じ分の場合の数 +                dp[i + 1][nextj][nextk] += dp[i][j][k] +ans = dp[N][K][0] + dp[N][K][1] +print(ans)