Minimum no. of operations required to make all Array Elements Zero

Given an array of N elements and each element is either 1 or 0. You need to make all the elements of the array equal to 0 by performing the below operations:

• If an element is 1, You can change it’s value equal to 0 then, 
  • if the next consecutive element is 1, it will automatically get converted to 0.
  • if the next consecutive element is already 0, nothing will happen.

Now, the task is to find the minimum number of operations required to make all elements equal to 0.

Examples:  

Input : arr[] = {1, 1, 0, 0, 1, 1, 1, 0, 0, 1} 
Output : Minimum changes: 3 

Input : arr[] = {1, 1, 1, 1}
Output : Minimum changes: 1 

Approach 1: To find the minimum number of changes required, iterate the array from left to right and check if the current element is 1 or not. If the current element is 1, then change it to 0 and increment the count by 1 and search for the 0 for the next operation as all consecutive 1’s will be automatically converted to 0. 

Implementation:

C++

// CPP program to find  minimum number of
// operations required to make all
// array elements zero

#include <bits/stdc++.h>
using namespace std;

// Function to find  minimum number of
// operations required to make all
// array elements zero
int minimumChanges(int arr[], int n)
{
    int i;

    // It will maintain total changes required
    int changes = 0;

    for (i = 0; i < n; i++)
    {
        // Check for the first 1
        if (arr[i] == 1)
        {
            int j;

            // Check for number of
            // consecutive 1's
            for(j = i+1; j<n; j++)
            {
                if(arr[j]==0)
                    break;
            }

            // Increment i to the position of
            // last consecutive 1
            i = j-1;

            changes++;
        }
    }

    return changes;
}

// Driver code
int main()
{
    int arr[] = { 1, 1, 0, 0, 0, 1, 0, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Minimum operations: " << minimumChanges(arr, n);

    return 0;
}

Java

// Java program to find minimum
// number of operations required
// to make all array elements zero

class GFG
{

// Function to find minimum number
// of operations required to make
// all array elements zero
static int minimumChanges(int arr[],
                          int n)
{
    int i;

    // It will maintain total
    // changes required
    int changes = 0;

    for (i = 0; i < n; i++)
    {
        // Check for the first 1
        if (arr[i] == 1)
        {
            int j;

            // Check for number of
            // consecutive 1's
            for(j = i + 1; j < n; j++)
            {
                if(arr[j] == 0)
                    break;
            }

            // Increment i to the position
            // of last consecutive 1
            i = j - 1;

            changes++;
        }
    }

    return changes;
}

// Driver code
public static void main (String args[])
{
    int arr[] = { 1, 1, 0, 0, 0,
                     1, 0, 1, 1 };
    int n = arr.length ;

    System.out.println("Minimum operations: " +
                        minimumChanges(arr, n));

}
}

// This code is contributed by ANKITRAI1

Python 3

# Python 3 program to find
# minimum number of operations
# required to make all array
# elements zero

# Function to find minimum number
# of operations required to make
# all array elements zero
def minimumChanges(arr, n) :

    # It will maintain total
    # changes required
    changes = 0

    i = 0

    while i < n :

        # Check for the first 1
        if arr[i] == 1 :

            j = i + 1

            # Check for number of
            # consecutive 1's
            while j < n:

                if arr[j] == 0 :
                    break

                j += 1

            # Increment i to the position
            # of last consecutive 1
            i = j - 1

            changes += 1

        i += 1

    return changes

# Driver code
if __name__ == "__main__" :

    arr = [ 1, 1, 0, 0, 0, 1, 0, 1, 1]
    n = len(arr)

    print("Minimum operations:",
           minimumChanges(arr, n))

# This code is contributed by ANKITRAI1

C#

// C# program to find minimum
// number of operations required
// to make all array elements zero
class GFG
{

// Function to find minimum number
// of operations required to make
// all array elements zero
static int minimumChanges(int[] arr,
                          int n)
{
    int i;

    // It will maintain total
    // changes required
    int changes = 0;

    for (i = 0; i < n; i++)
    {
        // Check for the first 1
        if (arr[i] == 1)
        {
            int j;

            // Check for number of
            // consecutive 1's
            for(j = i + 1; j < n; j++)
            {
                if(arr[j] == 0)
                    break;
            }

            // Increment i to the position
            // of last consecutive 1
            i = j - 1;

            changes++;
        }
    }

    return changes;
}

// Driver code
static void Main()
{
    int[] arr = new int[]{ 1, 1, 0, 0, 0,
                           1, 0, 1, 1 };
    int n = arr.Length ;

    System.Console.WriteLine("Minimum operations: " +
                             minimumChanges(arr, n));
}
}

// This code is contributed by mits

PHP

<?php
// PHP program to find minimum number
// of operations required to make all
// array elements zero

// Function to find minimum number
// of operations required to make
// all array elements zero
function minimumChanges($arr, $n)
{
    $i;

    // It will maintain total
    // changes required
    $changes = 0;

    for ($i = 0; $i < $n; $i++)
    {
        // Check for the first 1
        if ($arr[$i] == 1)
        {
            $j;

            // Check for number of
            // consecutive 1's
            for($j = $i + 1; $j < $n; $j++)
            {
                if($arr[$j] == 0)
                    break;
            }

            // Increment i to the position
            // of last consecutive 1
            $i = $j - 1;

            $changes++;
        }
    }

    return $changes;
}

// Driver code
$arr = array( 1, 1, 0, 0, 0,
                 1, 0, 1, 1 );
$n = sizeof($arr);

echo "Minimum operations: " .
    minimumChanges($arr, $n);

// This code is contributed
// by Akanksha Rai(Abby_akku)

Javascript

<script>

// Javascript program to find  minimum number of
// operations required to make all
// array elements zero

// Function to find  minimum number of
// operations required to make all
// array elements zero
function minimumChanges(arr, n)
{
    var i;

    // It will maintain total changes required
    var changes = 0;

    for (i = 0; i < n; i++)
    {
        // Check for the first 1
        if (arr[i] == 1)
        {
            var j;

            // Check for number of
            // consecutive 1's
            for(j = i+1; j<n; j++)
            {
                if(arr[j]==0)
                    break;
            }

            // Increment i to the position of
            // last consecutive 1
            i = j-1;

            changes++;
        }
    }

    return changes;
}

// Driver code
var arr = [1, 1, 0, 0, 0, 1, 0, 1, 1 ];
var n = arr.length;

document.write( "Minimum operations: " + minimumChanges(arr, n));

</script>

Output

Minimum operations: 3

Complexity Analysis:

• Time Complexity: O(N*N), where N represents the size of the given array.
• Auxiliary Space: O(1), no extra space is required, so it is a constant.

Approach 2:

1. As we already know that we have to look for consecutive group/cluster of ‘1’, as after change the first ‘1’ of the group, rest of the consecutive ‘1’s will automatically be changed. So to find the consecutive ‘1’, we can iterate over the array and find the no. of consecutive pair of ‘1’ and ‘0’, as it will indicate the breakpoint for consecutive ‘1’s.
2. And at the last index, we will check if the last element of the array is ‘1’ or ‘0’, because, if it is ‘1’, then it is possible that a continuous group of ‘1’ was there and therefore our loop couldn’t find the breakpoint as the iteration ended.

Implementation:

C++

// CPP program to find minimum number of
// operations required to make all
// array elements zero

#include <bits/stdc++.h>
using namespace std;

// Function to find minimum number of
// operations required to make all
// array elements zero
int minimumChanges(int arr[], int n)
{
    int i;

    // It will maintain total changes
    // required and return as
    // answer
    int changes = 0;

    // We iterate from 0 to n-1
    // We can't iterate from 0 to n as
    // the arr[i+1] will be
    // out of index
    for (i = 0; i < n-1; i++) {

        // If we there is a consecutive pair of '1' and
        // '0'(in respective order)
        if ((arr[i] == 1) && (arr[i + 1] == 0)) {

            // We increment our returning variable by 1
            changes++;
        }
    }

    // After the loop ends, we check the last element
    // whether it is '1'
    if (arr[n - 1] == 1) {
        changes++;

        // If it is '1', we again increment our
        // returning variable by 1
    }

    return changes;
}

// Driver code
int main()
{
    int arr[] = { 1, 1, 0, 0, 0, 1, 0, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Minimum operations: "
         << minimumChanges(arr, n);

    return 0;
}

// This code is contributed by yashbro

Java

// Java program to find minimum number of
// operations required to make all
// array elements zero
class GFG
{

  // Function to find minimum number of
  // operations required to make all
  // array elements zero
  public static int minimumChanges(int arr[], int n)
  {
    int i;

    // It will maintain total changes
    // required and return as
    // answer
    int changes = 0;

    // We iterate from 0 to n-1
    // We can't iterate from 0 to n as
    // the arr[i+1] will be
    // out of index
    for (i = 0; i < n-1; i++) {

      // If we there is a consecutive pair of '1' and
      // '0'(in respective order)
      if ((arr[i] == 1) && (arr[i + 1] == 0)) {

        // We increment our returning variable by 1
        changes++;
      }
    }

    // After the loop ends, we check the last element
    // whether it is '1'
    if (arr[n - 1] == 1) {
      changes++;

      // If it is '1', we again increment our
      // returning variable by 1
    }

    return changes;
  }

  // Driver code

  public static void main(String[] args)
  {
    int arr[] = { 1, 1, 0, 0, 0, 1, 0, 1, 1 };
    int n = arr.length;

    System.out.println( "Minimum operations: "+ minimumChanges(arr, n));

  }
}

//This code is contributed by sravan kumar

Python3

# Python 3 program to find
# minimum number of operations
# required to make all array
# elements zero

# Function to find minimum number
# of operations required to make
# all array elements zero


def minimumChanges(arr, n):
    # It will maintain total
    # changes required
    changes = 0

    # We iterate from 0 to n-1
    # We can't iterate from 0 to n as the arr[i+1] will be out of index
    for i in range(n - 1):

        # If we there is a consecutive pair of '1' and '0'(in respective order)
        if arr[i] == 1 and arr[i + 1] == 0:
            # We increment our returning variable by 1
            changes += 1

    # After the loop ends, we check the last element whether it is '1'
    if arr[n - 1] == 1:
        changes += 1  # If it is '1', we again increment our returning variable by 1

    return changes


# Driver code
if __name__ == "__main__":
    arr = [1, 1, 0, 0, 0, 1, 0, 1, 1]
    n = len(arr)

    print("Minimum operations:",
          minimumChanges(arr, n))

# This code is contributed by yashbro

C#

// C# program to find minimum number of
// operations required to make all
// array elements zero
using System;
class GFG
{

  // Function to find minimum number of
  // operations required to make all
  // array elements zero
  static int minimumChanges(int[] arr, int n)
  {
    int i;

    // It will maintain total changes
    // required and return as
    // answer
    int changes = 0;

    // We iterate from 0 to n-1
    // We can't iterate from 0 to n as
    // the arr[i+1] will be
    // out of index
    for (i = 0; i < n - 1; i++) {

      // If we there is a consecutive pair of '1' and
      // '0'(in respective order)
      if ((arr[i] == 1) && (arr[i + 1] == 0)) {

        // We increment our returning variable by 1
        changes++;
      }
    }

    // After the loop ends, we check the last element
    // whether it is '1'
    if (arr[n - 1] == 1) {
      changes++;

      // If it is '1', we again increment our
      // returning variable by 1
    }

    return changes;
  }

  // Driver code
  public static int Main()
  {
    int[] arr = { 1, 1, 0, 0, 0, 1, 0, 1, 1 };
    int n = arr.Length;

    Console.Write("Minimum operations: "
                  + minimumChanges(arr, n));
    return 0;
  }
}
// This code is contributed by Taranpreet

Javascript

<script>
// Js program to find minimum number of
// operations required to make all
// array elements zero

// Function to find minimum number of
// operations required to make all
// array elements zero
function minimumChanges( arr, n)
{
    let i;

    // It will maintain total changes
    // required and return as
    // answer
    let changes = 0;

    // We iterate from 0 to n-1
    // We can't iterate from 0 to n as
    // the arr[i+1] will be
    // out of index
    for (i = 0; i < n-1; i++) {

        // If we there is a consecutive pair of '1' and
        // '0'(in respective order)
        if ((arr[i] == 1) && (arr[i + 1] == 0)) {

            // We increment our returning variable by 1
            changes++;
        }
    }

    // After the loop ends, we check the last element
    // whether it is '1'
    if (arr[n - 1] == 1) {
        changes++;

        // If it is '1', we again increment our
        // returning variable by 1
    }

    return changes;
}

// Driver code
let arr= [1, 1, 0, 0, 0, 1, 0, 1, 1];
let n =arr.length;
document.write("Minimum operations: "
         , minimumChanges(arr, n));

</script>

Output

Minimum operations: 3

Complexity Analysis:

• Time complexity: O(N), where N represents the size of the given array.
• Auxiliary Space: O(1), no extra space is required, so it is a constant.