# Check if Binary Array can be made palindrome after K bitwise XOR with 1

Given a binary array arr[] of size N and an integer K, the task is to check whether the binary array can be turned into a palindrome after K number of operations where in one operation, any random index can be chosen and the value stored in the index will be replaced by its bitwise XOR(^) with1.

Examples:

Input: arr[] = { 1, 0, 0, 1, 1}, K = 0
Output: No
Explanation: As the array is not a palindrome, we must need some non-zero number of operations
to make it palindrome.

Input: arr[] = { 1, 0, 1, 1, 0, 0}, K = 1
Output: Yes
Explanation: Closest arrays which are palindrome : {0, 0, 1, 1, 0, 0} and {1, 0, 1, 1, 0, 1}, which is possible
using 1 such operations only.

Approach: The approach to solve the problem is based on the following idea:

The minimum number of operations required is the number of unequal elements equidistant from the mid of the array and to make them equal it takes 1 operation (from 1 to 0 or from 0 to 1).
There is need of 2 operations to change two equal elements and make them have the same value again using bitwise XOR.

To implement this idea, follow the steps shown below :

• Initialize two pointers pointing at the two ends of the array.
• Find the number of unequal array elements while traversing the array from its two ends.
• If the number is greater than K, then it is impossible to reach the target with exactly K steps.
• If the number is exactly equal to K, then it is possible to make the array palindrome.
• Otherwise, if the number is lesser than K:
• If the array length is odd, then any number of positive K is fine as we can perform the operations at the mid index.
• If the array length is even, to keep it a palindrome, we must choose two indices and make the operations on those indices. So remaining K has to be even.

Here is the code for the above approach:

## C++

 `// C++ code for the approach`   `#include ` `using` `namespace` `std;`   `// Function to check whether the array` `// can be turned into palindrome after K` `// number of operations` `bool` `check_possibility(``int``* arr, ``int` `K)` `{` `    ``// Store the length of the array in` `    ``// arr_length variable` `    ``int` `arr_length = ``sizeof``(arr) / ``sizeof``(` `                                       ``arr[0]);`   `    ``// Initialize two pointers from left and` `    ``// right ends of the array` `    ``int` `i = 0;` `    ``int` `j = arr_length - 1;`   `    ``// Keep iterating through the array from` `    ``// two ends until the two pointers cross` `    ``// each other to count the number` `    ``// of the different array items.` `    ``while` `(i < j) {`   `        ``// If the two elements are unequal,` `        ``// decrease the value of K by one` `        ``if` `(arr[i] != arr[j]) {` `            ``K--;` `        ``}`   `        ``// Move the left pointer towards the` `        ``// right and right pointer towards the` `        ``// left` `        ``i++;` `        ``j--;` `    ``}`   `    ``// The unequal items are more than K or K` `    ``// becomes less than zero, it is impossible` `    ``// to make it a palindrome with D operations.` `    ``if` `(K < 0) {` `        ``return` `false``;` `    ``}`   `    ``// If K has a non-negative value, we make the` `    ``// array a palindrome if it has an odd length` `    ``// the remaining value of K is odd as we have` `    ``// to choose two indices at a time to keep it` `    ``// as a palindrome.` `    ``else` `{` `        ``if` `((arr_length % 2) != 0` `            ``|| (K % 2) == 0) {` `            ``return` `true``;` `        ``}` `        ``else` `{` `            ``return` `false``;` `        ``}` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[6] = { 1, 0, 1, 1, 0, 0 };` `    ``int` `K = 1;`   `    ``// Function call` `    ``if` `(check_possibility(arr, K) == ``true``) {` `        ``cout << ``"Yes"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"No"` `<< endl;` `    ``}` `    ``return` `0;` `}`

## Java

 `// Java code for the approach` `import` `java.io.*;`   `class` `GFG` `{`   `  ``// Function to check whether the array` `  ``// can be turned into palindrome after K` `  ``// number of operations` `  ``public` `static` `boolean` `check_possibility(``int` `arr[],` `                                          ``int` `K)` `  ``{`   `    ``// Store the length of the array in` `    ``// arr_length variable` `    ``int` `arr_length = arr.length;`   `    ``// Initialize two pointers from left and` `    ``// right ends of the array` `    ``int` `i = ``0``;` `    ``int` `j = arr_length - ``1``;`   `    ``// Keep iterating through the array from` `    ``// two ends until the two pointers cross` `    ``// each other to count the number` `    ``// of the different array items.` `    ``while` `(i < j) {`   `      ``// If the two elements are unequal,` `      ``// decrease the value of K by one` `      ``if` `(arr[i] != arr[j]) {` `        ``K--;` `      ``}`   `      ``// Move the left pointer towards the` `      ``// right and right pointer towards the` `      ``// left` `      ``i++;` `      ``j--;` `    ``}`   `    ``// The unequal items are more than K or K` `    ``// becomes less than zero, it is impossible` `    ``// to make it a palindrome with D operations.` `    ``if` `(K < ``0``) {` `      ``return` `false``;` `    ``}`   `    ``// If K has a non-negative value, we make the` `    ``// array a palindrome if it has an odd length` `    ``// the remaining value of K is odd as we have` `    ``// to choose two indices at a time to keep it` `    ``// as a palindrome.` `    ``else` `{` `      ``if` `((arr_length % ``2``) != ``0` `|| (K % ``2``) == ``0``) {` `        ``return` `true``;` `      ``}` `      ``else` `{` `        ``return` `false``;` `      ``}` `    ``}` `  ``}` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = { ``1``, ``0``, ``1``, ``1``, ``0``, ``0` `};` `    ``int` `K = ``1``;`   `    ``// Function call` `    ``if` `(check_possibility(arr, K) == ``true``) {` `      ``System.out.println(``"Yes"``);` `    ``}` `    ``else` `{` `      ``System.out.println(``"No"``);` `    ``}` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## C#

 `// C# code for the approach` `using` `System;` `class` `GFG {`   `  ``// Function to check whether the array` `  ``// can be turned into palindrome after K` `  ``// number of operations` `  ``static` `bool` `check_possibility(``int``[] arr, ``int` `K)` `  ``{`   `    ``// Store the length of the array in` `    ``// arr_length variable` `    ``int` `arr_length = arr.Length;`   `    ``// Initialize two pointers from left and` `    ``// right ends of the array` `    ``int` `i = 0;` `    ``int` `j = arr_length - 1;`   `    ``// Keep iterating through the array from` `    ``// two ends until the two pointers cross` `    ``// each other to count the number` `    ``// of the different array items.` `    ``while` `(i < j) {`   `      ``// If the two elements are unequal,` `      ``// decrease the value of K by one` `      ``if` `(arr[i] != arr[j]) {` `        ``K--;` `      ``}`   `      ``// Move the left pointer towards the` `      ``// right and right pointer towards the` `      ``// left` `      ``i++;` `      ``j--;` `    ``}`   `    ``// The unequal items are more than K or K` `    ``// becomes less than zero, it is impossible` `    ``// to make it a palindrome with D operations.` `    ``if` `(K < 0) {` `      ``return` `false``;` `    ``}`   `    ``// If K has a non-negative value, we make the` `    ``// array a palindrome if it has an odd length` `    ``// the remaining value of K is odd as we have` `    ``// to choose two indices at a time to keep it` `    ``// as a palindrome.` `    ``else` `{` `      ``if` `((arr_length % 2) != 0 || (K % 2) == 0) {` `        ``return` `true``;` `      ``}` `      ``else` `{` `        ``return` `false``;` `      ``}` `    ``}` `  ``}` `  ``public` `static` `int` `Main()` `  ``{` `    ``int``[] arr = ``new` `int``[] { 1, 0, 1, 1, 0, 0 };` `    ``int` `K = 1;`   `    ``// Function call` `    ``if` `(check_possibility(arr, K) == ``true``) {` `      ``Console.WriteLine(``"Yes"``);` `    ``}` `    ``else` `{` `      ``Console.WriteLine(``"No"``);` `    ``}` `    ``return` `0;` `  ``}` `}`   `// This code is contributed by Taranpreet`

## Python3

 `# Python code for the approach`   `def` `check_possibility(arr, K):` `   `  `    ``# Store the length of the array in ` `    ``# arr_length variable` `    ``arr_length ``=` `len``(arr)` `    `  `    ``# Initialize two pointers from left and right ` `    ``# ends of the array` `    ``i ``=` `0` `    ``j ``=` `arr_length ``-` `1` `    `  `    ``# Keep iterating through the array from two ` `    ``# ends until the two pointers cross each` `    ``# other to count the number of the different ` `    ``# array items.` `    ``while``(i < j):` `      `  `        ``# If the two elements are unequal, ` `        ``# decrease the value of K by one` `        ``if``(arr[i] !``=` `arr[j]):` `            ``K ``-``=` `1`   `        ``# Move the left pointer towards the right` `        ``# and right pointer towards the left` `        ``i ``+``=` `1` `        ``j ``-``=` `1` `    `  `    ``# The unequal items are more than K or` `    ``# K becomes less than zero, it is impossible` `    ``# to make it a palindrome with K operations.` `    ``if``(K < ``0``):` `        ``return` `False` `    `  `    ``# If K has a non-negative value, we make the ` `    ``# array a palindrome if it has an odd length` `    ``# the remaining value of K is odd as we have ` `    ``# to choose two indices at a time ` `    ``# to keep it as a palindrome` `    ``else``:` `        ``if``( (arr_length ``%` `2``)!``=` `0` `or` `(K ``%` `2``)``=``=` `0``):` `            ``return` `True` `    `  `        ``else``:` `            ``return` `False`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``1``, ``0``, ``1``, ``1``, ``0``, ``0``]` `    ``K ``=` `1` `    `  `    ``if` `check_possibility(arr, K) ``=``=` `True` `:` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"No"``)`

## Javascript

 `// JavaScript code for the approach`   `// Function to check whether the array` `// can be turned into palindrome after K` `// number of operations` `function` `check_possibility(arr, K)` `{`   `    ``// Store the length of the array in` `    ``// arr_length variable` `    ``var` `arr_length = arr.length;`   `    ``// Initialize two pointers from left and` `    ``// right ends of the array` `    ``var` `i = 0;` `    ``var` `j = arr_length - 1;`   `    ``// Keep iterating through the array from` `    ``// two ends until the two pointers cross` `    ``// each other to count the number` `    ``// of the different array items.` `    ``while` `(i < j) {`   `        ``// If the two elements are unequal,` `        ``// decrease the value of K by one` `        ``if` `(arr[i] != arr[j]) {` `            ``K--;` `        ``}`   `        ``// Move the left pointer towards the` `        ``// right and right pointer towards the` `        ``// left` `        ``i++;` `        ``j--;` `    ``}`   `    ``// The unequal items are more than K or K` `    ``// becomes less than zero, it is impossible` `    ``// to make it a palindrome with D operations.` `    ``if` `(K < 0) {` `        ``return` `false``;` `    ``}`   `    ``// If K has a non-negative value, we make the` `    ``// array a palindrome if it has an odd length` `    ``// the remaining value of K is odd as we have` `    ``// to choose two indices at a time to keep it` `    ``// as a palindrome.` `    ``else` `{` `        ``if` `((arr_length % 2) != 0 || (K % 2) == 0) {` `            ``return` `true``;` `        ``}` `        ``else` `{` `            ``return` `false``;` `        ``}` `    ``}` `}`   `// Driver code` `var` `arr = [ 1, 0, 1, 1, 0, 0 ];` `var` `K = 1;`   `// Function call` `if` `(check_possibility(arr, K) == ``true``) {` `    ``console.log(``"Yes"``);` `}` `else` `{` `    ``console.log(``"No"``);` `}`   `// This code is contributed by phasing17`

Output

`Yes`

Time Complexity: O(N)
Auxiliary Space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next