# Count of N digit Numbers having no pair of equal consecutive Digits

Given an integer N, the task is to find the total count of N digit numbers such that no two consecutive digits are equal.

Examples:

Input: N = 2
Output: 81
Explanation:
Count possible 2-digit numbers, i.e. the numbers in the range [10, 99] = 90
All 2-digit numbers having equal consecutive digits are {11, 22, 33, 44, 55, 66, 77, 88, 99}.
Therefore, the required count = 90 – 9 = 81

Input: N = 1
Output: 10

Naive Approach: The simplest approach to solve the problem is to iterate over all possible N-digit numbers and check for every number if any two consecutive digits are equal or not.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach` `#include` `using` `namespace` `std;`   `// Function to count the number` `// of N-digit numbers with no` `// equal pair of consecutive digits` `void` `count(``int` `N)` `{` `    `  `    ``// Base Case` `    ``if` `(N == 1)` `    ``{` `        ``cout << 10 << endl;` `        ``return``;` `    ``}`   `    ``// Lowest N-digit number` `    ``int` `l = ``pow``(10, N - 1);`   `    ``// Highest N-digit number` `    ``int` `r = ``pow``(10, N) - 1;`   `    ``// Stores the count of all` `    ``// required numbers` `    ``int` `ans = 0;`   `    ``// Iterate over all N-digit numbers` `    ``for``(``int` `i = l; i <= r; i++) ` `    ``{` `        ``string s = to_string(i);` `        ``int` `flag = 0;`   `        ``// Iterate over all digits` `        ``for``(``int` `j = 1; j < N; j++)` `        ``{` `            `  `            ``// Check for equal pair of` `            ``// adjacent digits` `            ``if` `(s[j] == s[j - 1])` `            ``{` `                ``flag = 1;` `                ``break``;` `            ``}` `        ``}` `        ``if` `(flag == 0)` `            ``ans++;` `    ``}` `    ``cout << ans << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 2;` `    `  `    ``count(N);` `    ``return` `0;` `}`   `// This code is contributed by rutvik_56`

## Java

 `// Java Program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG {`   `    ``// Function to count the number` `    ``// of N-digit numbers with no` `    ``// equal pair of consecutive digits` `    ``public` `static` `void` `count(``int` `N)` `    ``{`   `        ``// Base Case` `        ``if` `(N == ``1``) {` `            ``System.out.println(``10``);` `            ``return``;` `        ``}`   `        ``// Lowest N-digit number` `        ``int` `l = (``int``)Math.pow(``10``, N - ``1``);`   `        ``// Highest N-digit number` `        ``int` `r = (``int``)Math.pow(``10``, N) - ``1``;`   `        ``// Stores the count of all` `        ``// required numbers` `        ``int` `ans = ``0``;`   `        ``// Iterate over all N-digit numbers` `        ``for` `(``int` `i = l; i <= r; i++) {` `            ``String s = Integer.toString(i);` `            ``int` `flag = ``0``;`   `            ``// Iterate over all digits` `            ``for` `(``int` `j = ``1``; j < N; j++) {`   `                ``// Check for equal pair of` `                ``// adjacent digits` `                ``if` `(s.charAt(j) == s.charAt(j - ``1``)) {` `                    ``flag = ``1``;` `                    ``break``;` `                ``}` `            ``}` `            ``if` `(flag == ``0``)` `                ``ans++;` `        ``}` `        ``System.out.println(ans);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``2``;` `        ``count(N);` `    ``}` `}`

## Python3

 `# Python3 Program to implement` `# the above approach`   `# Function to count the number` `# of N-digit numbers with no` `# equal pair of consecutive digits` `def` `count(N):`   `    ``# Base Case` `    ``if` `(N ``=``=` `1``):` `        ``print``(``10``);` `        ``return``;` `    `  `    ``# Lowest N-digit number` `    ``l ``=` `int``(``pow``(``10``, N ``-` `1``));`   `    ``# Highest N-digit number` `    ``r ``=` `int``(``pow``(``10``, N) ``-` `1``);`   `    ``# Stores the count of all` `    ``# required numbers` `    ``ans ``=` `0``;`   `    ``# Iterate over all N-digit numbers` `    ``for` `i ``in` `range``(l, r ``+` `1``):` `        ``s ``=` `str``(i);` `        ``flag ``=` `0``;`   `        ``# Iterate over all digits` `        ``for` `j ``in` `range``(``1``, N):`   `            ``# Check for equal pair of` `            ``# adjacent digits` `            ``if` `(s[j] ``=``=` `s[j ``-` `1``]):` `                ``flag ``=` `1``;` `                ``break``;` `            `  `        ``if` `(flag ``=``=` `0``):` `            ``ans``+``=``1``;` `    `  `    ``print``(ans);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `2``;` `    ``count(N);`   `# This code is contributed by sapnasingh4991`

## C#

 `// C# program to implement` `// the above approach` `using` `System;`   `class` `GFG{`   `// Function to count the number` `// of N-digit numbers with no` `// equal pair of consecutive digits` `public` `static` `void` `count(``int` `N)` `{` `    `  `    ``// Base Case` `    ``if` `(N == 1)` `    ``{` `        ``Console.WriteLine(10);` `        ``return``;` `    ``}`   `    ``// Lowest N-digit number` `    ``int` `l = (``int``)Math.Pow(10, N - 1);`   `    ``// Highest N-digit number` `    ``int` `r = (``int``)Math.Pow(10, N) - 1;`   `    ``// Stores the count of all` `    ``// required numbers` `    ``int` `ans = 0;`   `    ``// Iterate over all N-digit numbers` `    ``for``(``int` `i = l; i <= r; i++) ` `    ``{` `        ``String s = i.ToString();` `        ``int` `flag = 0;`   `        ``// Iterate over all digits` `        ``for``(``int` `j = 1; j < N; j++)` `        ``{`   `            ``// Check for equal pair of` `            ``// adjacent digits` `            ``if` `(s[j] == s[j - 1]) ` `            ``{` `                ``flag = 1;` `                ``break``;` `            ``}` `        ``}` `        ``if` `(flag == 0)` `            ``ans++;` `    ``}` `    ``Console.WriteLine(ans);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 2;` `    ``count(N);` `}` `}`   `// This code is contributed by Princi Singh`

Output:

```81

```

Time Complexity: O(N * (10N), where N is the given integer.
Auxiliary Space: O(1)

Dynamic Programming Approach: The above approach can be optimized using Dynamic Programming approach. Follow the steps below to solve the problem:

• Initialize DP[][], where DP[i][j] stores the count of numbers having i digits, and ending with j.
• Iterate from 2 to N and follow the steps:
• Calculate the total count of valid i-1 digit numbers by adding all the values of DP[i-1][j] where j ranges from 0 to 9, and store it in temp.
• Update DP[i][j] = temp – DP[i-1][j], where j ranges from 0 to 9.
• The result is the sum of DP[N][j], where j ranges from 0 to 9

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include` `using` `namespace` `std;`   `// Function to count the number` `// of N-digit numbers with no` `// equal pair of consecutive digits` `void` `count(``int` `N)` `{`   `   ``// Base Case` `   ``if` `(N == 1) ` `   ``{` `     ``cout << (10) << endl;` `     ``return``;` `   ``}`   `  ``int` `dp[N];` `  ``memset``(dp, 0, ``sizeof``(dp));` `  ``for` `(``int` `i = 1; i < 10; i++)` `    ``dp[i] = 1;` `  ``for` `(``int` `i = 1; i < N; i++) ` `  ``{`   `    ``// Calculate the total count` `    ``// of valid (i-1)-digit numbers` `    ``int` `temp = 0;` `    ``for` `(``int` `j = 0; j < 10; j++)` `      ``temp += dp[i - 1][j];`   `    ``// Update dp[][] table` `    ``for` `(``int` `j = 0; j < 10; j++)` `      ``dp[i][j] = temp - dp[i - 1][j];` `  ``}`   `  ``// Calculate the count of` `  ``// required N-digit numbers` `  ``int` `ans = 0;` `  ``for` `(``int` `i = 0; i < 10; i++)` `    ``ans += dp[N - 1][i];` `  ``cout << ans << endl;` `}`   `// Driver Code` `int` `main()` `{` `  ``int` `N = 2;` `  ``count(N);` `  ``return` `0;` `}`   `// This code is contributed by sapnasingh4991`

## Java

 `// Java Program to implement` `// of the above approach` `import` `java.util.*;` `class` `GFG {`   `    ``// Function to count the number` `    ``// of N-digit numbers with no` `    ``// equal pair of consecutive digits` `    ``public` `static` `void` `count(``int` `N)` `    ``{`   `        ``// Base Case` `        ``if` `(N == ``1``) {` `            ``System.out.println(``10``);` `            ``return``;` `        ``}`   `        ``int` `dp[][] = ``new` `int``[N][``10``];`   `        ``for` `(``int` `i = ``1``; i < ``10``; i++)` `            ``dp[``0``][i] = ``1``;` `        ``for` `(``int` `i = ``1``; i < N; i++) {`   `            ``// Calculate the total count` `            ``// of valid (i-1)-digit numbers` `            ``int` `temp = ``0``;` `            ``for` `(``int` `j = ``0``; j < ``10``; j++)` `                ``temp += dp[i - ``1``][j];`   `            ``// Update dp[][] table` `            ``for` `(``int` `j = ``0``; j < ``10``; j++)` `                ``dp[i][j] = temp - dp[i - ``1``][j];` `        ``}`   `        ``// Calculate the count of` `        ``// required N-digit numbers` `        ``int` `ans = ``0``;` `        ``for` `(``int` `i = ``0``; i < ``10``; i++)` `            ``ans += dp[N - ``1``][i];` `        ``System.out.println(ans);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``2``;` `        ``count(N);` `    ``}` `}`

## Python3

 `# Python3 Program to implement` `# of the above approach`   `# Function to count the number` `# of N-digit numbers with no` `# equal pair of consecutive digits` `def` `count(N):` `  `  `    ``# Base Case` `    ``if` `(N ``=``=` `1``):` `        ``print``(``10``);` `        ``return``;`   `    ``dp ``=` `[[``0` `for` `i ``in` `range``(``10``)] ` `             ``for` `j ``in` `range``(N)]`   `    ``for` `i ``in` `range``(``1``,``10``):` `        ``dp[``0``][i] ``=` `1``;` `    ``for` `i ``in` `range``(``1``, N):`   `        ``# Calculate the total count` `        ``# of valid (i-1)-digit numbers` `        ``temp ``=` `0``;` `        ``for` `j ``in` `range``(``10``):` `            ``temp ``+``=` `dp[i ``-` `1``][j];`   `        ``# Update dp table` `        ``for` `j ``in` `range``(``10``):` `            ``dp[i][j] ``=` `temp ``-` `dp[i ``-` `1``][j];`   `    ``# Calculate the count of` `    ``# required N-digit numbers` `    ``ans ``=` `0``;` `    ``for` `i ``in` `range``(``10``):` `        ``ans ``+``=` `dp[N ``-` `1``][i];` `    ``print``(ans);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `2``;` `    ``count(N);`   `# This code is contributed by Amit Katiyar`

## C#

 `// C# Program to implement` `// of the above approach` `using` `System;` `class` `GFG{`   `  ``// Function to count the number` `  ``// of N-digit numbers with no` `  ``// equal pair of consecutive digits` `  ``public` `static` `void` `count(``int` `N)` `  ``{`   `    ``// Base Case` `    ``if` `(N == 1)` `    ``{` `      ``Console.WriteLine(10);` `      ``return``;` `    ``}`   `    ``int` `[,]dp = ``new` `int``[N, 10];`   `    ``for` `(``int` `i = 1; i < 10; i++)` `      ``dp[0, i] = 1;` `    ``for` `(``int` `i = 1; i < N; i++)` `    ``{`   `      ``// Calculate the total count` `      ``// of valid (i-1)-digit numbers` `      ``int` `temp = 0;` `      ``for` `(``int` `j = 0; j < 10; j++)` `        ``temp += dp[i - 1, j];`   `      ``// Update [,]dp table` `      ``for` `(``int` `j = 0; j < 10; j++)` `        ``dp[i, j] = temp - dp[i - 1, j];` `    ``}`   `    ``// Calculate the count of` `    ``// required N-digit numbers` `    ``int` `ans = 0;` `    ``for` `(``int` `i = 0; i < 10; i++)` `      ``ans += dp[N - 1, i];` `    ``Console.WriteLine(ans);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `N = 2;` `    ``count(N);` `  ``}` `}`   `// This code is contributed by sapnasingh4991`

Output:

```81

```

Time Complexity: O(N), where N is the given integer
Auxiliary Space: O(N)

Efficient Approach: The above approach can be further optimized by observing that for any N digit number, the required answer is 9N which can be calculated using Binary Exponentiation.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Iterative Function to calculate` `// (x^y) % mod in O(log y)` `int` `power(``int` `x, ``int` `y, ``int` `mod)` `{` `    ``// Initialize result` `    ``int` `res = 1;`   `    ``// Update x if x >= mod` `    ``x = x % mod;`   `    ``// If x is divisible by mod` `    ``if` `(x == 0)` `        ``return` `0;`   `    ``while` `(y > 0)` `    ``{`   `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `((y & 1) == 1)` `            ``res = (res * x) % mod;`   `        ``// y must be even now` `        ``// y = y / 2` `        ``y = y >> 1;` `        ``x = (x * x) % mod;` `    ``}` `    ``return` `res;` `}`   `// Function to count the number` `// of N-digit numbers with no` `// equal pair of consecutive digits` `void` `count(``int` `N)` `{`   `    ``// Base Case` `    ``if` `(N == 1) ` `    ``{` `        ``cout << 10 << endl;` `        ``return``;` `    ``}`   `    ``cout << (power(9, N, 1000000007)) << endl;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 3;` `    ``count(N);` `    ``return` `0;` `}`   `// This code is contributed by sapnasingh4991`

## Java

 `// Java Program to implement` `// of the above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``// Iterative Function to calculate` `    ``// (x^y) % mod in O(log y)` `    ``static` `int` `power(``int` `x, ``int` `y, ``int` `mod)` `    ``{` `        ``// Initialize result` `        ``int` `res = ``1``;`   `        ``// Update x if x >= mod` `        ``x = x % mod;`   `        ``// If x is divisible by mod` `        ``if` `(x == ``0``)` `            ``return` `0``;`   `        ``while` `(y > ``0``) {`   `            ``// If y is odd, multiply x` `            ``// with result` `            ``if` `((y & ``1``) == ``1``)` `                ``res = (res * x) % mod;`   `            ``// y must be even now` `            ``// y = y / 2` `            ``y = y >> ``1``;` `            ``x = (x * x) % mod;` `        ``}` `        ``return` `res;` `    ``}`   `    ``// Function to count the number` `    ``// of N-digit numbers with no` `    ``// equal pair of consecutive digits` `    ``public` `static` `void` `count(``int` `N)` `    ``{`   `        ``// Base Case` `        ``if` `(N == ``1``) {` `            ``System.out.println(``10``);` `            ``return``;` `        ``}`   `        ``System.out.println(power(``9``, N,` `                                 ``1000000007``));` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `N = ``3``;` `        ``count(N);` `    ``}` `}`

## Python3

 `# Python3 Program to implement` `# of the above approach`   `# Iterative Function to calculate` `# (x^y) % mod in O(log y)` `def` `power(x, y, mod):` `  `  `    ``# Initialize result` `    ``res ``=` `1``;`   `    ``# Update x if x >= mod` `    ``x ``=` `x ``%` `mod;`   `    ``# If x is divisible by mod` `    ``if` `(x ``=``=` `0``):` `        ``return` `0``;`   `    ``while` `(y > ``0``):`   `        ``# If y is odd, multiply x` `        ``# with result` `        ``if` `((y & ``1``) ``=``=` `1``):` `            ``res ``=` `(res ``*` `x) ``%` `mod;`   `        ``# y must be even now` `        ``# y = y / 2` `        ``y ``=` `y >> ``1``;` `        ``x ``=` `(x ``*` `x) ``%` `mod;`   `    ``return` `res;`   `# Function to count the number` `# of N-digit numbers with no` `# equal pair of consecutive digits` `def` `count(N):` `  `  `    ``# Base Case` `    ``if` `(N ``=``=` `1``):` `        ``print``(``10``);` `        ``return``;`   `    ``print``(power(``9``, N, ``1000000007``));`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `3``;` `    ``count(N);`   `# This code is contributed by Rohit_ranjan`

## C#

 `// C# program to implement` `// of the above approach` `using` `System;`   `class` `GFG{`   `// Iterative Function to calculate` `// (x^y) % mod in O(log y)` `static` `int` `power(``int` `x, ``int` `y, ``int` `mod)` `{` `    `  `    ``// Initialize result` `    ``int` `res = 1;`   `    ``// Update x if x >= mod` `    ``x = x % mod;`   `    ``// If x is divisible by mod` `    ``if` `(x == 0)` `        ``return` `0;`   `    ``while` `(y > 0)` `    ``{` `        `  `        ``// If y is odd, multiply x` `        ``// with result` `        ``if` `((y & 1) == 1)` `            ``res = (res * x) % mod;`   `        ``// y must be even now` `        ``// y = y / 2` `        ``y = y >> 1;` `        ``x = (x * x) % mod;` `    ``}` `    ``return` `res;` `}`   `// Function to count the number` `// of N-digit numbers with no` `// equal pair of consecutive digits` `public` `static` `void` `count(``int` `N)` `{`   `    ``// Base Case` `    ``if` `(N == 1) ` `    ``{` `        ``Console.WriteLine(10);` `        ``return``;` `    ``}`   `    ``Console.WriteLine(power(9, N,` `                            ``1000000007));` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `N = 3;` `    ``count(N);` `}` `}`   `// This code is contributed by 29AjayKumar`

Output:

```729

```

Time Complexity: O(logN)
Space Complexity: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.