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

Difficulty Level : Medium
Last Updated : 23 Oct, 2020

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 <bits/stdc++.h> 
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 

Output:

Time Complexity: O(N*10^N)
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.

Create a table dp[][], where dp[i][j] stores the count of i-digit numbers such that their XOR is j.
Initialize the dp[][] for i = 1 and for each i form 2 to N iterate for every digit j from 0 to 9.
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].
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<bits/stdc++.h>
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 

Output:

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

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

Related Articles

C++

Java

Python3

C#

C++

Java

Python3

C#