# Count number of occurrences (or frequency) in a sorted array

Given a sorted array arr[] and a number x, write a function that counts the occurrences of x in arr[]. Expected time complexity is O(Logn)

Examples:

```  Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 2
Output: 4 // x (or 2) occurs 4 times in arr[]

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

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

Input: arr[] = {1, 1, 2, 2, 2, 2, 3,},   x = 4
Output: -1 // 4 doesn't occur in arr[] ```

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

Method 1 (Linear Search)
Linearly search for x, count the occurrences of x and return the count.

## C++

 `// C++ program to count occurrences of an element ` `#include ` `using` `namespace` `std; ` ` `  `// Returns number of times x occurs in arr[0..n-1] ` `int` `countOccurrences(``int` `arr[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `res = 0; ` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to count occurrences  ` `// of an element ` ` `  `class` `Main ` `{ ` `    ``// Returns number of times x occurs in arr[0..n-1] ` `    ``static` `int` `countOccurrences(``int` `arr[], ``int` `n, ``int` `x) ` `    ``{ ` `        ``int` `res = ``0``; ` `        ``for` `(``int` `i=``0``; i

## Python3

 `# Python3 program to count  ` `# occurrences of an element ` ` `  `# Returns number of times x  ` `# occurs in arr[0..n-1] ` `def` `countOccurrences(arr, n, x): ` `    ``res ``=` `0` `    ``for` `i ``in` `range``(n): ` `        ``if` `x ``=``=` `arr[i]: ` `            ``res ``+``=` `1` `    ``return` `res ` `  `  `# Driver code ` `arr ``=` `[``1``, ``2``, ``2``, ``2``, ``2``, ``3``, ``4``, ``7` `,``8` `,``8``] ` `n ``=` `len``(arr) ` `x ``=` `2` `print` `(countOccurrences(arr, n, x)) `

## C#

 `// C# program to count occurrences  ` `// of an element ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// Returns number of times x ` `    ``// occurs in arr[0..n-1] ` `    ``static` `int` `countOccurrences(``int` `[]arr, ` `                                ``int` `n, ``int` `x) ` `    ``{ ` `        ``int` `res = 0; ` `         `  `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``if` `(x == arr[i]) ` `            ``res++; ` `             `  `        ``return` `res; ` `    ``} ` `     `  `    ``// driver code     ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = {1, 2, 2, 2, 2, 3, 4, 7 ,8 ,8 }; ` `        ``int` `n = arr.Length; ` `        ``int` `x = 2; ` `         `  `        ``Console.Write(countOccurrences(arr, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## PHP

 ` `

Output :

`4`

Time Complexity: O(n)

Method 2 (Better using Binary Search)
We first find an occurrence using binary search. Then we match toward left and right sides of the matched the found index.

## C++

 `// C++ program to count occurrences of an element ` `#include ` `using` `namespace` `std; ` ` `  `// A recursive binary search function. It returns ` `// location of x in given array arr[l..r] is present, ` `// otherwise -1 ` `int` `binarySearch(``int` `arr[], ``int` `l, ``int` `r, ``int` `x) ` `{ ` `    ``if` `(r < l) ` `        ``return` `-1; ` ` `  `    ``int` `mid = l + (r - l) / 2; ` ` `  `    ``// If the element is present at the middle ` `    ``// itself ` `    ``if` `(arr[mid] == x) ` `        ``return` `mid; ` ` `  `    ``// If element is smaller than mid, then ` `    ``// it can only be present in left subarray ` `    ``if` `(arr[mid] > x) ` `        ``return` `binarySearch(arr, l, mid - 1, x); ` ` `  `    ``// Else the element can only be present ` `    ``// in right subarray ` `    ``return` `binarySearch(arr, mid + 1, r, x); ` `} ` ` `  `// Returns number of times x occurs in arr[0..n-1] ` `int` `countOccurrences(``int` `arr[], ``int` `n, ``int` `x) ` `{ ` `    ``int` `ind = binarySearch(arr, 0, n - 1, x); ` ` `  `    ``// If element is not present ` `    ``if` `(ind == -1) ` `        ``return` `0; ` ` `  `    ``// Count elements on left side. ` `    ``int` `count = 1; ` `    ``int` `left = ind - 1; ` `    ``while` `(left >= 0 && arr[left] == x) ` `        ``count++, left--; ` ` `  `    ``// Count elements on right side. ` `    ``int` `right = ind + 1; ` `    ``while` `(right < n && arr[right] == x) ` `        ``count++, right++; ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `x = 2; ` `    ``cout << countOccurrences(arr, n, x); ` `    ``return` `0; ` `}`

## Java

 `// Java program to count  ` `// occurrences of an element ` `class` `GFG  ` `{ ` ` `  `    ``// A recursive binary search  ` `    ``// function. It returns location  ` `    ``// of x in given array arr[l..r]  ` `    ``// is present, otherwise -1 ` `    ``static` `int` `binarySearch(``int` `arr[], ``int` `l, ` `                            ``int` `r, ``int` `x) ` `    ``{ ` `        ``if` `(r < l) ` `            ``return` `-``1``; ` ` `  `        ``int` `mid = l + (r - l) / ``2``; ` ` `  `        ``// If the element is present  ` `        ``// at the middle itself ` `        ``if` `(arr[mid] == x) ` `            ``return` `mid; ` ` `  `        ``// If element is smaller than  ` `        ``// mid, then it can only be  ` `        ``// present in left subarray ` `        ``if` `(arr[mid] > x) ` `            ``return` `binarySearch(arr, l,  ` `                                ``mid - ``1``, x); ` ` `  `        ``// Else the element can ` `        ``// only be present in ` `        ``// right subarray ` `        ``return` `binarySearch(arr, mid + ``1``, r, x); ` `    ``} ` ` `  `    ``// Returns number of times x ` `    ``// occurs in arr[0..n-1] ` `    ``static` `int` `countOccurrences(``int` `arr[],  ` `                                ``int` `n, ``int` `x) ` `    ``{ ` `        ``int` `ind = binarySearch(arr, ``0``,  ` `                               ``n - ``1``, x); ` ` `  `        ``// If element is not present ` `        ``if` `(ind == -``1``) ` `            ``return` `0``; ` ` `  `        ``// Count elements on left side. ` `        ``int` `count = ``1``; ` `        ``int` `left = ind - ``1``; ` `        ``while` `(left >= ``0` `&&  ` `               ``arr[left] == x) ` `        ``{ ` `            ``count++; ` `            ``left--; ` `        ``} ` ` `  `        ``// Count elements  ` `        ``// on right side. ` `        ``int` `right = ind + ``1``; ` `        ``while` `(right < n &&  ` `               ``arr[right] == x) ` `        ``{ ` `            ``count++; ` `            ``right++; ` `        ``} ` ` `  `        ``return` `count; ` `    ``} ` ` `  ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `arr[] = {``1``, ``2``, ``2``, ``2``, ``2``,  ` `                     ``3``, ``4``, ``7``, ``8``, ``8``}; ` `        ``int` `n = arr.length; ` `        ``int` `x = ``2``; ` `        ``System.out.print(countOccurrences(arr, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

## Python 3

 `# Python 3 program to count  ` `# occurrences of an element ` ` `  `# A recursive binary search  ` `# function. It returns location ` `# of x in given array arr[l..r]  ` `# is present, otherwise -1 ` `def` `binarySearch(arr, l, r, x): ` `    ``if` `(r < l): ` `        ``return` `-``1` ` `  `    ``mid ``=` `int``( l ``+` `(r ``-` `l) ``/` `2``) ` ` `  `    ``# If the element is present  ` `    ``# at the middle itself ` `    ``if` `arr[mid] ``=``=` `x: ` `        ``return` `mid ` ` `  `    ``# If element is smaller than  ` `    ``# mid, then it can only be ` `    ``# present in left subarray ` `    ``if` `arr[mid] > x: ` `        ``return` `binarySearch(arr, l,  ` `                            ``mid ``-` `1``, x) ` ` `  `    ``# Else the element  ` `    ``# can only be present ` `    ``# in right subarray ` `    ``return` `binarySearch(arr, mid ``+` `1``, ` `                                ``r, x) ` ` `  `# Returns number of times  ` `# x occurs in arr[0..n-1] ` `def` `countOccurrences(arr, n, x): ` `    ``ind ``=` `binarySearch(arr, ``0``, n ``-` `1``, x) ` ` `  `    ``# If element is not present ` `    ``if` `ind ``=``=` `-``1``: ` `        ``return` `0` ` `  `    ``# Count elements  ` `    ``# on left side. ` `    ``count ``=` `1` `    ``left ``=` `ind ``-` `1` `    ``while` `(left >``=` `0` `and`  `           ``arr[left] ``=``=` `x): ` `        ``count ``+``=` `1` `        ``left ``-``=` `1` ` `  `    ``# Count elements on ` `    ``# right side. ` `    ``right ``=` `ind ``+` `1``; ` `    ``while` `(right < n ``and` `           ``arr[right] ``=``=` `x): ` `        ``count ``+``=` `1` `        ``right ``+``=` `1` ` `  `    ``return` `count ` ` `  `# Driver code ` `arr ``=` `[ ``1``, ``2``, ``2``, ``2``, ``2``,  ` `        ``3``, ``4``, ``7``, ``8``, ``8` `] ` `n ``=` `len``(arr) ` `x ``=` `2` `print``(countOccurrences(arr, n, x)) ` ` `  `# This code is contributed  ` `# by ChitraNayal `

## C#

 `// C# program to count  ` `// occurrences of an element ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// A recursive binary search  ` `    ``// function. It returns location ` `    ``// of x in given array arr[l..r]  ` `    ``// is present, otherwise -1 ` `    ``static` `int` `binarySearch(``int``[] arr, ``int` `l,  ` `                            ``int` `r, ``int` `x) ` `    ``{ ` `        ``if` `(r < l) ` `            ``return` `-1; ` ` `  `        ``int` `mid = l + (r - l) / 2; ` ` `  `        ``// If the element is present  ` `        ``// at the middle itself ` `        ``if` `(arr[mid] == x) ` `            ``return` `mid; ` ` `  `        ``// If element is smaller than  ` `        ``// mid, then it can only be  ` `        ``// present in left subarray ` `        ``if` `(arr[mid] > x) ` `            ``return` `binarySearch(arr, l,  ` `                                ``mid - 1, x); ` ` `  `        ``// Else the element  ` `        ``// can only be present ` `        ``// in right subarray ` `        ``return` `binarySearch(arr, mid + 1, ` `                                   ``r, x); ` `    ``} ` ` `  `    ``// Returns number of times x  ` `    ``// occurs in arr[0..n-1] ` `    ``static` `int` `countOccurrences(``int``[] arr,  ` `                                ``int` `n, ``int` `x) ` `    ``{ ` `        ``int` `ind = binarySearch(arr, 0,  ` `                               ``n - 1, x); ` ` `  `        ``// If element is not present ` `        ``if` `(ind == -1) ` `            ``return` `0; ` ` `  `        ``// Count elements on left side. ` `        ``int` `count = 1; ` `        ``int` `left = ind - 1; ` `        ``while` `(left >= 0 &&  ` `               ``arr[left] == x) ` `        ``{ ` `            ``count++; ` `            ``left--; ` `        ``} ` ` `  `        ``// Count elements on right side. ` `        ``int` `right = ind + 1; ` `        ``while` `(right < n &&  ` `               ``arr[right] == x) ` `        ``{ ` `            ``count++; ` `            ``right++; ` `        ``} ` ` `  `        ``return` `count; ` `    ``} ` ` `  ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``int``[] arr = {1, 2, 2, 2, 2,  ` `                     ``3, 4, 7, 8, 8}; ` `        ``int` `n = arr.Length; ` `        ``int` `x = 2; ` `        ``Console.Write(countOccurrences(arr, n, x)); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

## PHP

 ` ``\$x``) ` `        ``return` `binarySearch(``\$arr``, ``\$l``,    ` `                            ``\$mid` `- 1, ``\$x``); ` ` `  `    ``// Else the element ` `    ``// can only be present ` `    ``// in right subarray ` `    ``return` `binarySearch(``\$arr``, ``\$mid` `+ 1,  ` `                                ``\$r``, ``\$x``); ` `} ` ` `  `// Returns number of times ` `// x occurs in arr[0..n-1] ` `function` `countOccurrences(``\$arr``, ``\$n``, ``\$x``) ` `{ ` `    ``\$ind` `= binarySearch(``\$arr``, 0,  ` `                        ``\$n` `- 1, ``\$x``); ` ` `  `    ``// If element is not present ` `    ``if` `(``\$ind` `== -1) ` `        ``return` `0; ` ` `  `    ``// Count elements  ` `    ``// on left side. ` `    ``\$count` `= 1; ` `    ``\$left` `= ``\$ind` `- 1; ` `    ``while` `(``\$left` `>= 0 &&  ` `           ``\$arr``[``\$left``] == ``\$x``) ` `    ``{  ` `        ``\$count``++; ` `        ``\$left``--; ` `    ``} ` `     `  `    ``// Count elements on right side. ` `    ``\$right` `= ``\$ind` `+ 1; ` `    ``while` `(``\$right` `< ``\$n` `&&  ` `           ``\$arr``[``\$right``] == ``\$x``) ` `    ``{ ` `        ``\$count``++; ` `        ``\$right``++; ` `    ``} ` `    ``return` `\$count``; ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``( 1, 2, 2, 2, 2,  ` `              ``3, 4, 7, 8, 8 ); ` `\$n` `= sizeof(``\$arr``); ` `\$x` `= 2; ` `echo` `countOccurrences(``\$arr``, ``\$n``, ``\$x``); ` ` `  `// This code is contributed ` `// by ChitraNayal ` `?> `

Output :

```4
```

Time Complexity : O(Log n + count) where count is number of occurrences.

Method 3 (Best using Improved Binary Search)
1) Use Binary search to get index of the first occurrence of x in arr[]. Let the index of the first occurrence be i.
2) Use Binary search to get index of the last occurrence of x in arr[]. Let the index of the last occurrence be j.
3) Return (j – i + 1);

## C++

 `// C++ program to count occurrences of an element ` `// in a sorted array. ` `# include ` `using` `namespace` `std; ` ` `  `/* if x is present in arr[] then returns the count ` `    ``of occurrences of x, otherwise returns 0. */` `int` `count(``int` `arr[], ``int` `x, ``int` `n) ` `{     ` `  ``/* get the index of first occurrence of x */` `  ``int` `*low = lower_bound(arr, arr+n, x); ` ` `  `  ``// If element is not present, return 0 ` `  ``if` `(low == (arr + n) || *low != x) ` `     ``return` `0; ` `    `  `  ``/* Else get the index of last occurrence of x. ` `     ``Note that we  are only looking in the  ` `     ``subarray after first occurrence */`    `  ``int` `*high = upper_bound(low, arr+n, x);      ` `    `  `  ``/* return count */` `  ``return` `high - low; ` `} ` ` `  `/* driver program to test above functions */` `int` `main() ` `{ ` `  ``int` `arr[] = {1, 2, 2, 3, 3, 3, 3}; ` `  ``int` `x =  3;  ``// Element to be counted in arr[] ` `  ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `  ``int` `c = count(arr, x, n); ` `  ``printf``(``" %d occurs %d times "``, x, c); ` `  ``return` `0; ` `} `

## C

 `# include ` ` `  `/* if x is present in arr[] then returns  ` `   ``the index of FIRST occurrence  ` `   ``of x in arr[0..n-1], otherwise returns -1 */` `int` `first(``int` `arr[], ``int` `low, ``int` `high, ``int` `x, ``int` `n) ` `{ ` `  ``if``(high >= low) ` `  ``{ ` `    ``int` `mid = (low + high)/2;  ``/*low + (high - low)/2;*/` `    ``if``( ( mid == 0 || x > arr[mid-1]) && arr[mid] == x) ` `      ``return` `mid; ` `    ``else` `if``(x > arr[mid]) ` `      ``return` `first(arr, (mid + 1), high, x, n); ` `    ``else` `      ``return` `first(arr, low, (mid -1), x, n); ` `  ``} ` `  ``return` `-1; ` `} ` ` `  `/* if x is present in arr[] then returns the ` `   ``index of LAST occurrence of x in arr[0..n-1],  ` `   ``otherwise returns -1 */`  `int` `last(``int` `arr[], ``int` `low, ``int` `high, ``int` `x, ``int` `n) ` `{ ` `  ``if` `(high >= low) ` `  ``{ ` `    ``int` `mid = (low + high)/2;  ``/*low + (high - low)/2;*/` `    ``if``( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x ) ` `      ``return` `mid; ` `    ``else` `if``(x < arr[mid]) ` `      ``return` `last(arr, low, (mid -1), x, n); ` `    ``else` `      ``return` `last(arr, (mid + 1), high, x, n);       ` `  ``} ` `  ``return` `-1; ` `} ` ` `  `/* if x is present in arr[] then returns the count ` `   ``of occurrences of x, otherwise returns -1. */` `int` `count(``int` `arr[], ``int` `x, ``int` `n) ` `{ ` `  ``int` `i; ``// index of first occurrence of x in arr[0..n-1] ` `  ``int` `j; ``// index of last occurrence of x in arr[0..n-1] ` `     `  `  ``/* get the index of first occurrence of x */` `  ``i = first(arr, 0, n-1, x, n); ` ` `  `  ``/* If x doesn't exist in arr[] then return -1 */` `  ``if``(i == -1) ` `    ``return` `i; ` `    `  `  ``/* Else get the index of last occurrence of x.  ` `     ``Note that we are only looking in the subarray  ` `     ``after first occurrence */`    `  ``j = last(arr, i, n-1, x, n);      ` `    `  `  ``/* return count */` `  ``return` `j-i+1; ` `} ` ` `  `/* driver program to test above functions */` `int` `main() ` `{ ` `  ``int` `arr[] = {1, 2, 2, 3, 3, 3, 3}; ` `  ``int` `x =  3;  ``// Element to be counted in arr[] ` `  ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` `  ``int` `c = count(arr, x, n); ` `  ``printf``(``" %d occurs %d times "``, x, c); ` `  ``getchar``(); ` `  ``return` `0; ` `} `

## Java

 `// Java program to count occurrences  ` `// of an element ` ` `  `class` `Main ` `{ ` `    ``/* if x is present in arr[] then returns  ` `       ``the count of occurrences of x,  ` `       ``otherwise returns -1. */` `    ``static` `int` `count(``int` `arr[], ``int` `x, ``int` `n) ` `    ``{ ` `      ``// index of first occurrence of x in arr[0..n-1]     ` `      ``int` `i;  ` `       `  `      ``// index of last occurrence of x in arr[0..n-1] ` `      ``int` `j;  ` `          `  `      ``/* get the index of first occurrence of x */` `      ``i = first(arr, ``0``, n-``1``, x, n); ` `      `  `      ``/* If x doesn't exist in arr[] then return -1 */` `      ``if``(i == -``1``) ` `        ``return` `i; ` `         `  `      ``/* Else get the index of last occurrence of x.  ` `         ``Note that we are only looking in the  ` `         ``subarray after first occurrence */`   `      ``j = last(arr, i, n-``1``, x, n);      ` `         `  `      ``/* return count */` `      ``return` `j-i+``1``; ` `    ``} ` `      `  `    ``/* if x is present in arr[] then returns the  ` `       ``index of FIRST occurrence of x in arr[0..n-1],  ` `       ``otherwise returns -1 */` `    ``static` `int` `first(``int` `arr[], ``int` `low, ``int` `high, ``int` `x, ``int` `n) ` `    ``{ ` `      ``if``(high >= low) ` `      ``{ ` `        ``/*low + (high - low)/2;*/`   `        ``int` `mid = (low + high)/``2``;   ` `        ``if``( ( mid == ``0` `|| x > arr[mid-``1``]) && arr[mid] == x) ` `          ``return` `mid; ` `        ``else` `if``(x > arr[mid]) ` `          ``return` `first(arr, (mid + ``1``), high, x, n); ` `        ``else` `          ``return` `first(arr, low, (mid -``1``), x, n); ` `      ``} ` `      ``return` `-``1``; ` `    ``} ` `      `  `    ``/* if x is present in arr[] then returns the  ` `       ``index of LAST occurrence of x in arr[0..n-1],  ` `       ``otherwise returns -1 */` `    ``static` `int` `last(``int` `arr[], ``int` `low, ``int` `high, ``int` `x, ``int` `n) ` `    ``{ ` `      ``if``(high >= low) ` `      ``{ ` `        ``/*low + (high - low)/2;*/`       `        ``int` `mid = (low + high)/``2``;  ` `        ``if``( ( mid == n-``1` `|| x < arr[mid+``1``]) && arr[mid] == x ) ` `          ``return` `mid; ` `        ``else` `if``(x < arr[mid]) ` `          ``return` `last(arr, low, (mid -``1``), x, n); ` `        ``else` `          ``return` `last(arr, (mid + ``1``), high, x, n);       ` `      ``} ` `      ``return` `-``1``; ` `    ``} ` `      `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `arr[] = {``1``, ``2``, ``2``, ``3``, ``3``, ``3``, ``3``}; ` `         `  `        ``// Element to be counted in arr[] ` `        ``int` `x =  ``3``;  ` `        ``int` `n = arr.length; ` `        ``int` `c = count(arr, x, n); ` `        ``System.out.println(x+``" occurs "``+c+``" times"``); ` `    ``} ` `} `

## Python3

 `# Python3 program to count ` `# occurrences of an element ` ` `  `# if x is present in arr[] then  ` `# returns the count of occurrences ` `# of x, otherwise returns -1.  ` `def` `count(arr, x, n): ` ` `  `    ``# get the index of first ` `    ``# occurrence of x  ` `    ``i ``=` `first(arr, ``0``, n``-``1``, x, n) ` `  `  `    ``# If x doesn't exist in  ` `    ``# arr[] then return -1  ` `    ``if` `i ``=``=` `-``1``: ` `        ``return` `i ` `     `  `    ``# Else get the index of last occurrence ` `    ``# of x. Note that we are only looking ` `    ``# in the subarray after first occurrence    ` `    ``j ``=` `last(arr, i, n``-``1``, x, n);      ` `     `  `    ``# return count  ` `    ``return` `j``-``i``+``1``; ` ` `  `# if x is present in arr[] then return ` `# the index of FIRST occurrence of x in ` `# arr[0..n-1], otherwise returns -1  ` `def` `first(arr, low, high, x, n): ` `    ``if` `high >``=` `low: ` ` `  `        ``# low + (high - low)/2 ` `        ``mid ``=` `(low ``+` `high)``/``/``2`       `         `  `    ``if` `(mid ``=``=` `0` `or` `x > arr[mid``-``1``]) ``and` `arr[mid] ``=``=` `x: ` `        ``return` `mid ` `    ``elif` `x > arr[mid]: ` `        ``return` `first(arr, (mid ``+` `1``), high, x, n) ` `    ``else``: ` `        ``return` `first(arr, low, (mid ``-``1``), x, n) ` `    ``return` `-``1``; ` `  `  `# if x is present in arr[] then return ` `# the index of LAST occurrence of x  ` `# in arr[0..n-1], otherwise returns -1  ` `def` `last(arr, low, high, x, n): ` `    ``if` `high >``=` `low: ` ` `  `        ``# low + (high - low)/2 ` `        ``mid ``=` `(low ``+` `high)``/``/``2``;  ` `  `  `    ``if``(mid ``=``=` `n``-``1` `or` `x < arr[mid``+``1``]) ``and` `arr[mid] ``=``=` `x : ` `        ``return` `mid ` `    ``elif` `x < arr[mid]: ` `        ``return` `last(arr, low, (mid ``-``1``), x, n) ` `    ``else``: ` `        ``return` `last(arr, (mid ``+` `1``), high, x, n)      ` `    ``return` `-``1` ` `  `# driver program to test above functions  ` `arr ``=` `[``1``, ``2``, ``2``, ``3``, ``3``, ``3``, ``3``] ` `x ``=` `3`  `# Element to be counted in arr[] ` `n ``=` `len``(arr) ` `c ``=` `count(arr, x, n) ` `print` `(``"%d occurs %d times "``%``(x, c)) `

## C#

 `// C# program to count occurrences  ` `// of an element ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``/* if x is present in arr[] then returns  ` `    ``the count of occurrences of x,  ` `    ``otherwise returns -1. */` `    ``static` `int` `count(``int` `[]arr, ``int` `x, ``int` `n) ` `    ``{ ` `    ``// index of first occurrence of x in arr[0..n-1]  ` `    ``int` `i;  ` `         `  `    ``// index of last occurrence of x in arr[0..n-1] ` `    ``int` `j;  ` `         `  `    ``/* get the index of first occurrence of x */` `    ``i = first(arr, 0, n-1, x, n); ` `     `  `    ``/* If x doesn't exist in arr[] then return -1 */` `    ``if``(i == -1) ` `        ``return` `i; ` `         `  `    ``/* Else get the index of last occurrence of x.  ` `        ``Note that we are only looking in the  ` `        ``subarray after first occurrence */` `    ``j = last(arr, i, n-1, x, n);      ` `         `  `    ``/* return count */` `    ``return` `j-i+1; ` `    ``} ` `     `  `    ``/* if x is present in arr[] then returns the  ` `    ``index of FIRST occurrence of x in arr[0..n-1],  ` `    ``otherwise returns -1 */` `    ``static` `int` `first(``int` `[]arr, ``int` `low, ``int` `high,  ` `                                     ``int` `x, ``int` `n) ` `    ``{ ` `    ``if``(high >= low) ` `    ``{ ` `        ``/*low + (high - low)/2;*/` `        ``int` `mid = (low + high)/2;  ` `        ``if``( ( mid == 0 || x > arr[mid-1])  ` `                            ``&& arr[mid] == x) ` `        ``return` `mid; ` `        ``else` `if``(x > arr[mid]) ` `        ``return` `first(arr, (mid + 1), high, x, n); ` `        ``else` `        ``return` `first(arr, low, (mid -1), x, n); ` `    ``} ` `    ``return` `-1; ` `    ``} ` `     `  `    ``/* if x is present in arr[] then returns the  ` `    ``index of LAST occurrence of x in arr[0..n-1],  ` `    ``otherwise returns -1 */` `    ``static` `int` `last(``int` `[]arr, ``int` `low, ` `                        ``int` `high, ``int` `x, ``int` `n) ` `    ``{ ` `    ``if``(high >= low) ` `    ``{ ` `        ``/*low + (high - low)/2;*/`     `        ``int` `mid = (low + high)/2;  ` `        ``if``( ( mid == n-1 || x < arr[mid+1]) ` `                            ``&& arr[mid] == x ) ` `        ``return` `mid; ` `        ``else` `if``(x < arr[mid]) ` `        ``return` `last(arr, low, (mid -1), x, n); ` `        ``else` `        ``return` `last(arr, (mid + 1), high, x, n);      ` `    ``} ` `    ``return` `-1; ` `    ``} ` `     `  `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = {1, 2, 2, 3, 3, 3, 3}; ` `         `  `        ``// Element to be counted in arr[] ` `        ``int` `x = 3;  ` `        ``int` `n = arr.Length; ` `        ``int` `c = count(arr, x, n); ` `         `  `        ``Console.Write(x + ``" occurs "` `+ c + ``" times"``); ` `    ``} ` `} ` `// This code is contributed by Sam007 `

Output:

```3 occurs 4 times
```

Time Complexity: O(Logn)