Skip to content
Related Articles

Related Articles

Minimum no. of operations required to make all Array Elements Zero
  • Difficulty Level : Easy
  • Last Updated : 17 Mar, 2021

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

Time Complexity : O(n2



Below is the implementation of above approach:  

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)
Output: 
Minimum operations: 3

 

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.

Below is the implementation of the above approach:

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

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
Output
Minimum operations: 3

Time complexity : O(N)

 
 
My Personal Notes arrow_drop_up
Recommended Articles
Page :