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 = 6

Output:Yes

Explanation:

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 = 3

Output:No

Explanation:

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; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

Yes