Find the number of zeroes

Given an array of 1s and 0s which has all 1s first followed by all 0s. Find the number of 0s. Count the number of zeroes in the given array.

Examples :

Input: arr[] = {1, 1, 1, 1, 0, 0}
Output: 2

Input: arr[] = {1, 0, 0, 0, 0}
Output: 4

Input: arr[] = {0, 0, 0}
Output: 3

Input: arr[] = {1, 1, 1, 1}
Output: 0

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

A simple solution is to traverse the input array. As soon as we find a 0, we return n – index of first 0. Here n is number of elements in input array. Time complexity of this solution would be O(n).

Since the input array is sorted, we can use Binary Search to find the first occurrence of 0. Once we have index of first element, we can return count as n – index of first zero.

C

// A divide and conquer solution to find count of zeroes in an array 
// where all 1s are present before all 0s 
#include <stdio.h> 
  
/* if 0 is present in arr[] then returns the index of FIRST occurrence 
   of 0 in arr[low..high], otherwise returns -1 */
int firstZero(int arr[], int low, int high) 
{ 
    if (high >= low) 
    { 
        // Check if mid element is first 0 
        int mid = low + (high - low)/2; 
        if (( mid == 0 || arr[mid-1] == 1) && arr[mid] == 0) 
            return mid; 
  
        if (arr[mid] == 1)  // If mid element is not 0 
            return firstZero(arr, (mid + 1), high); 
        else  // If mid element is 0, but not first 0 
            return firstZero(arr, low, (mid -1)); 
    } 
    return -1; 
} 
  
// A wrapper over recursive function firstZero() 
int countZeroes(int arr[], int n) 
{ 
    // Find index of first zero in given array 
    int first = firstZero(arr, 0, n-1); 
  
    // If 0 is not present at all, return 0 
    if (first == -1) 
        return 0; 
  
    return (n - first); 
} 
  
/* Driver program to check above functions */
int main() 
{ 
    int arr[] =   {1, 1, 1, 0, 0, 0, 0, 0}; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    printf("Count of zeroes is %d", countZeroes(arr, n)); 
    return 0; 
} 

C++

// A divide and conquer solution to  
// find count of zeroes in an array 
// where all 1s are present before all 0s 
#include <bits/stdc++.h> 
using namespace std; 
  
/* if 0 is present in arr[] then 
returns the index of FIRST occurrence 
of 0 in arr[low..high], otherwise returns -1 */
int firstZero(int arr[], int low, int high) 
{ 
    if (high >= low) 
    { 
        // Check if mid element is first 0 
        int mid = low + (high - low) / 2; 
        if ((mid == 0 || arr[mid - 1] == 1) &&  
                         arr[mid] == 0) 
            return mid; 
  
        // If mid element is not 0 
        if (arr[mid] == 1)  
            return firstZero(arr, (mid + 1), high); 
          
        // If mid element is 0, but not first 0     
        else 
            return firstZero(arr, low, (mid -1)); 
    } 
    return -1; 
} 
  
// A wrapper over recursive function firstZero() 
int countZeroes(int arr[], int n) 
{ 
    // Find index of first zero in given array 
    int first = firstZero(arr, 0, n - 1); 
  
    // If 0 is not present at all, return 0 
    if (first == -1) 
        return 0; 
  
    return (n - first); 
} 
  
// Driver Code 
int main() 
{ 
    int arr[] = {1, 1, 1, 0, 0, 0, 0, 0}; 
    int n = sizeof(arr) / sizeof(arr[0]); 
    cout << "Count of zeroes is "
         << countZeroes(arr, n); 
    return 0; 
} 
  
// This code is contributed by SoumikMondal 

Java

// A divide and conquer solution to find count of zeroes in an array 
// where all 1s are present before all 0s 
  
class CountZeros  
{ 
    /* if 0 is present in arr[] then returns the index of FIRST occurrence 
       of 0 in arr[low..high], otherwise returns -1 */
    int firstZero(int arr[], int low, int high)  
    { 
        if (high >= low)  
        { 
            // Check if mid element is first 0 
            int mid = low + (high - low) / 2; 
            if ((mid == 0 || arr[mid - 1] == 1) && arr[mid] == 0) 
                return mid; 
  
            if (arr[mid] == 1) // If mid element is not 0 
                return firstZero(arr, (mid + 1), high); 
            else // If mid element is 0, but not first 0 
                return firstZero(arr, low, (mid - 1)); 
        } 
        return -1; 
    } 
  
    // A wrapper over recursive function firstZero() 
    int countZeroes(int arr[], int n)  
    { 
        // Find index of first zero in given array 
        int first = firstZero(arr, 0, n - 1); 
  
        // If 0 is not present at all, return 0 
        if (first == -1) 
            return 0; 
  
        return (n - first); 
    } 
  
    // Driver program to test above functions 
    public static void main(String[] args)  
    { 
        CountZeros count = new CountZeros(); 
        int arr[] = {1, 1, 1, 0, 0, 0, 0, 0}; 
        int n = arr.length; 
        System.out.println("Count of zeroes is " + count.countZeroes(arr, n)); 
    } 
} 

Python3

# A divide and conquer solution to 
# find count of zeroes in an array 
# where all 1s are present before all 0s 
  
# if 0 is present in arr[] then returns 
# the index of FIRST occurrence of 0 in 
# arr[low..high], otherwise returns -1  
def firstZero(arr, low, high): 
  
    if (high >= low): 
      
        # Check if mid element is first 0 
        mid = low + int((high - low) / 2) 
        if (( mid == 0 or arr[mid-1] == 1) 
                      and arr[mid] == 0): 
            return mid 
          
        # If mid element is not 0 
        if (arr[mid] == 1):  
            return firstZero(arr, (mid + 1), high) 
              
        # If mid element is 0, but not first 0 
        else:  
            return firstZero(arr, low, (mid - 1)) 
      
    return -1
  
# A wrapper over recursive 
# function firstZero() 
def countZeroes(arr, n): 
  
    # Find index of first zero in given array 
    first = firstZero(arr, 0, n - 1) 
  
    # If 0 is not present at all, return 0 
    if (first == -1): 
        return 0
  
    return (n - first) 
  
# Driver Code 
arr = [1, 1, 1, 0, 0, 0, 0, 0] 
n = len(arr) 
print("Count of zeroes is", 
        countZeroes(arr, n)) 
  
# This code is contributed by Smitha Dinesh Semwal 

C#

// A divide and conquer solution to find  
// count of zeroes in an array where all 
// 1s are present before all 0s 
using System; 
  
class CountZeros  
{ 
    /* if 0 is present in arr[] then returns 
       the index of FIRST occurrence of 0 in 
       arr[low..high], otherwise returns -1 */
    int firstZero(int []arr, int low, int high)  
    { 
        if (high >= low)  
        { 
            // Check if mid element is first 0 
            int mid = low + (high - low) / 2; 
            if ((mid == 0 || arr[mid - 1] == 1) && 
                                 arr[mid] == 0) 
                return mid; 
  
            if (arr[mid] == 1) // If mid element is not 0 
                return firstZero(arr, (mid + 1), high); 
                  
            else // If mid element is 0, but not first 0 
                return firstZero(arr, low, (mid - 1)); 
        } 
        return -1; 
    } 
  
    // A wrapper over recursive function firstZero() 
    int countZeroes(int []arr, int n)  
    { 
        // Find index of first zero in given array 
        int first = firstZero(arr, 0, n - 1); 
  
        // If 0 is not present at all, return 0 
        if (first == -1) 
            return 0; 
  
        return (n - first); 
    } 
  
    // Driver program to test above functions 
    public static void Main()  
    { 
        CountZeros count = new CountZeros(); 
        int []arr = {1, 1, 1, 0, 0, 0, 0, 0}; 
        int n = arr.Length; 
        Console.Write("Count of zeroes is " +  
                       count.countZeroes(arr, n)); 
    } 
} 
  
// This code is contributed by nitin mittal. 

PHP

<?php 
// A divide and conquer solution to  
// find count of zeroes in an array 
// where all 1s are present before all 0s 
  
/* if 0 is present in arr[] then 
   returns the index of FIRST  
   occurrence of 0 in arr[low..high],  
   otherwise returns -1 */
function firstZero($arr, $low, $high) 
{ 
    if ($high >= $low) 
    { 
          
        // Check if mid element is first 0 
        $mid = $low + floor(($high - $low)/2); 
          
        if (( $mid == 0 || $arr[$mid-1] == 1) &&  
                                 $arr[$mid] == 0) 
            return $mid; 
  
        // If mid element is not 0 
        if ($arr[$mid] == 1)  
            return firstZero($arr, ($mid + 1), $high); 
          
        // If mid element is 0, 
        // but not first 0     
        else
            return firstZero($arr, $low,  
                            ($mid - 1)); 
    } 
    return -1; 
} 
  
// A wrapper over recursive 
// function firstZero() 
function countZeroes($arr, $n) 
{ 
      
    // Find index of first  
    // zero in given array 
    $first = firstZero($arr, 0, $n - 1); 
  
    // If 0 is not present 
    // at all, return 0 
    if ($first == -1) 
        return 0; 
  
    return ($n - $first); 
} 
      
    // Driver Code 
    $arr = array(1, 1, 1, 0, 0, 0, 0, 0); 
    $n = sizeof($arr); 
    echo("Count of zeroes is ");  
    echo(countZeroes($arr, $n)); 
      
// This code is contributed by nitin mittal 
?> 

Output:

Count of zeroes is 5

Time Complexity: O(Logn) where n is number of elements in arr[].

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes

Nov	DEC	Jan
	04
2019	2020	2021

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

C

C++

Java

Python3

C#

PHP

Recommended Posts: