Skip to content

Count of N-digit numbers having digit XOR as single digit

• Difficulty Level : Medium
• Last Updated : 23 Nov, 2021

Given an integer N, the task is to find the total count of N-Digit numbers such that the Bitwise XOR of the digits of the numbers is a single digit.

Examples:

Input: N = 1
Output: 9
Explanation:
1, 2, 3, 4, 5, 6, 7, 8, 9 are the numbers.

Input: N = 2
Output: 66
Explanation:
There are 66 such 2-digit numbers whose Xor of digits is a single digit number.

Approach: The naive approach will be to iterate over all the N-digit numbers and check if the Bitwise XOR of all the digits of the number is a single digit. If yes then include this in the count, otherwise, check for the next number.

Below is the implementation of the above approach:

C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; `   `// Function to find count of N-digit ` `// numbers with single digit XOR ` `void` `countNums(``int` `N) ` `{ ` `    `  `    ``// Range of numbers ` `    ``int` `l = (``int``)``pow``(10, N - 1); ` `    ``int` `r = (``int``)``pow``(10, N) - 1; `   `    ``int` `count = 0; ` `    ``for``(``int` `i = l; i <= r; i++) ` `    ``{ ` `        ``int` `xorr = 0, temp = i; `   `        ``// Calculate XOR of digits ` `        ``while` `(temp > 0)` `        ``{ ` `            ``xorr = xorr ^ (temp % 10); ` `            ``temp /= 10; ` `        ``} `   `        ``// If XOR <= 9, ` `        ``// then increment count ` `        ``if` `(xorr <= 9) ` `            ``count++; ` `    ``} ` `    `  `    ``// Print the count ` `    ``cout << count; ` `} `   `// Driver Code ` `int` `main()` `{ ` `    `  `    ``// Given number ` `    ``int` `N = 2; `   `    ``// Function call ` `    ``countNums(N); ` `} `   `// This code is contributed by code_hunt `

Java

 `// Java program for the above approach `   `class` `GFG { `   `    ``// Function to find count of N-digit ` `    ``// numbers with single digit XOR ` `    ``public` `static` `void` `countNums(``int` `N) ` `    ``{ ` `        ``// Range of numbers ` `        ``int` `l = (``int``)Math.pow(``10``, N - ``1``), ` `            ``r = (``int``)Math.pow(``10``, N) - ``1``; `   `        ``int` `count = ``0``; `   `        ``for` `(``int` `i = l; i <= r; i++) { ` `            ``int` `xor = ``0``, temp = i; `   `            ``// Calculate XOR of digits ` `            ``while` `(temp > ``0``) { ` `                ``xor = xor ^ (temp % ``10``); ` `                ``temp /= ``10``; ` `            ``} `   `            ``// If XOR <= 9, ` `            ``// then increment count ` `            ``if` `(xor <= ``9``) ` `                ``count++; ` `        ``} `   `        ``// Print the count ` `        ``System.out.println(count); ` `    ``} `   `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given Number ` `        ``int` `N = ``2``; `   `        ``// Function Call ` `        ``countNums(N); ` `    ``} ` `}`

Python3

 `# Python3 program for the above approach `   `# Function to find count of N-digit ` `# numbers with single digit XOR ` `def` `countNums(N): ` `    `  `    ``# Range of numbers ` `    ``l ``=` `pow``(``10``, N ``-` `1``) ` `    ``r ``=` `pow``(``10``, N) ``-` `1`   `    ``count ``=` `0` `    ``for` `i ``in` `range``(l, r ``+` `1``): ` `        ``xorr ``=` `0` `        ``temp ``=` `i `   `        ``# Calculate XOR of digits ` `        ``while` `(temp > ``0``): ` `            ``xorr ``=` `xorr ^ (temp ``%` `10``) ` `            ``temp ``/``/``=` `10` `        `  `        ``# If XOR <= 9, ` `        ``# then increment count ` `        ``if` `(xorr <``=` `9``):` `            ``count ``+``=` `1` `        `  `    ``# Print the count ` `    ``print``(count)`   `# Driver Code `   `# Given number ` `N ``=` `2`   `# Function call ` `countNums(N) `   `# This code is contributed by code_hunt `

C#

 `// C# program for the above approach ` `using` `System;`   `class` `GFG{ `   `// Function to find count of N-digit ` `// numbers with single digit XOR ` `public` `static` `void` `countNums(``int` `N) ` `{ ` `    `  `    ``// Range of numbers ` `    ``int` `l = (``int``)Math.Pow(10, N - 1), ` `        ``r = (``int``)Math.Pow(10, N) - 1; `   `    ``int` `count = 0; `   `    ``for``(``int` `i = l; i <= r; i++)` `    ``{ ` `        ``int` `xor = 0, temp = i; `   `        ``// Calculate XOR of digits ` `        ``while` `(temp > 0)` `        ``{ ` `            ``xor = xor ^ (temp % 10); ` `            ``temp /= 10; ` `        ``} `   `        ``// If XOR <= 9, ` `        ``// then increment count ` `        ``if` `(xor <= 9) ` `            ``count++; ` `    ``} `   `    ``// Print the count ` `    ``Console.WriteLine(count); ` `} `   `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    `  `    ``// Given number ` `    ``int` `N = 2; `   `    ``// Function call ` `    ``countNums(N); ` `} ` `}`   `// This code is contributed by code_hunt `

Javascript

 ``

Output:

`66`

Time Complexity: O(N*10N)
Auxiliary Space: O(1)

Efficient Approach: The idea is to use Dynamic Programming. Observe that the maximum Bitwise XOR that can be obtained is 15.

1. Create a table dp[][], where dp[i][j] stores the count of i-digit numbers such that their XOR is j.
2. Initialize the dp[][] for i = 1 and for each i form 2 to N iterate for every digit j from 0 to 9.
3. For every possible previous XOR k from 0 to 15, find the value by doing XOR of previous XOR k and the digit j, and increment the count of dp[i][value] by dp[i – 1][k].
4. The total count of N-digit numbers with a single-digit XOR can be found by summing the dp[N][j] where j ranges from 0 to 9.

Below is the implementation of the above approach:

C++

 `// C++ program for ` `// the above approach ` `#include` `using` `namespace` `std;`   `// Function to find ` `// count of N-digit ` `// numbers with single ` `// digit XOR ` `void` `countNums(``int` `N) ` `{  ` `  ``// dp[i][j] stores the number ` `  ``// of i-digit numbers with ` `  ``// XOR equal to j ` `  ``int` `dp[N][16]; ` `  ``memset``(dp, 0, ` `         ``sizeof``(dp[0][0]) * ` `                ``N * 16);`   `  ``// For 1-9 store the value ` `  ``for` `(``int` `i = 1; i <= 9; i++) ` `    ``dp[0][i] = 1; `   `  ``// Iterate till N ` `  ``for` `(``int` `i = 1; i < N; i++) ` `  ``{` `    ``for` `(``int` `j = 0; j < 10; j++) ` `    ``{` `      ``for` `(``int` `k = 0; k < 16; k++) ` `      ``{` `        ``// Calculate XOR ` `        ``int` `xo = j ^ k; `   `        ``// Store in DP table ` `        ``dp[i][xo] += dp[i - 1][k]; ` `      ``} ` `    ``} ` `  ``} `   `  ``// Initialize count ` `  ``int` `count = 0; ` `  ``for` `(``int` `i = 0; i < 10; i++) ` `    ``count += dp[N - 1][i]; `   `  ``// Print the answer ` `  ``cout << (count) << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `  ``// Given number N ` `  ``int` `N = 1; `   `  ``// Function Call ` `  ``countNums(N); ` `} `   `// This code is contributed by Chitranayal`

Java

 `// Java program for the above approach `   `class` `GFG { `   `    ``// Function to find count of N-digit ` `    ``// numbers with single digit XOR ` `    ``public` `static` `void` `countNums(``int` `N) ` `    ``{ `   `        ``// dp[i][j] stores the number ` `        ``// of i-digit numbers with ` `        ``// XOR equal to j ` `        ``int` `dp[][] = ``new` `int``[N][``16``]; `   `        ``// For 1-9 store the value ` `        ``for` `(``int` `i = ``1``; i <= ``9``; i++) ` `            ``dp[``0``][i] = ``1``; `   `        ``// Iterate till N ` `        ``for` `(``int` `i = ``1``; i < N; i++) { `   `            ``for` `(``int` `j = ``0``; j < ``10``; j++) { `   `                ``for` `(``int` `k = ``0``; k < ``16``; k++) { `   `                    ``// Calculate XOR ` `                    ``int` `xor = j ^ k; `   `                    ``// Store in DP table ` `                    ``dp[i][xor] += dp[i - ``1``][k]; ` `                ``} ` `            ``} ` `        ``} `   `        ``// Initialize count ` `        ``int` `count = ``0``; ` `        ``for` `(``int` `i = ``0``; i < ``10``; i++) ` `            ``count += dp[N - ``1``][i]; `   `        ``// Print the answer ` `        ``System.out.println(count); ` `    ``} `   `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given number N ` `        ``int` `N = ``1``; `   `        ``// Function Call ` `        ``countNums(N); ` `    ``} ` `}`

Python3

 `# Python3 program for the` `# above approach`   `# Function to find count of ` `# N-digit numbers with single` `# digit XOR` `def` `countNums(N):` `  `  `    ``# dp[i][j] stores the number` `    ``# of i-digit numbers with` `    ``# XOR equal to j` `    ``dp ``=` `[[``0` `for` `i ``in` `range``(``16``)] ` `             ``for` `j ``in` `range``(N)];`   `    ``# For 1-9 store the value` `    ``for` `i ``in` `range``(``1``, ``10``):` `        ``dp[``0``][i] ``=` `1``;`   `    ``# Iterate till N` `    ``for` `i ``in` `range``(``1``, N):` `        ``for` `j ``in` `range``(``0``, ``10``):` `            ``for` `k ``in` `range``(``0``, ``16``):` `                ``# Calculate XOR` `                ``xor ``=` `j ^ k;`   `                ``# Store in DP table` `                ``dp[i][xor] ``+``=` `dp[i ``-` `1``][k];`   `    ``# Initialize count` `    ``count ``=` `0``;` `    ``for` `i ``in` `range``(``0``, ``10``):` `        ``count ``+``=` `dp[N ``-` `1``][i];`   `    ``# Print answer` `    ``print``(count);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# Given number N` `    ``N ``=` `1``;`   `    ``# Function Call` `    ``countNums(N);`   `# This code is contributed by shikhasingrajput`

C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find count of N-digit` `// numbers with single digit XOR` `public` `static` `void` `countNums(``int` `N)` `{`   `    ``// dp[i][j] stores the number` `    ``// of i-digit numbers with` `    ``// XOR equal to j` `    ``int` `[,]dp = ``new` `int``[N, 16];`   `    ``// For 1-9 store the value` `    ``for``(``int` `i = 1; i <= 9; i++)` `        ``dp[0, i] = 1;`   `    ``// Iterate till N` `    ``for``(``int` `i = 1; i < N; i++)` `    ``{` `        ``for``(``int` `j = 0; j < 10; j++) ` `        ``{` `            ``for` `(``int` `k = 0; k < 16; k++) ` `            ``{`   `                ``// Calculate XOR` `                ``int` `xor = j ^ k;`   `                ``// Store in DP table` `                ``dp[i, xor] += dp[i - 1, k];` `            ``}` `        ``}` `    ``}`   `    ``// Initialize count` `    ``int` `count = 0;` `    ``for``(``int` `i = 0; i < 10; i++)` `        ``count += dp[N - 1, i];`   `    ``// Print the answer` `    ``Console.Write(count);` `}`   `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    `  `    ``// Given number N` `    ``int` `N = 1;`   `    ``// Function call` `    ``countNums(N);` `}` `}`   `// This code is contributed by rutvik_56 `

Javascript

 ``

Output:

`9`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :