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++
#include <bits/stdc++.h>
using namespace std;
int minimumChanges( int arr[], int n)
{
int i;
int changes = 0;
for (i = 0; i < n; i++)
{
if (arr[i] == 1)
{
int j;
for (j = i+1; j<n; j++)
{
if (arr[j]==0)
break ;
}
i = j-1;
changes++;
}
}
return changes;
}
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
class GFG
{
static int minimumChanges( int arr[],
int n)
{
int i;
int changes = 0 ;
for (i = 0 ; i < n; i++)
{
if (arr[i] == 1 )
{
int j;
for (j = i + 1 ; j < n; j++)
{
if (arr[j] == 0 )
break ;
}
i = j - 1 ;
changes++;
}
}
return changes;
}
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));
}
}
|
Python 3
def minimumChanges(arr, n) :
changes = 0
i = 0
while i < n :
if arr[i] = = 1 :
j = i + 1
while j < n:
if arr[j] = = 0 :
break
j + = 1
i = j - 1
changes + = 1
i + = 1
return changes
if __name__ = = "__main__" :
arr = [ 1 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 1 ]
n = len (arr)
print ( "Minimum operations:" ,
minimumChanges(arr, n))
|
C#
class GFG
{
static int minimumChanges( int [] arr,
int n)
{
int i;
int changes = 0;
for (i = 0; i < n; i++)
{
if (arr[i] == 1)
{
int j;
for (j = i + 1; j < n; j++)
{
if (arr[j] == 0)
break ;
}
i = j - 1;
changes++;
}
}
return changes;
}
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));
}
}
|
PHP
<?php
function minimumChanges( $arr , $n )
{
$i ;
$changes = 0;
for ( $i = 0; $i < $n ; $i ++)
{
if ( $arr [ $i ] == 1)
{
$j ;
for ( $j = $i + 1; $j < $n ; $j ++)
{
if ( $arr [ $j ] == 0)
break ;
}
$i = $j - 1;
$changes ++;
}
}
return $changes ;
}
$arr = array ( 1, 1, 0, 0, 0,
1, 0, 1, 1 );
$n = sizeof( $arr );
echo "Minimum operations: " .
minimumChanges( $arr , $n );
|
Javascript
<script>
function minimumChanges(arr, n)
{
var i;
var changes = 0;
for (i = 0; i < n; i++)
{
if (arr[i] == 1)
{
var j;
for (j = i+1; j<n; j++)
{
if (arr[j]==0)
break ;
}
i = j-1;
changes++;
}
}
return changes;
}
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:
- 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++
#include <bits/stdc++.h>
using namespace std;
int minimumChanges( int arr[], int n)
{
int i;
int changes = 0;
for (i = 0; i < n-1; i++) {
if ((arr[i] == 1) && (arr[i + 1] == 0)) {
changes++;
}
}
if (arr[n - 1] == 1) {
changes++;
}
return changes;
}
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
class GFG
{
public static int minimumChanges( int arr[], int n)
{
int i;
int changes = 0 ;
for (i = 0 ; i < n- 1 ; i++) {
if ((arr[i] == 1 ) && (arr[i + 1 ] == 0 )) {
changes++;
}
}
if (arr[n - 1 ] == 1 ) {
changes++;
}
return changes;
}
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));
}
}
|
Python3
def minimumChanges(arr, n):
changes = 0
for i in range (n - 1 ):
if arr[i] = = 1 and arr[i + 1 ] = = 0 :
changes + = 1
if arr[n - 1 ] = = 1 :
changes + = 1
return changes
if __name__ = = "__main__" :
arr = [ 1 , 1 , 0 , 0 , 0 , 1 , 0 , 1 , 1 ]
n = len (arr)
print ( "Minimum operations:" ,
minimumChanges(arr, n))
|
C#
using System;
class GFG
{
static int minimumChanges( int [] arr, int n)
{
int i;
int changes = 0;
for (i = 0; i < n - 1; i++) {
if ((arr[i] == 1) && (arr[i + 1] == 0)) {
changes++;
}
}
if (arr[n - 1] == 1) {
changes++;
}
return changes;
}
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;
}
}
|
Javascript
<script>
function minimumChanges( arr, n)
{
let i;
let changes = 0;
for (i = 0; i < n-1; i++) {
if ((arr[i] == 1) && (arr[i + 1] == 0)) {
changes++;
}
}
if (arr[n - 1] == 1) {
changes++;
}
return changes;
}
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.
Last Updated :
02 Sep, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...