# Check if original Array is retained after performing XOR with M exactly K times

Given an array **A** and two integers **M** and **K**, the task is to check and print “**Yes**“, if the original array can be retained by performing exactly ‘**K**‘ number of bitwise XOR operations of the array elements with ‘**M**‘. Else print “**No**“.**Note:** XOR operation can be performed, on any element of the array, for 0 or more times. **Examples:**

Input:A[] = {1, 2, 3, 4}, M = 5, K = 6Output:YesExplanation:

If the XOR is performed on 1st element, A[0], for 6 times, we get A[0] back. Therefore, the original array is retained.Input:A[] = {5, 9, 3, 4, 5}, M = 5, K = 3Output:NoExplanation:

The original array cant be retained after performing odd number of XOR operations.

**Approach:** This problem can be solved using the XOR property

A XOR B = C and C XOR B = A

It can be seen that:

- if even number of XOR operations are performed for any positive number, then the original number can be retained.
- However, 0 is an exception. If both odd or even number of XOR operations are performed for 0, then the original number can be retained.
- Therefore,
**if K is even and M is 0**, then the answer will always be Yes. **If K is odd and 0 is not present in the array**, then the answer will always be No.**If K is odd and the count of 0 is at least 1**in the array then, the answer will be Yes.

**Below is the implementation of the above approach:**

## C++

`// C++ implementation for the` `// above mentioned problem` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check if original Array` `// can be retained by performing XOR` `// with M exactly K times` `string check(` `int` `Arr[], ` `int` `n,` ` ` `int` `M, ` `int` `K)` `{` ` ` `int` `flag = 0;` ` ` `// Check if O is present or not` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(Arr[i] == 0)` ` ` `flag = 1;` ` ` `}` ` ` `// If K is odd and 0 is not present` ` ` `// then the answer will always be No.` ` ` `if` `(K % 2 != 0` ` ` `&& flag == 0)` ` ` `return` `"No"` `;` ` ` `// Else it will be Yes` ` ` `else` ` ` `return` `"Yes"` `;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `Arr[] = { 1, 1, 2, 4, 7, 8 };` ` ` `int` `M = 5;` ` ` `int` `K = 6;` ` ` `int` `n = ` `sizeof` `(Arr) / ` `sizeof` `(Arr[0]);` ` ` `cout << check(Arr, n, M, K);` ` ` `return` `0;` `}` |

## Java

`import` `java.util.*;` `class` `GFG{` `// Function to check if original Array` `// can be retained by performing XOR` `// with M exactly K times` `static` `String check(` `int` `[]Arr, ` `int` `n,` ` ` `int` `M, ` `int` `K)` `{` ` ` `int` `flag = ` `0` `;` ` ` `// Check if O is present or not` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` `if` `(Arr[i] == ` `0` `)` ` ` `flag = ` `1` `;` ` ` `}` ` ` `// If K is odd and 0 is not present` ` ` `// then the answer will always be No.` ` ` `if` `(K % ` `2` `!= ` `0` ` ` `&& flag == ` `0` `)` ` ` `return` `"No"` `;` ` ` `// Else it will be Yes` ` ` `else` ` ` `return` `"Yes"` `;` `}` `// Driver Code` `public` `static` `void` `main(String args[])` `{` ` ` `int` `[]Arr = { ` `1` `, ` `1` `, ` `2` `, ` `4` `, ` `7` `, ` `8` `};` ` ` `int` `M = ` `5` `;` ` ` `int` `K = ` `6` `;` ` ` `int` `n = Arr.length;` ` ` `System.out.println(check(Arr, n, M, K));` `}` `}` `// This code is contributed by Surendra_Gangwar` |

## Python3

`# Python3 implementation for the` `# above mentioned problem` ` ` `# Function to check if original Array` `# can be retained by performing XOR` `# with M exactly K times` `def` `check(Arr, n, M, K):` ` ` `flag ` `=` `0` ` ` ` ` `# Check if O is present or not` ` ` `for` `i ` `in` `range` `(n):` ` ` `if` `(Arr[i] ` `=` `=` `0` `):` ` ` `flag ` `=` `1` ` ` ` ` `# If K is odd and 0 is not present` ` ` `# then the answer will always be No.` ` ` `if` `(K ` `%` `2` `!` `=` `0` `and` `flag ` `=` `=` `0` `):` ` ` `return` `"No"` ` ` ` ` `# Else it will be Yes` ` ` `else` `:` ` ` `return` `"Yes"` `;` ` ` `# Driver Code` `if` `__name__` `=` `=` `'__main__'` `:` ` ` `Arr ` `=` `[ ` `1` `, ` `1` `, ` `2` `, ` `4` `, ` `7` `, ` `8` `]` ` ` `M ` `=` `5` `;` ` ` `K ` `=` `6` `;` ` ` `n ` `=` `len` `(Arr);` ` ` ` ` `print` `(check(Arr, n, M, K))` `# This article contributed by Princi Singh` |

## C#

`// C# implementation for the` `// above mentioned problem` `using` `System;` ` ` `class` `GFG` `{` ` ` `// Function to check if original Array` `// can be retained by performing XOR` `// with M exactly K times` `static` `String check(` `int` `[]Arr, ` `int` `n,` `int` `M, ` `int` `K)` `{` ` ` `int` `flag = 0;` ` ` `// Check if O is present or not` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(Arr[i] == 0)` ` ` `flag = 1;` ` ` `}` ` ` `// If K is odd and 0 is not present` ` ` `// then the answer will always be No.` ` ` `if` `(K % 2 != 0` ` ` `&& flag == 0)` ` ` `return` `"No"` `;` ` ` `// Else it will be Yes` ` ` `else` ` ` `return` `"Yes"` `;` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[]Arr = { 1, 1, 2, 4, 7, 8 };` ` ` `int` `M = 5;` ` ` `int` `K = 6;` ` ` `int` `n = Arr.Length;` ` ` `Console.Write(check(Arr, n, M, K));` `}` `}` `// This code is contributed by shivanisinghss2110` |

## Javascript

`<script>` `// Javascript implementation for the` `// above mentioned problem` `// Function to check if original Array` `// can be retained by performing XOR` `// with M exactly K times` `function` `check(Arr, n, M, K)` `{` ` ` `let flag = 0;` ` ` `// Check if O is present or not` ` ` `for` `(let i = 0; i < n; i++) {` ` ` `if` `(Arr[i] == 0)` ` ` `flag = 1;` ` ` `}` ` ` `// If K is odd and 0 is not present` ` ` `// then the answer will always be No.` ` ` `if` `(K % 2 != 0` ` ` `&& flag == 0)` ` ` `return` `"No"` `;` ` ` `// Else it will be Yes` ` ` `else` ` ` `return` `"Yes"` `;` `}` `// Driver Code` ` ` `let Arr = [ 1, 1, 2, 4, 7, 8 ];` ` ` `let M = 5;` ` ` `let K = 6;` ` ` `let n = Arr.length;` ` ` `document.write(check(Arr, n, M, K));` `</script>` |

**Output:**

Yes

Time Complexity: O(N)

Auxiliary Space: O(1)