# Count 1’s in a sorted binary array

• Difficulty Level : Easy
• Last Updated : 13 Jul, 2022

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 ``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);``   ``cout << ``"Count of 1's in given array is "` `<< countOnes(arr, 0, n-1);``   ``return` `0;``}`

## Python3

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

 `= ``\$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

 ``

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 ``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);``    ``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.`

## Python3

 `'''package whatever #do not write package name here '''``def` `countOnes(arr, n):``    ``low ``=` `0``;``    ``high ``=` `n ``-` `1``;``    ``while` `(low <``=` `high): ``# get the middle index``        ``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``        ``elif``(arr[mid] > ``1``):``            ``low ``=` `mid ``+` `1``;``        ``else``:`` ` `        ``# check if the element at middle index is last 1``            ``if` `(mid ``=``=` `n ``-` `1` `or` `arr[mid ``+` `1``] !``=` `1``):``                ``return` `mid ``+` `1``;``            ``else``:``                ``low ``=` `mid ``+` `1``;``         ` `    ``return` `0``;`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``arr ``=` `[ ``1``, ``1``, ``1``, ``1``, ``0``, ``0``, ``0` `];``    ``n ``=` `len``(arr);`` ` `    ``print``(``"Count of 1's in given array is "` `, countOnes(arr, n));`` ` `# This code is contributed by umadevi9616`

## C#

 `/*package whatever //do not write package name here */``using` `System;``public` `class` `GFG {`` ` `  ``static` `int` `countOnes(``int` `[]arr, ``int` `n) {`` ` `    ``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;`` ` `    ``Console.WriteLine(``"Count of 1's in given array is "` `+ countOnes(arr, n));``  ``}``}`` ` `// This code is contributed by umadevi9616`

## Javascript

 ``

Output

`Count of 1's in given array is 4`

Time complexity of the above solution is O(Logn)

Space complexity is O(1)

### Method 2: Using C++ STL  upper_bound()

The function will return the pointer to the index after the last occurrence of the element which we pass into the function.

We can use it here as the array is sorted in non-increasing order.

#### For example:

```int arr[] = {1,1,1,1,0,0,0,0};
int size = sizeof(arr)/sizeof(arr);
auto ptr = upper_bound( arr, arr + size, 1, greater<int>() );```

upper_bound() will return the iterator to the index after the last occurrence of 1.

Here, ptr will point to index 4 of the array, i.e, after the last 1.

We need to use the greater<int>() function since the array is reverse sorted, i.e, 1s occur before 0s.

Now, subtracting the pointer to the array beginning from ptr ( ptr – arr ) will give us the number of 1s.

since the (pointer to first 0 – pointer to array beginning) = number of 1s

just like index of first 0 (4) – index of array beginning (0) = number of 1s

`int no_of_1 = ptr - arr;`

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main()``{`` ` `    ``int` `arr[] = { 1, 1, 1, 1, 0, 0, 0, 0, 0 };``    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr);``     ` `      ``// Pointer to the first occurrence of zero ``   ` `    ``auto` `ptr``        ``= upper_bound(arr, arr + size, 1, greater<``int``>());``    ``cout << ``"Count of 1's in given array is "` `<< (ptr - arr);`` ` `    ``return` `0;``}`

### Output:

`Count of 1's in given array is 4`

The time complexity of the above solution is O(Logn).

Space complexity is O(1).