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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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);  


    }  


} 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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  



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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  



















                        chevron_right







                        filter_none











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. 

  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. 

  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. 

  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.
    5. 



Below is the implementation of the above approach:




Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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);  


    }  


} 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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  



















                        chevron_right







                        filter_none











Output:


9





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
        arrow_drop_up
    

    

        
        

            
            
        

    


Recommended Posts:
jrishabh99
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.


Improved By :  rutvik_56, code_hunt