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

23 May, 2022
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.
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. 
Below is the implementation of above approach:  
C++
Java
Python 3
C#
PHP
Javascript
// 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 zeroint 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 codeint 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 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 zerostatic 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 codepublic 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 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 zerodef 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# program to find minimum// number of operations required// to make all array elements zeroclass GFG{ // Function to find minimum number// of operations required to make// all array elements zerostatic 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 codestatic 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 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 zerofunction 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)
<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 zerofunction 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 codevar arr = [1, 1, 0, 0, 0, 1, 0, 1, 1 ];var n = arr.length; document.write( "Minimum operations: " + minimumChanges(arr, n)); </script>
Minimum operations: 3
 
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: 
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.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.
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.
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++
Java
Python3
C#
Javascript
// 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 zeroint 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 codeint 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 program to find minimum number of// operations required to make all// array elements zeroclass 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
# 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 codeif __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# program to find minimum number of// operations required to make all// array elements zerousing 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
<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 zerofunction 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 codelet arr= [1, 1, 0, 0, 0, 1, 0, 1, 1];let n =arr.length;document.write("Minimum operations: "         , minimumChanges(arr, n)); </script>
Minimum operations: 3
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.
ankthon
Mithun Kumar
Akanksha_Rai
nidhi_biet
yashbro
rrrtnx
rohan07
sravankumar8128
singhh3010
tamanna17122007
Constructive Algorithms
Arrays
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Linear Search
Introduction to Arrays
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
K'th Smallest/Largest Element in Unsorted Array | Set 1
Subset Sum Problem | DP-25
Python | Using 2D arrays/lists the right way