GeeksforGeeks App
Open App
Browser
Continue

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

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

 `

## Javascript

 ``

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

 ``

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.

My Personal Notes arrow_drop_up