Minimize insertion of 0 or 1 such that no adjacent pair has same value

Last Updated : 31 Mar, 2023

Given a binary array A[] of length N, the task is to find the minimum number of operations required such that no adjacent pair has the same value where in each operation we can insert either 0 or 1 at any position in the array.

Examples:

Input: A[] = {0, 0, 1, 0, 0}
Output: 2
?Explanation: We can perform the following operations to make consecutive element different in an array:
Insert 1 at index 1 in A = {0, 0, 1, 0, 0} ? {0, 1, 0, 1, 0, 0}
Insert 1 at index 5 in A = {0, 1, 0, 1, 0, 0} ? {0, 1, 0, 1, 0, 1, 0} all consecutive elements are different.

Input: A[] = {0, 1, 1}
Output: 1

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

A single move allows us to ‘break apart’ exactly one pair of equal adjacent elements of an array, by inserting either 1 between 0, 0 or 0 between 1, 1.

So, the answer is simply the number of pairs that are already adjacent and equal, i.e, positions i (1 ? i <N) such that A_i = A_{i + 1}, which can be computed with a simple for loop.

Follow the below steps to solve the problem:

Initialize a variable count = 0.
Iterate a loop for each element in A, and check if it is equal to the next element.
- If yes, increment the count by 1.
Print the count which gives the minimum number of operations required to make consecutive elements different in an array.

Below is the implementation of the above approach.

C++

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

// Function to find minimum number of
// operations required to make
// consecutive element different in
// an array
int minOperation(int arr[], int n)
{
  int count = 0;

  for (int i = 0; i < n - 1; i++) {
    if (arr[i] == arr[i + 1]) {
      count++;
    }
  }
  return count;
}

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

  // Function call
  cout << minOperation(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 minimum number of
    // operations required to make
    // consecutive element different in
    // an array
    public static int minOperation(int arr[], int n)
    {
        int count = 0;

        for (int i = 0; i < n - 1; i++) {
            if (arr[i] == arr[i + 1]) {
                count++;
            }
        }
        return count;
    }

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

        // Function Call
        System.out.println(minOperation(A, N));
    }
}

Python3

# Python code to implement the approach

# Function to find minimum number of
# operations required to make
# consecutive element different in
# an array
def minOperation(arr, n):
    count = 0
    for i in range(0, n-1):
        if (arr[i] == arr[i + 1]):
            count = count + 1
    return count

# Driver Code
if __name__ == '__main__':
    A = [0, 0, 1, 0, 0]
    N = len(A)

    # Function call
    print(minOperation(A, N))

   # This code is contributed by aarohirai2616.

// C# code to implement the approach
using System;
public class GFG{

  // Function to find minimum number of
  // operations required to make
  // consecutive element different in
  // an array
  public static int minOperation(int[] arr, int n)
  {
    int count = 0;

    for (int i = 0; i < n - 1; i++) {
      if (arr[i] == arr[i + 1]) {
        count++;
      }
    }
    return count;
  }

  static public void Main (){

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

    // Function Call
    Console.WriteLine(minOperation(A, N));
  }
}

// This code is contributed by lokeshmvs21.

JavaScript

// Javascript code to implement the approach

// Function to find minimum number of
// operations required to make
// consecutive element different in
// an array
function minOperation(arr, n)
{
  let count = 0;

  for (let i = 0; i < n - 1; i++) {
    if (arr[i] == arr[i + 1]) {
      count += 1;
    }
  }
  return count;
}

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

// Function call
console.log(minOperation(A, N));

// This code is contributed by Samim Hossain Mondal.