Related Articles

Related Articles

XOR of array elements whose modular inverse with a given number exists
  • Difficulty Level : Medium
  • Last Updated : 25 Oct, 2020

Given an array arr[] of length N and a positive integer M, the task is to find the Bitwise XOR of all the array elements whose modular inverse with M exists.

Examples:

Input: arr[] = {1, 2, 3}, M = 4
Output: 2
Explanation:
Initialize the value xor with 0:
For element indexed at 0 i.e., 1, its mod inverse with 4 is 1 because (1 * 1) % 4 = 1 i.e., it exists. Therefore, xor = (xor ^ 1) = 1.
For element indexed at 1 i.e., 2, its mod inverse does not exist.
For element indexed at 2 i.e., 3, its mod inverse with 4 is 3 because (3 * 3) % 4 = 1 i.e., it exists. Therefore, xor = (xor ^ 3) = 2.
Hence, xor is 2.

Input: arr[] = {3, 6, 4, 5, 8}, M = 9
Output: 9
Explanation:
Initialize the value xor with 0:
For element indexed at 0 i.e., 3, its mod inverse does not exist.
For element indexed at 1 i.e., 6, its mod inverse does not exist.
For element indexed at 2 i.e., 4, its mod inverse with 9 is 7 because (4 * 7) % 9 = 1 i.e., it exists. Therefore, xor = (xor ^ 4) = 4.
For element indexed at 3 i.e., 5, its mod inverse with 9 is 2 because (5 * 2) % 9 = 1 i.e., it exists. Therefore, xor = (xor ^ 5) = 1.
For element indexed at 4 i.e., 8, its mod inverse with 9 is 8 because (8 * 8) % 9 = 1 i.e., it exists. Therefore, xor = (xor ^ 8) = 9.
Hence, xor is 9.

Naive Approach: The simplest approach is to print the XOR of all the elements of the array for which there exists any j where (1 <= j < M) such that (arr[i] * j) % M = 1 where 0 ≤ i < N.



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

Efficient Approach: To optimize the above approach, the idea is to use the property that the modular inverse of any number X under mod M exists if and only if the GCD of M and X is 1 i.e., gcd(M, X) is 1. Follow the steps below to solve the problem:

  1. Initialize a variable xor with 0, to store the xor of all the elements whose modular inverse under M exists.
  2. Traverse the array over the range [0, N – 1].
  3. If gcd(M, arr[i]) is 1 then update xor as xor = (xor^arr[i]).
  4. After traversing, print the value xor as the required result.

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 return the gcd of a & b
int gcd(int a, int b)
{
    // Base Case
    if (a == 0)
        return b;
      
     // Recursively calculate GCD
    return gcd(b % a, a);
}
  
// Function to print the Bitwise XOR of
// elements of arr[] if gcd(arr[i], M) is 1
void countInverse(int arr[], int N, int M)
{
    // Initialize xor
    int XOR = 0;
  
    // Traversing the array
    for (int i = 0; i < N; i++) {
  
        // GCD of M and arr[i]
        int gcdOfMandelement
          = gcd(M, arr[i]);
  
        // If GCD is 1, update xor
        if (gcdOfMandelement == 1) {
  
            XOR ^= arr[i];
        }
    }
  
    // Print xor
    cout << XOR << ' ';
}
  
// Drive Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 3 };
  
    // Given number M
    int M = 4;
  
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
  
    // Function Call
    countInverse(arr, N, M);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach
import java.io.*;
  
class GFG{
  
// Function to return the gcd of a & b
static int gcd(int a, int b)
{
      
    // Base Case
    if (a == 0)
        return b;
  
    // Recursively calculate GCD
    return gcd(b % a, a);
}
  
// Function to print the Bitwise XOR of
// elements of arr[] if gcd(arr[i], M) is 1
static void countInverse(int[] arr, int N, int M)
{
      
    // Initialize xor
    int XOR = 0;
  
    // Traversing the array
    for(int i = 0; i < N; i++) 
    {
          
        // GCD of M and arr[i]
        int gcdOfMandelement = gcd(M, arr[i]);
  
        // If GCD is 1, update xor
        if (gcdOfMandelement == 1
        {
            XOR ^= arr[i];
        }
    }
  
    // Print xor
    System.out.println(XOR);
}
  
// Drive Code
public static void main(String[] args)
{
  
    // Given array arr[]
    int[] arr = { 1, 2, 3 };
  
    // Given number M
    int M = 4;
  
    // Size of the array
    int N = arr.length;
  
    // Function Call
    countInverse(arr, N, M);
}
}
  
// This code is contributed by akhilsaini

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to return the gcd of a & b
def gcd(a, b):
      
    # Base Case
    if (a == 0):
        return b
  
    # Recursively calculate GCD
    return gcd(b % a, a)
  
# Function to print the Bitwise XOR of
# elements of arr[] if gcd(arr[i], M) is 1
def countInverse(arr, N, M):
  
    # Initialize xor
    XOR = 0
  
    # Traversing the array
    for i in range(0, N):
  
        # GCD of M and arr[i]
        gcdOfMandelement = gcd(M, arr[i])
  
        # If GCD is 1, update xor
        if (gcdOfMandelement == 1):
            XOR = XOR ^ arr[i]
  
    # Print xor
    print(XOR)
  
# Drive Code
if __name__ == '__main__':
  
    # Given array arr[]
    arr = [ 1, 2, 3 ]
  
    # Given number M
    M = 4
  
    # Size of the array
    N = len(arr)
  
    # Function Call
    countInverse(arr, N, M)
  
# This code is contributed by akhilsaini

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
  
class GFG{
  
// Function to return the gcd of a & b
static int gcd(int a, int b)
{
      
    // Base Case
    if (a == 0)
        return b;
  
    // Recursively calculate GCD
    return gcd(b % a, a);
}
  
// Function to print the Bitwise XOR of
// elements of arr[] if gcd(arr[i], M) is 1
static void countInverse(int[] arr, int N, int M)
{
      
    // Initialize xor
    int XOR = 0;
  
    // Traversing the array
    for(int i = 0; i < N; i++)
    {
          
        // GCD of M and arr[i]
        int gcdOfMandelement = gcd(M, arr[i]);
  
        // If GCD is 1, update xor
        if (gcdOfMandelement == 1)
        {
  
            XOR ^= arr[i];
        }
    }
  
    // Print xor
    Console.WriteLine(XOR);
}
  
// Drive Code
public static void Main()
{
  
    // Given array arr[]
    int[] arr = { 1, 2, 3 };
  
    // Given number M
    int M = 4;
  
    // Size of the array
    int N = arr.Length;
  
    // Function Call
    countInverse(arr, N, M);
}
}
  
// This code is contributed by akhilsaini

chevron_right


Output: 

2



 

Time Complexity: O(N*log M)
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 Articles
Page :