# Count of only repeated element in a sorted array of consecutive elements

Given a sorted array of consecutive elements. The array has only one element repeated many times. The task is to find length of the sequence of repeated element.

Expected Time Complexity : Less than 0(n)

Examples:

```Input  : arr[] = {1, 2, 3, 4, 4, 4, 5, 6}
Output : 4 3
Repeated element is 4 and it appears 3 times.

Input  : arr[] = {4, 4, 4, 4, 4}
Output : 4 5

Input  : arr[] = {6, 7, 8, 9, 10, 10, 11}
Output : 10 2

Input  : arr[] = {6, 7, 8, 9, 10, 10, 10}
Output : 10 3
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We need to find two things:

1. Number of times the element repeats. If the array is sorted and if max-difference of two adjacent elements is 1, then the length of the repeated sequence is n – 1 – (array[n-1] – array)
2. Value of the element. To the value, we do Binary Search.

## C++

 `// C++ program to find the only repeated element ` `// and number of times it appears ` `#include ` `using` `namespace` `std; ` ` `  `// Assumptions : vector a is sorted, max-difference ` `// of two adjacent elements is 1 ` `pair<``int``, ``int``> sequence(``const` `vector<``int``>& a) ` `{ ` `    ``if` `(a.size() == 0) ` `        ``return` `{0, 0}; ` ` `  `    ``int` `s = 0; ` `    ``int` `e = a.size() - 1; ` `    ``while` `(s < e) ` `    ``{ ` `        ``int` `m = (s + e) / 2; ` ` `  `        ``// if a[m] = m + a, there is no ` `        ``// repeating character in [s..m] ` `        ``if` `(a[m] >= m + a) ` `            ``s = m + 1; ` ` `  `       ``// if a[m] < m + a, there is a ` `       ``// repeating character in [s..m] ` `        ``else` `            ``e = m; ` `    ``} ` `    ``return` `{a[s], a.size() - (a[a.size() - 1] - a)}; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``pair<``int``, ``int``>p = sequence({ 1, 2, 3, 4, 4, 4, 5, 6 }); ` `    ``cout << ``"Repeated element is "` `<< p.first ` `         ``<< ``", it appears "` `<< p.second << ``" times"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the only repeated element ` `// and number of times it appears ` ` `  `import` `java.awt.Point; ` `import` `java.util.Arrays; ` `import` `java.util.Vector; ` ` `  `class` `Test ` `{ ` `    ``// Assumptions : vector a is sorted, max-difference ` `    ``// of two adjacent elements is 1 ` `    ``static` `Point sequence(Vector a) ` `    ``{ ` `        ``if` `(a.size() == ``0``) ` `            ``return` `new` `Point(``0``, ``0``); ` `      `  `        ``int` `s = ``0``; ` `        ``int` `e = a.size() - ``1``; ` `        ``while` `(s < e) ` `        ``{ ` `            ``int` `m = (s + e) / ``2``; ` `      `  `            ``// if a[m] = m + a, there is no ` `            ``// repeating character in [s..m] ` `            ``if` `(a.get(m) >= m + a.get(``0``)) ` `                ``s = m + ``1``; ` `      `  `           ``// if a[m] < m + a, there is a ` `           ``// repeating character in [s..m] ` `            ``else` `                ``e = m; ` `        ``} ` `        ``return` `new` `Point(a.get(s), a.size() - (a.get(a.size() - ``1``) - a.get(``0``))); ` `    ``} ` `     `  `    ``// Driver method ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``Integer array[] = ``new` `Integer[]{``1``, ``2``, ``3``, ``4``, ``4``, ``4``, ``5``, ``6``}; ` `        ``Point p = sequence(``new` `Vector<>(Arrays.asList(array))); ` `        ``System.out.println(``"Repeated element is "` `+ p.x + ` `                           ``", it appears "` `+ p.y + ``" times"``); ` `    ``} ` `} `

## Python3

 `# Python3 program to find the  ` `# only repeated element and  ` `# number of times it appears ` ` `  `# Assumptions : vector a is sorted,  ` `# max-difference of two adjacent ` `# elements is 1 ` `def` `sequence(a): ` `    ``if` `(``len``(a) ``=``=` `0``): ` `        ``return` `[``0``, ``0``] ` ` `  `    ``s ``=` `0` `    ``e ``=` `len``(a) ``-` `1` `    ``while` `(s < e): ` `        ``m ``=` `(s ``+` `e) ``/``/` `2` ` `  `        ``# if a[m] = m + a, there is no ` `        ``# repeating character in [s..m] ` `        ``if` `(a[m] >``=` `m ``+` `a[``0``]): ` `            ``s ``=` `m ``+` `1` ` `  `        ``# if a[m] < m + a, there is a ` `        ``# repeating character in [s..m] ` `        ``else``: ` `            ``e ``=` `m ` `    ``return` `[a[s], ``len``(a) ``-` `( ` `                ``a[``len``(a) ``-` `1``] ``-` `a[``0``])] ` ` `  `# Driver code ` `p ``=` `sequence([``1``, ``2``, ``3``, ``4``, ``4``, ``4``, ``5``, ``6``]) ` `print``(``"Repeated element is"``, p[``0``],  ` `             ``", it appears"``, p[``1``], ``"times"``) ` ` `  `# This code is contributed by Mohit Kumar `

## C#

 `// C# program to find the only repeated element ` `// and number of times it appears ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `public` `class` `Point  ` `{  ` `    ``public` `int` `first, second;  ` ` `  `        ``public` `Point(``int` `first, ``int` `second)  ` `        ``{  ` `            ``this``.first = first;  ` `            ``this``.second = second;  ` `        ``}  ` `     `  `     `  `}  ` `public` `class` `Test ` `{ ` `    ``// Assumptions : vector a is sorted, max-difference ` `    ``// of two adjacent elements is 1 ` `    ``static` `Point sequence(List<``int``> a) ` `    ``{ ` `        ``if` `(a.Count == 0) ` `            ``return` `new` `Point(0, 0); ` `     `  `        ``int` `s = 0; ` `        ``int` `e = a.Count - 1; ` `        ``while` `(s < e) ` `        ``{ ` `            ``int` `m = (s + e) / 2; ` `     `  `            ``// if a[m] = m + a, there is no ` `            ``// repeating character in [s..m] ` `            ``if` `(a[m] >= m + a) ` `                ``s = m + 1; ` `     `  `        ``// if a[m] < m + a, there is a ` `        ``// repeating character in [s..m] ` `            ``else` `                ``e = m; ` `        ``} ` `        ``return` `new` `Point(a[s], a.Count - (a[a.Count - 1] - a)); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String []args) ` `    ``{ ` `        ``int` `[]array = ``new` `int``[]{1, 2, 3, 4, 4, 4, 5, 6}; ` `        ``Point p = sequence(``new` `List<``int``>(array)); ` `        ``Console.WriteLine(``"Repeated element is "` `+ p.first + ` `                        ``", it appears "` `+ p.second + ``" times"``); ` `    ``} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

Output:

```Repeated element is 4, it appears 3 times
```

This article is contributed by Rakesh Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.