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

• Difficulty Level : Medium
• Last Updated : 14 Jun, 2022

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);`   `    ``// 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 = { 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)

My Personal Notes arrow_drop_up
Recommended Articles
Page :