# Count of integers of length N and value less than K such that they contain digits only from the given set

• Difficulty Level : Expert
• Last Updated : 31 May, 2022

Given a set of digits A[] in sorted order and two integers N and K, the task is to find how many numbers of length N are possible whose value is less than K and the digits are from the given set only. Note that you can use the same digit multiple times.

Examples:

Input: A[] = {0, 1, 5}, N = 1, K = 2
Output:
Only valid numbers are 0 and 1.

Input: A[] = {0, 1, 2, 5}, N = 2, K = 21
Output:
10, 11, 12, 15 and 20 are the valid numbers.

Approach: Let d be the size of A[]. We can break this problem into three simpler cases.

1. When N is greater than the length of K, It is obvious that if the length of N is greater than the length of k or if d is equal to 0, no such number is possible.
2. When N is smaller than the length of K, then all possible combinations of digit of length N are valid. Also, we have to keep in mind that 0 can’t be in the first place. So, if A[] contains 0, the first place can be filled in (d – 1) ways. Since repetition is allowed and 0 can occupy the other places, rest N – 1 places can be filled in d * d * … * d(N – 1) times i.e. in dN – 1 ways. Therefore the answer is (d – 1) * (dN – 1) if A[] contains 0 else dN.
3. When N is equal to the length of K, this is the trickiest part. We need to use Dynamic Programming for this part. Construct a digit array of K. Let’s call it digit[]. Let First(i) be the number formed by taking the first i digits of it. Let lower[i] denote the number of elements in A[] which are smaller than i
For example, First(2) of 423 is 42. If A[] = {0, 2} then lower = 0, lower = 1, lower = 1, lower = 2.
Generate N digit numbers by dynamic programming. Let dp[i] denote total numbers of length i which are less than first i digits of K
Elements in dp[i] can be generated by two cases:
• For all the numbers whose First(i – 1) is less than First(i – 1) of K, we can put any digit at ith index. Hence, dp[i] = dp[i] + (dp[i – 1] * d)
• For all the numbers whose First(i – 1) is the same as First(i – 1) of K, we can only put those digits which are smaller than digit[i]. Hence, dp[i] = dp[i] + lower[digit[i]].

Below is the implementation of the above approach:

## C++14

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `#define MAX 10` `// Function to convert a number into vector``vector<``int``> numToVec(``int` `N)``{``    ``vector<``int``> digit;` `    ``// Push all the digits of N from the end``    ``// one by one to the vector``    ``while` `(N != 0) {``        ``digit.push_back(N % 10);``        ``N = N / 10;``    ``}` `    ``// If the original number was 0``    ``if` `(digit.size() == 0)``        ``digit.push_back(0);` `    ``// Reverse the vector elements``    ``reverse(digit.begin(), digit.end());` `    ``// Return the required vector``    ``return` `digit;``}` `// Function to return the count of B length integers``// which are less than C and they``// contain digits from set A[] only``int` `solve(vector<``int``>& A, ``int` `B, ``int` `C)``{``    ``vector<``int``> digit;``    ``int` `d, d2;` `    ``// Convert number to digit array``    ``digit = numToVec(C);``    ``d = A.size();` `    ``// Case 1: No such number possible as the``    ``// generated numbers will always``    ``// be greater than C``    ``if` `(B > digit.size() || d == 0)``        ``return` `0;` `    ``// Case 2: All integers of length B are valid``    ``// as they all are less than C``    ``else` `if` `(B < digit.size()) {``        ``// contain 0``        ``if` `(A == 0 && B != 1)``            ``return` `(d - 1) * ``pow``(d, B - 1);``        ``else``            ``return` `pow``(d, B);``    ``}` `    ``// Case 3``    ``else` `{``        ``int` `dp[B + 1] = { 0 };``        ``int` `lower[MAX + 1] = { 0 };` `        ``// Update the lower[] array such that``        ``// lower[i] stores the count of elements``        ``// in A[] which are less than i``        ``for` `(``int` `i = 0; i < d; i++)``            ``lower[A[i] + 1] = 1;``        ``for` `(``int` `i = 1; i <= MAX; i++)``            ``lower[i] = lower[i - 1] + lower[i];` `        ``bool` `flag = ``true``;``        ``dp = 0;``        ``for` `(``int` `i = 1; i <= B; i++) {``            ``d2 = lower[digit[i - 1]];``            ``dp[i] = dp[i - 1] * d;` `            ``// For first index we can't use 0``            ``if` `(i == 1 && A == 0 && B != 1)``                ``d2 = d2 - 1;` `            ``// Whether (i-1) digit of generated number``            ``// can be equal to (i - 1) digit of C``            ``if` `(flag)``                ``dp[i] += d2;` `            ``// Is digit[i - 1] present in A ?``            ``flag = (flag & (lower[digit[i - 1] + 1]``                            ``== lower[digit[i - 1]] + 1));``        ``}``        ``return` `dp[B];``    ``}``}` `// Driver code``int` `main()``{` `    ``// Digits array``    ``vector<``int``> A = { 0, 1, 2, 5 };``    ``int` `N = 2;``    ``int` `k = 21;` `    ``cout << solve(A, N, k);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{``static` `int` `MAX = ``10``;` `// Function to convert a number into vector``static` `Vector numToVec(``int` `N)``{``    ``Vector digit = ``new` `Vector();` `    ``// Push all the digits of N from the end``    ``// one by one to the vector``    ``while` `(N != ``0``)``    ``{``        ``digit.add(N % ``10``);``        ``N = N / ``10``;``    ``}` `    ``// If the original number was 0``    ``if` `(digit.size() == ``0``)``        ``digit.add(``0``);` `    ``// Reverse the vector elements``    ``Collections.reverse(digit);` `    ``// Return the required vector``    ``return` `digit;``}` `// Function to return the count``// of B length integers which are``// less than C and they contain``// digits from set A[] only``static` `int` `solve(Vector A, ``int` `B, ``int` `C)``{``    ``Vector digit = ``new` `Vector();``    ``int` `d, d2;` `    ``// Convert number to digit array``    ``digit = numToVec(C);``    ``d = A.size();` `    ``// Case 1: No such number possible as the``    ``// generated numbers will always``    ``// be greater than C``    ``if` `(B > digit.size() || d == ``0``)``        ``return` `0``;` `    ``// Case 2: All integers of length B are valid``    ``// as they all are less than C``    ``else` `if` `(B < digit.size())``    ``{``        ``// contain 0``        ``if` `(A.get(``0``) == ``0` `&& B != ``1``)``            ``return` `(``int``) ((d - ``1``) * Math.pow(d, B - ``1``));``        ``else``            ``return` `(``int``) Math.pow(d, B);``    ``}` `    ``// Case 3``    ``else``    ``{``        ``int` `[]dp = ``new` `int``[B + ``1``];``        ``int` `[]lower = ``new` `int``[MAX + ``1``];` `        ``// Update the lower[] array such that``        ``// lower[i] stores the count of elements``        ``// in A[] which are less than i``        ``for` `(``int` `i = ``0``; i < d; i++)``            ``lower[A.get(i) + ``1``] = ``1``;``        ``for` `(``int` `i = ``1``; i <= MAX; i++)``            ``lower[i] = lower[i - ``1``] + lower[i];` `        ``boolean` `flag = ``true``;``        ``dp[``0``] = ``0``;``        ``for` `(``int` `i = ``1``; i <= B; i++)``        ``{``            ``d2 = lower[digit.get(i - ``1``)];``            ``dp[i] = dp[i - ``1``] * d;` `            ``// For first index we can't use 0``            ``if` `(i == ``1` `&& A.get(``0``) == ``0` `&& B != ``1``)``                ``d2 = d2 - ``1``;` `            ``// Whether (i-1) digit of generated number``            ``// can be equal to (i - 1) digit of C``            ``if` `(flag)``                ``dp[i] += d2;` `            ``// Is digit[i - 1] present in A ?``            ``flag = (flag & (lower[digit.get(i - ``1``) + ``1``] ==``                            ``lower[digit.get(i - ``1``)] + ``1``));``        ``}``        ``return` `dp[B];``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``Integer arr[] = { ``0``, ``1``, ``2``, ``5` `};``    ``// Digits array``    ``Vector A = ``new` `Vector<>(Arrays.asList(arr));``    ``int` `N = ``2``;``    ``int` `k = ``21``;` `    ``System.out.println(solve(A, N, k));``}``}` `// This code is contributed``// by PrinciRaj1992`

## Python3

 `# Python3 implementation of the approach``MAX``=``10` `# Function to convert a number into vector``def` `numToVec(N):``    ` `    ``digit ``=` `[]` `    ``# Push all the digits of N from the end``    ``# one by one to the vector``    ``while` `(N !``=` `0``):``        ``digit.append(N ``%` `10``)``        ``N ``=` `N ``/``/` `10` `    ``# If the original number was 0``    ``if` `(``len``(digit) ``=``=` `0``):``        ``digit.append(``0``)` `    ``# Reverse the vector elements``    ``digit ``=` `digit[::``-``1``]` `    ``# Return the required vector``    ``return` `digit`  `# Function to return the count of B length integers``# which are less than C and they``# contain digits from set A[] only``def` `solve(A, B, C):``    ``d, d2 ``=` `0``,``0` `    ``# Convert number to digit array``    ``digit ``=` `numToVec(C)``    ``d ``=` `len``(A)` `    ``# Case 1: No such number possible as the``    ``# generated numbers will always``    ``# be greater than C``    ``if` `(B > ``len``(digit) ``or` `d ``=``=` `0``):``        ``return` `0` `    ``# Case 2: All integers of length B are valid``    ``# as they all are less than C``    ``elif` `(B < ``len``(digit)):``        ``# contain 0``        ``if` `(A[``0``] ``=``=` `0` `and` `B !``=` `1``):``            ``return` `(d ``-` `1``) ``*` `pow``(d, B ``-` `1``)``        ``else``:``            ``return` `pow``(d, B)` `    ``# Case 3``    ``else` `:``        ``dp``=``[``0` `for` `i ``in` `range``(B ``+` `1``)]``        ``lower``=``[``0` `for` `i ``in` `range``(``MAX` `+` `1``)]` `        ``# Update the lower[] array such that``        ``# lower[i] stores the count of elements``        ``# in A[] which are less than i``        ``for` `i ``in` `range``(d):``            ``lower[A[i] ``+` `1``] ``=` `1``        ``for` `i ``in` `range``(``1``, ``MAX``+``1``):``            ``lower[i] ``=` `lower[i ``-` `1``] ``+` `lower[i]` `        ``flag ``=` `True``        ``dp[``0``] ``=` `0``        ``for` `i ``in` `range``(``1``, B``+``1``):``            ``d2 ``=` `lower[digit[i ``-` `1``]]``            ``dp[i] ``=` `dp[i ``-` `1``] ``*` `d` `            ``# For first index we can't use 0``            ``if` `(i ``=``=` `1` `and` `A[``0``] ``=``=` `0` `and` `B !``=` `1``):``                ``d2 ``=` `d2 ``-` `1` `            ``# Whether (i-1) digit of generated number``            ``# can be equal to (i - 1) digit of C``            ``if` `(flag):``                ``dp[i] ``+``=` `d2` `            ``# Is digit[i - 1] present in A ?``            ``flag ``=` `(flag & (lower[digit[i ``-` `1``] ``+` `1``] ``=``=` `lower[digit[i ``-` `1``]] ``+` `1``))``        ` `        ``return` `dp[B]` `# Driver code` `# Digits array``A ``=``[``0``, ``1``, ``2``, ``5``]``N ``=` `2``k ``=` `21` `print``(solve(A, N, k))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``static` `int` `MAX = 10;` `// Function to convert a number into vector``static` `List<``int``> numToVec(``int` `N)``{``    ``List<``int``> digit = ``new` `List<``int``>();` `    ``// Push all the digits of N from the end``    ``// one by one to the vector``    ``while` `(N != 0)``    ``{``        ``digit.Add(N % 10);``        ``N = N / 10;``    ``}` `    ``// If the original number was 0``    ``if` `(digit.Count == 0)``        ``digit.Add(0);` `    ``// Reverse the vector elements``    ``digit.Reverse();` `    ``// Return the required vector``    ``return` `digit;``}` `// Function to return the count``// of B length integers which are``// less than C and they contain``// digits from set A[] only``static` `int` `solve(List<``int``> A, ``int` `B, ``int` `C)``{``    ``List<``int``> digit = ``new` `List<``int``>();``    ``int` `d, d2;` `    ``// Convert number to digit array``    ``digit = numToVec(C);``    ``d = A.Count;` `    ``// Case 1: No such number possible as the``    ``// generated numbers will always``    ``// be greater than C``    ``if` `(B > digit.Count || d == 0)``        ``return` `0;` `    ``// Case 2: All integers of length B are valid``    ``// as they all are less than C``    ``else` `if` `(B < digit.Count)``    ``{``        ``// contain 0``        ``if` `(A == 0 && B != 1)``            ``return` `(``int``) ((d - 1) * Math.Pow(d, B - 1));``        ``else``            ``return` `(``int``) Math.Pow(d, B);``    ``}` `    ``// Case 3``    ``else``    ``{``        ``int` `[]dp = ``new` `int``[B + 1];``        ``int` `[]lower = ``new` `int``[MAX + 1];` `        ``// Update the lower[] array such that``        ``// lower[i] stores the count of elements``        ``// in A[] which are less than i``        ``for` `(``int` `i = 0; i < d; i++)``            ``lower[A[i] + 1] = 1;``        ``for` `(``int` `i = 1; i <= MAX; i++)``            ``lower[i] = lower[i - 1] + lower[i];` `        ``Boolean flag = ``true``;``        ``dp = 0;``        ``for` `(``int` `i = 1; i <= B; i++)``        ``{``            ``d2 = lower[digit[i-1]];``            ``dp[i] = dp[i - 1] * d;` `            ``// For first index we can't use 0``            ``if` `(i == 1 && A == 0 && B != 1)``                ``d2 = d2 - 1;` `            ``// Whether (i-1) digit of generated number``            ``// can be equal to (i - 1) digit of C``            ``if` `(flag)``                ``dp[i] += d2;` `            ``// Is digit[i - 1] present in A ?``            ``flag = (flag & (lower[digit[i-1] + 1] ==``                            ``lower[digit[i-1]] + 1));``        ``}``        ``return` `dp[B];``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 0, 1, 2, 5 };``    ` `    ``// Digits array``    ``List<``int``> A = ``new` `List<``int``>(arr);``    ``int` `N = 2;``    ``int` `k = 21;` `    ``Console.WriteLine(solve(A, N, k));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`5`

Time complexity: O(N)
Auxiliary Space: O(N), since N extra space has been taken.

My Personal Notes arrow_drop_up