GeeksforGeeks App
Open App
Browser
Continue

# Find minimum number of non palindromic partition of Binary Array

Given a binary array A[] of length 2*N, the task is to find the minimum number of partitions that follow the below conditions:

• Each array element belongs to exactly one partition
• None of the partitioned subarrays is a palindrome

Note: If there are multiple answers print anyone that satisfies the above conditions and if no such partition exists that satisfies the above condition then print -1.

Examples:

Input: A[] = {1, 0, 1, 1, 0, 1}
Output: 2
Explanation: One of the valid partitions of A = {1, 0, 1, 1, 0, 1} is {1, 0} and {1, 1, 0, 1} which satisfy above conditions.Hence we can partition an array into 2 subarrays.

Input: A[] = {1, 0, 0, 1, 0, 0, 1, 1}
Output: 1
Explanation: Here A = {1, 0, 0, 1, 0, 0, 1, 1} is itself not a palindrome. Then, no more partitioning needs to be done: just take A itself. Hence number of partitions of an array is 1.

Approach: The problem can be solved based on the following observation:

• A trivial impossible case is when an array A consists of only 0’s or only 1’s as an element and print -1.
• In every other case, a valid partition exists and only 2 partitions are sufficient.
• Suppose A is itself not a palindrome. Then, no more partitioning needs to be done: just take A itself.
• Now we consider the case when A is a palindrome. Note that the length of A is even.
• Suppose the first half of A is not a palindrome. Then, its second half is also not a palindrome, so simply partition it into these two halves.
• Otherwise, the first N elements of A form a palindrome. In this case, consider the string formed by the first N+1 elements of A: this is definitely not a palindrome.

Follow the below steps to solve the problem:

• Check whether an array is a palindrome or not and if the array is not a palindrome then print 1.
• After that check whether array A[] consists of only 0’s or only 1’s as an element and if it is true then print -1.
• Otherwise, print 2 as an answer for the number of partitions of an array that satisfy conditions.

Below is the implementation of the above approach.

## C++

```// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to check if the array is palindrome
bool isPalindrome(int arr[], int n)
{
int flag = 0;

// Loop till array size n/2.
for (int i = 0; i <= n / 2 && n != 0; i++) {

if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}

if (flag == 1)
return false;
else
return true;
}

// Function to find number of
// partitions of an array
void numOfPartition(int arr[], int n)
{
if (!isPalindrome(arr, n)) {
cout << 1;
}
else {
int k = 0, z = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 0)
z++;
else
k++;
}
if (k == 0 || z == 0) {
cout << -1;
}
else {
cout << 2;
}
}
}

// Driver Code
int main()
{
int A[] = { 1, 0, 1, 1, 0, 1 };
int N = sizeof(A) / sizeof(A[0]);

// Function call
numOfPartition(A, N);

return 0;
}

// This code is contributed by aarohirai2616.```

## Java

```// Java code to implement the approach

import java.io.*;
import java.util.*;

public class GFG {

// Function to find number of
// partitions of an array
public static void numOfPartition(int arr[], int n)
{
if (!isPalindrome(arr, n)) {
System.out.println(1);
}
else {
int k = 0, z = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 0)
z++;
else
k++;
}
if (k == 0 || z == 0) {
System.out.println(-1);
}
else {
System.out.println(2);
}
}
}

// Function to check if the array is palindrome
static boolean isPalindrome(int arr[], int n)
{
int flag = 0;

// Loop till array size n/2.
for (int i = 0; i <= n / 2 && n != 0; i++) {

if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}

if (flag == 1)
return false;
else
return true;
}

// Driver Code
public static void main(String[] args)
{
int[] A = { 1, 0, 1, 1, 0, 1 };
int N = A.length;

// Function Call
numOfPartition(A, N);
}
}```

## Python

```# Python code to implement the approach

# Function to check if the array is palindrome
def isPalindrome(arr, n):

flag = 0

# Loop till array size n/2.
i = 0
while(i <= n // 2 and n != 0):

if (arr[i] != arr[n - i - 1]):
flag = 1
break

i += 1

if (flag == 1):
return False
else:
return True

# Function to find number of
# partitions of an array
def numOfPartition(arr, n):

if (isPalindrome(arr, n) == False):
print(1)
else:
k = 0
z = 0
for i in range(0, n):
if (arr[i] == 0):
z += 1
else:
k += 1
if (k == 0 or z == 0):
print(-1)

else:
print(2)

# Driver Code
A = [1, 0, 1, 1, 0, 1]
N = len(A)

# Function call
numOfPartition(A, N)

# This code is contributed by Samim Hossain Mondal.```

## C#

```// C# code to implement the approach

using System;

public class GFG {

// Function to find number of
// partitions of an array
public static void numOfPartition(int[] arr, int n)
{
if (!isPalindrome(arr, n)) {
Console.WriteLine(1);
}
else {
int k = 0, z = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == 0)
z++;
else
k++;
}
if (k == 0 || z == 0) {
Console.WriteLine(-1);
}
else {
Console.WriteLine(2);
}
}
}

// Function to check if the array is palindrome
static bool isPalindrome(int[] arr, int n)
{
int flag = 0;

// Loop till array size n/2.
for (int i = 0; i <= n / 2 && n != 0; i++) {

if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}

if (flag == 1)
return false;
else
return true;
}

static public void Main()
{

// Code
int[] A = { 1, 0, 1, 1, 0, 1 };
int N = A.Length;

// Function Call
numOfPartition(A, N);
}
}

// This code is contributed by lokesh```

## Javascript

```    // Javascript code to implement the approach

// Function to check if the array is palindrome
function isPalindrome(arr, n)
{
let flag = 0;

// Loop till array size n/2.
for (let i = 0; i <= n / 2 && n != 0; i++) {

if (arr[i] != arr[n - i - 1]) {
flag = 1;
break;
}
}

if (flag == 1)
return false;
else
return true;
}

// Function to find number of
// partitions of an array
function numOfPartition(arr, n)
{
if (!isPalindrome(arr, n)) {
console.log("1");
}
else {
let k = 0, z = 0;
for (let i = 0; i < n; i++) {
if (arr[i] == 0)
z++;
else
k++;
}
if (k == 0 || z == 0) {
console.log("-1");
}
else {
console.log("2");
}
}
}

// Driver Code

let A = [ 1, 0, 1, 1, 0, 1 ];
let N = A.length;

// Function call
numOfPartition(A, N);

// This code is contributed by Pushpesh Raj.

```
Output

`2`

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

My Personal Notes arrow_drop_up