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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;

namespace Contest
{
    partial class Program
    {
        static void Main(string[] args)
        {
            ABC154_E();
        }



        static void ABC154_A()
        {
            var st = ReadStrN();
            var ab = ReadIntN();
            var u = ReadStr();
            Console.WriteLine("{0} {1}", ab[0] - (st[0] == u ? 1 : 0), ab[1] - (st[1] == u ? 1 : 0));
        }
        static void ABC154_B()
        {
            Console.WriteLine(String.Join("", Enumerable.Repeat('x', ReadStr().Length)));
        }
        static void ABC154_C()
        {
            var N = ReadInt();
            var A = ReadIntN();
            A = A.OrderBy(x => x).ToArray();
            for (int i = 0; i < N - 1; ++i)
            {
                if (A[i] == A[i + 1])
                {
                    Console.WriteLine("NO");
                    return;
                }
            }
            Console.WriteLine("YES");
        }
        static void ABC154_D()
        {
            var NK = ReadIntN();
            var P = ReadIntN();
            var N = NK[0];
            var K = NK[1];
            int[] sums = new int[N + 1];
            sums[0] = 0;
            for (int i = 1; i < N + 1; ++i)
            {
                sums[i] = sums[i - 1] + P[i - 1];
            }
            var max = Enumerable.Range(0, N - K + 1).Select(i => sums[i + K] - sums[i]).Max();
            Console.WriteLine((max + K) / 2.0);
        }
        static void ABC154_E()
        {
            var NStr = ReadStr();
            var K = ReadInt();
            var N = NStr.Select(c => Convert.ToInt32(c) - 48).Reverse().ToArray();
            var length = N.Length;
            long[,] table1 = new long[length, 3];
            long[,] table2 = new long[length, 3];

            table1[0, 0] = N[0];
            table2[0, 0] = 9;

            for (int i = 1; i < length; ++i)
            {
                table2[i, 0] = table2[i - 1, 0] * 1 + 9;
                table2[i, 1] = table2[i - 1, 1] * 1 + table2[i - 1, 0] * 9;
                table2[i, 2] = table2[i - 1, 2] * 1 + table2[i - 1, 1] * 9;
                var n = N[i];
                if (n == 0)
                {
                    for (int j = 0; j < 3; ++j)
                    {
                        table1[i, j] = table1[i - 1, j];
                    }
                }
                else
                {
                    table1[i, 0] = table2[i - 1, 0] + (n - 1) + 1;
                    table1[i, 1] = table2[i - 1, 1] + (n - 1) * table2[i - 1, 0] + table1[i - 1, 0];
                    table1[i, 2] = table2[i - 1, 2] + (n - 1) * table2[i - 1, 1] + table1[i - 1, 1];
                }
            }
            Console.WriteLine(table1[length - 1, K - 1]);
        }
        static void ABC154_F()
        {
            var P = 1000000007;
            var RC = ReadIntN();
            var r1 = RC[0];
            var c1 = RC[1];
            var r2 = RC[2];
            var c2 = RC[3];
            var facts = Facts(r2 + c2 + 2, P);
            var factInvs = facts.Select(x => Inverse(x, P)).ToArray();

            Func<int, int, long> sumF = (r, c) =>
                  ((facts[r + c + 2] * factInvs[r + 1] % P) * factInvs[c + 1] % P + (P - 1)) % P;
            long ans = (sumF(r2, c2) - sumF(r1 - 1, c2) - sumF(r2, c1 - 1) + sumF(r1 - 1, c1 - 1) + P * 2) % P;
            Console.WriteLine(ans);
        }
        static long Inverse(long a, long p)
        {
            long b = p, c = 1, d = 0, e = 0, f = 0;
            while (b != 0)
            {
                e = a / b;
                f = b; b = a - e * b; a = f;
                f = d; d = c - e * d; c = f;
            }
            c %= p;
            return c + (c < 0 ? p : 0);
        }
        static long[] Facts(int n, long p)
        {
            var facts = new long[n + 1];
            facts[0] = 1;
            for (int i = 1; i <= n; ++i)
            {
                facts[i] = (i * facts[i - 1]) % p;
            }
            return facts;
        }

        static string ReadStr()
        {
            return Console.ReadLine();
        }
        static string[] ReadStrN()
        {
            return Console.ReadLine().Split(' ');
        }
        static int ReadInt()
        {
            return Convert.ToInt32(Console.ReadLine());
        }
        static int[] ReadIntN()
        {
            return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray();
        }
    }
}