Skip to content
Related Articles

Related Articles

Improve Article

Count 1’s in a sorted binary array

  • Difficulty Level : Easy
  • Last Updated : 20 Jul, 2021

Given a binary array sorted in non-increasing order, count the number of 1’s in it. 

Examples: 

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

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

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

A simple solution is to linearly traverse the array. The time complexity of the simple solution is O(n). We can use Binary Search to find count in O(Logn) time. The idea is to look for last occurrence of 1 using Binary Search. Once we find the index last occurrence, we return index + 1 as count.
The following is the implementation of above idea. 

C++




// C++ program to count one's in a boolean array
#include <bits/stdc++.h>
using namespace std;
 
/* Returns counts of 1's in arr[low..high].  The array is
   assumed to be sorted in non-increasing order */
int countOnes(bool arr[], int low, int high)
{
  if (high >= low)
  {
    // get the middle index
    int mid = low + (high - low)/2;
 
    // check if the element at middle index is last 1
    if ( (mid == high || arr[mid+1] == 0) && (arr[mid] == 1))
      return mid+1;
 
    // If element is not last 1, recur for right side
    if (arr[mid] == 1)
      return countOnes(arr, (mid + 1), high);
 
    // else recur for left side
    return countOnes(arr, low, (mid -1));
  }
  return 0;
}
 
/* Driver Code */
int main()
{
   bool arr[] = {1, 1, 1, 1, 0, 0, 0};
   int n = sizeof(arr)/sizeof(arr[0]);
   cout << "Count of 1's in given array is " << countOnes(arr, 0, n-1);
   return 0;
}

Python




# Python program to count one's in a boolean array
 
# Returns counts of 1's in arr[low..high].  The array is
# assumed to be sorted in non-increasing order
def countOnes(arr,low,high):
     
    if high>=low:
         
        # get the middle index
        mid = low + (high-low)//2
         
        # check if the element at middle index is last 1
        if ((mid == high or arr[mid+1]==0) and (arr[mid]==1)):
            return mid+1
             
        # If element is not last 1, recur for right side
        if arr[mid]==1:
            return countOnes(arr, (mid+1), high)
             
        # else recur for left side
        return countOnes(arr, low, mid-1)
     
    return 0
 
# Driver Code
arr=[1, 1, 1, 1, 0, 0, 0]
print ("Count of 1's in given array is",countOnes(arr, 0 , len(arr)-1))
 
# This code is contributed by __Devesh Agrawal__

Java




// Java program to count 1's in a sorted array
class CountOnes
{
    /* Returns counts of 1's in arr[low..high].  The
       array is assumed to be sorted in non-increasing
       order */
    int countOnes(int arr[], int low, int high)
    {
        if (high >= low)
        {
            // get the middle index
            int mid = low + (high - low) / 2;
 
            // check if the element at middle index is last
            // 1
            if ((mid == high || arr[mid + 1] == 0)
                && (arr[mid] == 1))
                return mid + 1;
 
            // If element is not last 1, recur for right
            // side
            if (arr[mid] == 1)
                return countOnes(arr, (mid + 1), high);
 
            // else recur for left side
            return countOnes(arr, low, (mid - 1));
        }
        return 0;
    }
 
    /* Driver code */
    public static void main(String args[])
    {
        CountOnes ob = new CountOnes();
        int arr[] = { 1, 1, 1, 1, 0, 0, 0 };
        int n = arr.length;
        System.out.println("Count of 1's in given array is "
                           + ob.countOnes(arr, 0, n - 1));
    }
}
/* This code is contributed by Rajat Mishra */

C#




// C# program to count 1's in a sorted array
using System;
 
class GFG {
 
    /* Returns counts of 1's in arr[low..high].
    The array is assumed to be sorted in
    non-increasing order */
    static int countOnes(int[] arr, int low, int high)
    {
        if (high >= low)
        {
            // get the middle index
            int mid = low + (high - low) / 2;
 
            // check if the element at middle
            // index is last 1
            if ((mid == high || arr[mid + 1] == 0)
                && (arr[mid] == 1))
                return mid + 1;
 
            // If element is not last 1, recur
            // for right side
            if (arr[mid] == 1)
                return countOnes(arr, (mid + 1), high);
 
            // else recur for left side
            return countOnes(arr, low, (mid - 1));
        }
 
        return 0;
    }
 
    /* Driver code */
    public static void Main()
    {
        int[] arr = { 1, 1, 1, 1, 0, 0, 0 };
        int n = arr.Length;
 
        Console.WriteLine("Count of 1's in given "
                          + "array is "
                          + countOnes(arr, 0, n - 1));
    }
}
 
// This code is contributed by Sam007

PHP




<?php
// PHP program to count one's in a
// boolean array
 
/* Returns counts of 1's in arr[low..high].
The array is assumed to be sorted in
non-increasing order */
function countOnes( $arr, $low, $high)
{
    if ($high >= $low)
    {
        // get the middle index
        $mid = $low + ($high - $low)/2;
     
        // check if the element at middle
        // index is last 1
        if ( ($mid == $high or $arr[$mid+1] == 0)
                           and ($arr[$mid] == 1))
            return $mid+1;
     
        // If element is not last 1, recur for
        // right side
        if ($arr[$mid] == 1)
            return countOnes($arr, ($mid + 1),
                                          $high);
     
        // else recur for left side
        return countOnes($arr, $low, ($mid -1));
    }
     
    return 0;
}
 
/* Driver code */
$arr = array(1, 1, 1, 1, 0, 0, 0);
$n = count($arr);
echo "Count of 1's in given array is " ,
                      countOnes($arr, 0, $n-1);
 
// This code is contributed by anuj_67.
?>

Javascript




<script>
 
// Javascript program to count one's in a boolean array
 
/* Returns counts of 1's in arr[low..high].  The array is
   assumed to be sorted in non-increasing order */
function countOnes( arr, low, high)
{
  if (high >= low)
  {
    // get the middle index
    let mid = Math.trunc(low + (high - low)/2);
 
    // check if the element at middle index is last 1
    if ( (mid == high || arr[mid+1] == 0) && (arr[mid] == 1))
      return mid+1;
 
    // If element is not last 1, recur for right side
    if (arr[mid] == 1)
      return countOnes(arr, (mid + 1), high);
 
    // else recur for left side
    return countOnes(arr, low, (mid -1));
  }
  return 0;
}
    // Driver program
     
   let arr = [ 1, 1, 1, 1, 0, 0, 0 ];
   let n = arr.length;
   document.write("Count of 1's in given array is " +
                    countOnes(arr, 0, n-1));
     
</script>
Output
Count of 1's in given array is 4

Time complexity of the above solution is O(Logn)



Space complexity o(log n) (function call stack)

The same approach with iterative solution would be

C++




#include <bits/stdc++.h>
using namespace std;
/* Returns counts of 1's in arr[low..high].  The array is
   assumed to be sorted in non-increasing order */
 
int countOnes(bool arr[], int n)
{
    int ans;
    int low = 0, high = n - 1;
    while (low <= high) { // get the middle index
        int mid = (low + high) / 2;
 
        // else recur for left side
        if (arr[mid] < 1)
            high = mid - 1;
        // If element is not last 1, recur for right side
        else if (arr[mid] > 1)
            low = mid + 1;
        else
        // check if the element at middle index is last 1
        {
            if (mid == n - 1 || arr[mid + 1] != 1)
                return mid + 1;
            else
                low = mid + 1;
        }
    }
}
 
int main()
{
    bool arr[] = { 1, 1, 1, 1, 0, 0, 0 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Count of 1's in given array is "
         << countOnes(arr, n);
    return 0;
}

Java




/*package whatever //do not write package name here */
import java.io.*;
 
class GFG
{
     
static int countOnes(int arr[], int n)
{
    int ans;
    int low = 0, high = n - 1;
    while (low <= high) { // get the middle index
        int mid = (low + high) / 2;
  
        // else recur for left side
        if (arr[mid] < 1)
            high = mid - 1;
       
        // If element is not last 1, recur for right side
        else if (arr[mid] > 1)
            low = mid + 1;
        else
           
        // check if the element at middle index is last 1
        {
            if (mid == n - 1 || arr[mid + 1] != 1)
                return mid + 1;
            else
                low = mid + 1;
        }
    }
    return 0;
}
     
  // Driver code
    public static void main (String[] args) {
         
        int arr[] = { 1, 1, 1, 1, 0, 0, 0 };
        int n = arr.length;
         
        System.out.println("Count of 1's in given array is "+ countOnes(arr, n));
    }
}
 
// This code is contributed by patel2127.

Javascript




<script>
/* Returns counts of 1's in arr[low..high].  The array is
   assumed to be sorted in non-increasing order */
 
function countOnes(arr,n)
{
    let ans;
    let low = 0, high = n - 1;
    while (low <= high) { // get the middle index
        let mid = Math.floor((low + high) / 2);
  
        // else recur for left side
        if (arr[mid] < 1)
            high = mid - 1;
        // If element is not last 1, recur for right side
        else if (arr[mid] > 1)
            low = mid + 1;
        else
        // check if the element at middle index is last 1
        {
            if (mid == n - 1 || arr[mid + 1] != 1)
                return mid + 1;
            else
                low = mid + 1;
        }
    }
}
 
let arr=[ 1, 1, 1, 1, 0, 0, 0];
let n = arr.length;
document.write( "Count of 1's in given array is "+ countOnes(arr, n));
 
 
// This code is contributed by unknown2108
</script>
Output
Count of 1's in given array is 4

Time complexity of the above solution is O(Logn)

Space complexity is O(1)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :