Minimum no. of operations required to make all Array Elements Zero
Last Updated :
02 Sep, 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 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 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 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# 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 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)
<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>
OutputMinimum 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:
- 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.
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 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
# 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# 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
<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>
OutputMinimum 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.
Similar Reads
Minimum operations required to make all the array elements equal
Given an array arr[] of n integer and an integer k. The task is to count the minimum number of times the given operation is required to make all the array elements equal. In a single operation, the kth element of the array is appended at the end of the array and the first element of the array gets d
6 min read
Minimum operations required to make all elements of Array less than equal to 0
Given an array arr[] consisting of N positive numbers, the task is to find the minimum number of operations required to make all elements of the array less than or equal to 0. In each operation, one has to pick the minimum positive element from the array and subtract all the elements of the array fr
5 min read
Find the minimum number of operations required to make all array elements equal
Given an array arr[] of size N. The task is to make all the array elements equal by applying the below operations minimum number of times: Choose a pair of indices (i, j) such that |i - j| = 1 (indices i and j are adjacent) and set arr[i] = arr[i] + |arr[i] - arr[j]|Choose a pair of indices (i, j) s
6 min read
Minimum number of operations required to make all elements equal
Given an array arr[] of length N along with an integer M. All the elements of arr[] are in the range [1, N]. Then your task is to output the minimum number of operations required to make all elements equal given that in one operation you can select at most M elements and increment all of them by 1.
5 min read
Minimum number of operations required to delete all elements of the array
Given an integer array arr, the task is to print the minimum number of operations required to delete all elements of the array. In an operation, any element from the array can be chosen at random and every element divisible by it can be removed from the array. Examples: Input: arr[] = {2, 4, 6, 3, 5
9 min read
Minimum operations required to make two elements equal in Array
Given array A[] of size N and integer X, the task is to find the minimum number of operations to make any two elements equal in the array. In one operation choose any element A[i] and replace it with A[i] & X. where & is bitwise AND. If such operations do not exist print -1. Examples: Input:
9 min read
Minimum number of operations required to set all elements of a binary matrix
Given a binary matrix mat[][] consisting of 1s and 0s of dimension M * N, the task is to find the number of operations to convert all 0s to 1s. In each operation, all the 1s can convert their adjacent 0s to 1s.Note: Diagonal elements are not considered as adjacent elements of a number in the matrix.
15+ min read
Minimum gcd operations to make all array elements one
Given an array A[] of size N. You can replace any number in the array with the gcd of that element with any of its adjacent elements. Find the minimum number of such operation to make the element of whole array equal to 1. If its not possible print -1. Examples: Input : A[] = {4, 8, 9} Output : 3 Ex
8 min read
Minimum number of operations required to make all the elements positive
Given an array A[] of length N. You can apply the below operation: Choose an index i such that (i+1) element exists. After that choose any number X (positive or negative). Then subtract X from the ith element and add it into (i+1)th element.The task is to find the minimum number of operations requir
9 min read
Find the number of operations required to make all array elements Equal
Given an array of N integers, the task is to find the number of operations required to make all elements in the array equal. In one operation we can distribute equal weights from the maximum element to the rest of the array elements. If it is not possible to make the array elements equal after perfo
6 min read