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++ code for the approach

#include <bits/stdc++.h>
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 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# 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

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

Yes

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