Count n digit numbers not having a particular digit

• Last Updated : 06 Aug, 2021

We are given two integers n and d, we need to count all n digit numbers that do not have digit d.

Example :

```Input : n = 2, d = 7
Output : 72
All two digit numbers that don't have
7 as digit are 10, 11, 12, 13, 14, 15,
16, 18, .....

Input : n = 3, d = 9
Output : 648
```

A simple solution is to traverse through all d digit numbers. For every number, check if it has x as digit or not.

Efficient approach In this method, we check first if excluding digit d is zero or non-zero. If it is zero then, we have 9 numbers (1 to 9) as first number otherwise we have 8 numbers(excluding x digit and 0). Then for all other digits, we have 9 choices i.e (0 to 9 excluding d digit). We simple call digitNumber function with n-1 digits as first number we already find it can be 8 or 9 and simple multiply it. For other numbers we check if digits are odd or even if it is odd we call digitNumber function with (n-1)/2 digits and multiply it by 9 otherwise we call digitNumber function with n/2 digits and store them in result and take result square.

Illustration :

```Number from 1 to 7 excluding digit 9.
digits      multiple          number
1           8                   8
2           8*9                 72
3           8*9*9               648
4           8*9*9*9             5832
5           8*9*9*9*9           52488
6           8*9*9*9*9*9         472392
7           8*9*9*9*9*9*9       4251528```

As we can see, in each step we are half the number of digits. Suppose we have 7 digits in this we call function from main with 6(7-1) digits. when we half the digits we left with 3(6/2) digits. Because of this we have to multiply result due to 3 digits with itself to get result for 6 digits. Similarly for 3 digits we have odd digits, we have odd digits. We find result with 1 ((3-1)/2) digits and find result square and multiply it with 9, because we find result for d-1 digits.

C++

 `// C++ Implementation of above method``#include ``#define mod 1000000007``using` `namespace` `std;` `// Finding number of possible number with``// n digits excluding a particular digit``long` `long` `digitNumber(``long` `long` `n) {` `  ``// Checking if number of digits is zero``  ``if` `(n == 0)``    ``return` `1;` `  ``// Checking if number of digits is one``  ``if` `(n == 1)``    ``return` `9;` `  ``// Checking if number of digits is odd``  ``if` `(n % 2) {` `    ``// Calling digitNumber function``    ``// with (digit-1)/2 digits``    ``long` `long` `temp = digitNumber((n - 1) / 2) % mod;``    ``return` `(9 * (temp * temp) % mod) % mod;``  ``} ``else` `{` `    ``// Calling digitNumber function``    ``// with n/2 digits``    ``long` `long` `temp = digitNumber(n / 2) % mod;``    ``return` `(temp * temp) % mod;``  ``}``}` `int` `countExcluding(``int` `n, ``int` `d)``{``  ``// Calling digitNumber function``  ``// Checking if excluding digit is``  ``// zero or non-zero``  ``if` `(d == 0)``    ``return` `(9 * digitNumber(n - 1)) % mod;``  ``else``    ``return` `(8 * digitNumber(n - 1)) % mod;``}` `// Driver function to run above program``int` `main() {` `  ``// Initializing variables``  ``long` `long` `d = 9;``  ``int` `n = 3;``  ``cout << countExcluding(n, d) << endl;``  ``return` `0;``}`

Java

 `// Java Implementation of above method``import` `java.lang.*;` `class` `GFG {``    ` `static` `final` `int` `mod = ``1000000007``;` `// Finding number of possible number with``// n digits excluding a particular digit``static` `int` `digitNumber(``long` `n) {` `    ``// Checking if number of digits is zero``    ``if` `(n == ``0``)``    ``return` `1``;` `    ``// Checking if number of digits is one``    ``if` `(n == ``1``)``    ``return` `9``;` `    ``// Checking if number of digits is odd``    ``if` `(n % ``2` `!= ``0``) {` `    ``// Calling digitNumber function``    ``// with (digit-1)/2 digits``    ``int` `temp = digitNumber((n - ``1``) / ``2``) % mod;``    ` `    ``return` `(``9` `* (temp * temp) % mod) % mod;``    ``}``    ``else` `{` `    ``// Calling digitNumber function``    ``// with n/2 digits``    ``int` `temp = digitNumber(n / ``2``) % mod;``    ` `    ``return` `(temp * temp) % mod;``    ``}``}` `static` `int` `countExcluding(``int` `n, ``int` `d) {``    ` `    ``// Calling digitNumber function``    ``// Checking if excluding digit is``    ``// zero or non-zero``    ``if` `(d == ``0``)``    ``return` `(``9` `* digitNumber(n - ``1``)) % mod;``    ``else``    ``return` `(``8` `* digitNumber(n - ``1``)) % mod;``}` `// Driver function to run above program``public` `static` `void` `main(String[] args) {``    ` `    ``// Initializing variables``    ``int` `d = ``9``;``    ``int` `n = ``3``;``    ``System.out.println(countExcluding(n, d));``}``}` `// This code is contributed by Anant Agarwal.`

Python3

 `# Python Implementation``# of above method` `mod``=``1000000007` `# Finding number of``# possible number with``# n digits excluding``# a particular digit``def` `digitNumber(n):` `    ``# Checking if number``    ``# of digits is zero``    ``if` `(n ``=``=` `0``):``        ``return` `1`` ` `    ``# Checking if number``    ``# of digits is one``    ``if` `(n ``=``=` `1``):``        ``return` `9`` ` `    ``# Checking if number``    ``# of digits is odd``    ``if` `(n ``%` `2``!``=``0``):`` ` `        ``# Calling digitNumber function``        ``# with (digit-1)/2 digits``        ``temp ``=` `digitNumber((n ``-` `1``) ``/``/` `2``) ``%` `mod``        ``return` `(``9` `*` `(temp ``*` `temp) ``%` `mod) ``%` `mod``    ``else``:`` ` `        ``# Calling digitNumber function``        ``# with n/2 digits``        ``temp ``=` `digitNumber(n ``/``/` `2``) ``%` `mod``        ``return` `(temp ``*` `temp) ``%` `mod`` ` `def` `countExcluding(n,d):` `    ``# Calling digitNumber function``    ``# Checking if excluding digit is``    ``# zero or non-zero``    ``if` `(d ``=``=` `0``):``        ``return` `(``9` `*` `digitNumber(n ``-` `1``)) ``%` `mod``    ``else``:``        ``return` `(``8` `*` `digitNumber(n ``-` `1``)) ``%` `mod``    ` `# Driver code` `d ``=` `9``n ``=` `3``print``(countExcluding(n, d))` `# This code is contributed``# by Anant Agarwal.`

C#

 `// C# Implementation of above method``using` `System;` `class` `GFG {``    ` `    ``static` `int` `mod = 1000000007;``    ` `    ``// Finding number of possible number with``    ``// n digits excluding a particular digit``    ``static` `int` `digitNumber(``long` `n) {``    ` `        ``// Checking if number of digits is zero``        ``if` `(n == 0)``            ``return` `1;``    ` `        ``// Checking if number of digits is one``        ``if` `(n == 1)``            ``return` `9;``    ` `        ``// Checking if number of digits is odd``        ``if` `(n % 2 != 0) {``    ` `            ``// Calling digitNumber function``            ``// with (digit-1)/2 digits``            ``int` `temp = digitNumber((n - 1) / 2) % mod;``            ` `            ``return` `(9 * (temp * temp) % mod) % mod;``        ``}``        ``else` `{``    ` `            ``// Calling digitNumber function``            ``// with n/2 digits``            ``int` `temp = digitNumber(n / 2) % mod;``            ` `            ``return` `(temp * temp) % mod;``        ``}``    ``}``    ` `    ``static` `int` `countExcluding(``int` `n, ``int` `d) {``        ` `        ``// Calling digitNumber function``        ``// Checking if excluding digit is``        ``// zero or non-zero``        ``if` `(d == 0)``            ``return` `(9 * digitNumber(n - 1)) % mod;``        ``else``            ``return` `(8 * digitNumber(n - 1)) % mod;``    ``}``    ` `    ``// Driver function to run above program``    ``public` `static` `void` `Main() {``        ` `        ``// Initializing variables``        ``int` `d = 9;``        ``int` `n = 3;``        ` `        ``Console.WriteLine(countExcluding(n, d));``    ``}``}` `// This code is contributed by vt_m.`

PHP

 ``

Javascript

 ``
Output:
`648`

Time Complexity : O(log n).

My Personal Notes arrow_drop_up