# N/3 repeated number in an array with O(1) space

• Difficulty Level : Hard
• Last Updated : 27 May, 2021

We are given a read only array of n integers. Find any element that appears more than n/3 times in the array in linear time and constant additional space. If no such element exists, return -1.

Examples:

```Input : [10, 10, 20, 30, 10, 10]
Output : 10
10 occurs 4 times which is more than 6/3.

Input : [20, 30, 10, 10, 5, 4, 20, 1, 2]
Output : -1```

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

The idea is based on Moore’s Voting algorithm.  We first find two candidates. Then we check if any of these two candidates is actually a majority. Below is the solution for above approach.

## C++

 `// CPP program to find if any element appears``// more than n/3.``#include ``using` `namespace` `std;` `int` `appearsNBy3(``int` `arr[], ``int` `n)``{``    ``int` `count1 = 0, count2 = 0;``    ``int` `first=INT_MAX    , second=INT_MAX    ;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// if this element is previously seen,``        ``// increment count1.``        ``if` `(first == arr[i])``            ``count1++;` `        ``// if this element is previously seen,``        ``// increment count2.``        ``else` `if` `(second == arr[i])``            ``count2++;``    ` `        ``else` `if` `(count1 == 0) {``            ``count1++;``            ``first = arr[i];``        ``}` `        ``else` `if` `(count2 == 0) {``            ``count2++;``            ``second = arr[i];``        ``}` `        ``// if current element is different from``        ``// both the previously seen variables,``        ``// decrement both the counts.``        ``else` `{``            ``count1--;``            ``count2--;``        ``}``    ``}` `    ``count1 = 0;``    ``count2 = 0;` `    ``// Again traverse the array and find the``    ``// actual counts.``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr[i] == first)``            ``count1++;` `        ``else` `if` `(arr[i] == second)``            ``count2++;``    ``}` `    ``if` `(count1 > n / 3)``        ``return` `first;` `    ``if` `(count2 > n / 3)``        ``return` `second;` `    ``return` `-1;``}` `int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 1, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << appearsNBy3(arr, n) << endl;``    ``return` `0;``}`

## Java

 `// Java program to find if any element appears``// more than n/3.``class` `GFG {``    ` `    ``static` `int` `appearsNBy3(``int` `arr[], ``int` `n)``    ``{``        ``int` `count1 = ``0``, count2 = ``0``;``        ` `        ``// take the integers as the maximum``        ``// value of integer hoping the integer``        ``// would not be present in the array``        ``int` `first =  Integer.MIN_VALUE;;``        ``int` `second = Integer.MAX_VALUE;``    ` `        ``for` `(``int` `i = ``0``; i < n; i++) {``    ` `            ``// if this element is previously``            ``// seen, increment count1.``            ``if` `(first == arr[i])``                ``count1++;``    ` `            ``// if this element is previously``            ``// seen, increment count2.``            ``else` `if` `(second == arr[i])``                ``count2++;``        ` `            ``else` `if` `(count1 == ``0``) {``                ``count1++;``                ``first = arr[i];``            ``}``    ` `            ``else` `if` `(count2 == ``0``) {``                ``count2++;``                ``second = arr[i];``            ``}``    ` `            ``// if current element is different``            ``// from both the previously seen``            ``// variables, decrement both the``            ``// counts.``            ``else` `{``                ``count1--;``                ``count2--;``            ``}``        ``}``    ` `        ``count1 = ``0``;``        ``count2 = ``0``;``    ` `        ``// Again traverse the array and``        ``// find the actual counts.``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(arr[i] == first)``                ``count1++;``    ` `            ``else` `if` `(arr[i] == second)``                ``count2++;``        ``}``    ` `        ``if` `(count1 > n / ``3``)``            ``return` `first;``    ` `        ``if` `(count2 > n / ``3``)``            ``return` `second;``    ` `        ``return` `-``1``;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``1``, ``1` `};``        ``int` `n = arr.length;``        ``System.out.println(appearsNBy3(arr, n));``        ` `    ``}``}` `// This code is contributed by Arnab Kundu`

## Python 3

 `# Python 3 program to find if``# any element appears more than``# n/3.``import` `sys` `def` `appearsNBy3(arr, n):` `    ``count1 ``=` `0``    ``count2 ``=` `0``    ``first ``=` `sys.maxsize``    ``second ``=` `sys.maxsize` `    ``for` `i ``in` `range``(``0``, n):` `        ``# if this element is``        ``# previously seen,``        ``# increment count1.``        ``if` `(first ``=``=` `arr[i]):``            ``count1 ``+``=` `1` `        ``# if this element is``        ``# previously seen,``        ``# increment count2.``        ``elif` `(second ``=``=` `arr[i]):``            ``count2 ``+``=` `1``    ` `        ``elif` `(count1 ``=``=` `0``):``            ``count1 ``+``=` `1``            ``first ``=` `arr[i]` `        ``elif` `(count2 ``=``=` `0``):``            ``count2 ``+``=` `1``            ``second ``=` `arr[i]``        `  `        ``# if current element is``        ``# different from both``        ``# the previously seen``        ``# variables, decrement``        ``# both the counts.``        ``else``:``            ``count1 ``-``=` `1``            ``count2 ``-``=` `1``        ` `    `  `    ``count1 ``=` `0``    ``count2 ``=` `0` `    ``# Again traverse the array``    ``# and find the actual counts.``    ``for` `i ``in` `range``(``0``, n):``        ``if` `(arr[i] ``=``=` `first):``            ``count1 ``+``=` `1` `        ``elif` `(arr[i] ``=``=` `second):``            ``count2 ``+``=` `1``    `  `    ``if` `(count1 > n ``/` `3``):``        ``return` `first` `    ``if` `(count2 > n ``/` `3``):``        ``return` `second` `    ``return` `-``1` `# Driver code``arr ``=` `[``1``, ``2``, ``3``, ``1``, ``1` `]``n ``=` `len``(arr)``print``(appearsNBy3(arr, n))` `# This code is contributed by``# Smitha`

## C#

 `// C# program to find if any element appears``// more than n/3.``using` `System;` `public` `class` `GFG {``    ` `    ``static` `int` `appearsNBy3(``int` `[]arr, ``int` `n)``    ``{``        ``int` `count1 = 0, count2 = 0;``        ` `        ``// take the integers as the maximum``        ``// value of integer hoping the integer``        ``// would not be present in the array``        ``int` `first = ``int``.MaxValue;``        ``int` `second = ``int``.MaxValue;``    ` `        ``for` `(``int` `i = 1; i < n; i++) {``    ` `            ``// if this element is previously``            ``// seen, increment count1.``            ``if` `(first == arr[i])``                ``count1++;``    ` `            ``// if this element is previously``            ``// seen, increment count2.``            ``else` `if` `(second == arr[i])``                ``count2++;``        ` `            ``else` `if` `(count1 == 0) {``                ``count1++;``                ``first = arr[i];``            ``}``    ` `            ``else` `if` `(count2 == 0) {``                ``count2++;``                ``second = arr[i];``            ``}``    ` `            ``// if current element is different``            ``// from both the previously seen``            ``// variables, decrement both the``            ``// counts.``            ``else` `{``                ``count1--;``                ``count2--;``            ``}``        ``}``    ` `        ``count1 = 0;``        ``count2 = 0;``    ` `        ``// Again traverse the array and``        ``// find the actual counts.``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(arr[i] == first)``                ``count1++;``    ` `            ``else` `if` `(arr[i] == second)``                ``count2++;``        ``}``    ` `        ``if` `(count1 > n / 3)``            ``return` `first;``    ` `        ``if` `(count2 > n / 3)``            ``return` `second;``    ` `        ``return` `-1;``    ``}``    ` `    ``// Driver code``    ``static` `public` `void` `Main(String []args)``    ``{``        ``int` `[]arr = { 1, 2, 3, 1, 1 };``        ``int` `n = arr.Length;``        ``Console.WriteLine(appearsNBy3(arr, n));``    ``}``}` `// This code is contributed by Arnab Kundu`

## PHP

 ` ``\$n` `/ 3)``        ``return` `\$first``;` `    ``if` `(``\$count2` `> ``\$n` `/ 3)``        ``return` `\$second``;` `    ``return` `-1;``}` `// Driver code``\$arr` `= ``array``( 1, 2, 3, 1, 1 );``\$n` `= ``count``(``\$arr``);``echo` `appearsNBy3(``\$arr``, ``\$n``) ;` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``
Output:
`1`

Complexity Analysis:

• Time Complexity:  O(n)
First pass of the algorithm takes complete traversal over the array contributing to O(n) and another O(n) is consumed in checking if count1 and count2 is greater than floor(n/3) times.
• Space Complexity: O(1)
As no extra space is required so space complexity is constant

My Personal Notes arrow_drop_up