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

 `// C++ program for the above approach ` `#include ` `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); ` ` `  `    ``// Function Call ` `    ``countInverse(arr, N, M); ` ` `  `    ``return` `0; ` `} `

## Java

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

## Python3

 `# 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`

## C#

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

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 :