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

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++ 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 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));
    }
}

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

2

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