# Find the two repeating elements in a given array

• Difficulty Level : Medium
• Last Updated : 05 Jul, 2022

You are given an array of n+2 elements. All elements of the array are in range 1 to n. And all elements occur once except two numbers which occur twice. Find the two repeating numbers.

Example:

Input:
arr = [4, 2, 4, 5, 2, 3, 1]
n = 5
Output:
4 2
Explanation:
The above array has n + 2 = 7 elements with all elements occurring once except 2 and 4 which occur twice. So the output should be 4 2.

Recommended Practice

Method 1 (Basic)

Use two loops. In the outer loop, pick elements one by one and count the number of occurrences of the picked element in the inner loop.
This method doesn’t use the other useful data provided in questions like range of numbers is between 1 to n and there are only two repeating elements.

## C++

 `// C++ program to Find the two repeating``// elements in a given array``#include``using` `namespace` `std;`` ` `void` `printTwoRepeatNumber(``int` `arr[], ``int` `size)``{``    ``int` `i, j, display=0;``    ``int` `visited[size];``    ``for``(i = 0; i < size; i++)``    ``{``    ``if` `(visited[i] == 1)``    ``{``        ``continue``;``    ``}``    ``int` `count = 0;``        ``for``(j = i + 1; j < size; j++)``        ``{``        ``if``(arr[i] == arr[j])``        ``{``            ``visited[j] = 1;``            ``++count;``            ``break``;``        ``}``        ``}``        ``if` `( (count > 0) && (display < 2)){``            ``++display;``        ``cout<<``"repeating element = "``<< arr[i]<

## C

 `#include``#include``void` `printRepeating(``int` `arr[], ``int` `size)``{``  ``int` `i, j;``  ``printf``(``" Repeating elements are "``);``  ``for``(i = 0; i < size-1; i++)``    ``for``(j = i+1; j < size; j++)``      ``if``(arr[i] == arr[j])``        ``printf``(``" %d "``, arr[i]);``}     `` ` `int` `main()``{``  ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1};``  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);  ``  ``printRepeating(arr, arr_size);``  ``getchar``();``  ``return` `0;``}`

## Java

 `class` `RepeatElement ``{``    ``void` `printRepeating(``int` `arr[], ``int` `size) ``    ``{``        ``int` `i, j;``        ``System.out.println(``"Repeated Elements are :"``);``        ``for` `(i = ``0``; i < size-``1``; i++) ``        ``{``            ``for` `(j = i + ``1``; j < size; j++) ``            ``{``                ``if` `(arr[i] == arr[j]) ``                    ``System.out.print(arr[i] + ``" "``);``            ``}``        ``}``    ``}`` ` `    ``public` `static` `void` `main(String[] args) ``    ``{``        ``RepeatElement repeat = ``new` `RepeatElement();``        ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``        ``int` `arr_size = arr.length;``        ``repeat.printRepeating(arr, arr_size);``    ``}``}`

## Python3

 `# Python3 program to Find the two``# repeating elements in a given array`` ` `def` `printRepeating(arr, size):`` ` `    ``print``(``"Repeating elements are "``,``                         ``end ``=` `'')``    ``for` `i ``in` `range` `(``0``, size``-``1``):``        ``for` `j ``in` `range` `(i ``+` `1``, size):``            ``if` `arr[i] ``=``=` `arr[j]:``                ``print``(arr[i], end ``=` `' '``)``     ` `# Driver code``arr ``=` `[``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(arr)``printRepeating(arr, arr_size)`` ` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `using` `System;`` ` `class` `GFG``{``         ` `    ``static` `void` `printRepeating(``int` `[]arr, ``int` `size) ``    ``{``        ``int` `i, j;``         ` `        ``Console.Write(``"Repeated Elements are :"``);``        ``for` `(i = 0; i < size-1; i++) ``        ``{``            ``for` `(j = i + 1; j < size; j++) ``            ``{``                ``if` `(arr[i] == arr[j]) ``                    ``Console.Write(arr[i] + ``" "``);``            ``}``        ``}``    ``}``    ``// driver code``    ``public` `static` `void` `Main() ``    ``{``        ``int` `[]arr = {4, 2, 4, 5, 2, 3, 1};``        ``int` `arr_size = arr.Length;``         ` `        ``printRepeating(arr, arr_size);``    ``}``}`` ` `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

` Repeating elements are 4 2 `

Time Complexity: O(n*n)
Auxiliary Space: O(1)

Method 2 (Use Count array)
Traverse the array once. While traversing, keep track of count of all elements in the array using a temp array count[] of size n, when you see an element whose count is already set, print it as duplicate.
This method uses the range given in the question to restrict the size of count[], but doesn’t use the data that there are only two repeating elements.

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;`` ` `void` `printRepeating(``int` `arr[], ``int` `size) ``{ ``    ``int` `*count = ``new` `int``[``sizeof``(``int``)*(size - 2)]; ``    ``int` `i; ``         ` `    ``cout << ``" Repeating elements are "``; ``    ``for``(i = 0; i < size; i++) ``    ``{ ``        ``if``(count[arr[i]] == 1) ``            ``cout << arr[i] << ``" "``; ``        ``else``            ``count[arr[i]]++; ``    ``} ``} `` ` `// Driver code``int` `main() ``{ ``    ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1}; ``    ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]); ``    ``printRepeating(arr, arr_size); ``    ``return` `0; ``} `` ` `// This is code is contributed by rathbhupendra`

## C

 `#include``#include`` ` `void` `printRepeating(``int` `arr[], ``int` `size)``{``  ``int` `*count = (``int` `*)``calloc``(``sizeof``(``int``), (size - 2));``  ``int` `i;``   ` `  ``printf``(``" Repeating elements are "``);``  ``for``(i = 0; i < size; i++)``  ``{  ``    ``if``(count[arr[i]] == 1)``      ``printf``(``" %d "``, arr[i]);``    ``else``     ``count[arr[i]]++;``  ``}    ``}     `` ` `int` `main()``{``  ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1};``  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);  ``  ``printRepeating(arr, arr_size);``  ``getchar``();``  ``return` `0;``}`

## Java

 `class` `RepeatElement``{``    ``void` `printRepeating(``int` `arr[], ``int` `size) ``    ``{``        ``int` `count[] = ``new` `int``[size];``        ``int` `i;`` ` `        ``System.out.println(``"Repeated elements are : "``);``        ``for` `(i = ``0``; i < size; i++) ``        ``{``            ``if` `(count[arr[i]] == ``1``)``                ``System.out.print(arr[i] + ``" "``);``            ``else``                ``count[arr[i]]++;``        ``}``    ``}`` ` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``RepeatElement repeat = ``new` `RepeatElement();``        ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``        ``int` `arr_size = arr.length;``        ``repeat.printRepeating(arr, arr_size);``    ``}``}`

## Python3

 `# Python3 code for Find the two repeating ``# elements in a given array`` ` ` ` `def` `printRepeating(arr,size) :``    ``count ``=` `[``0``] ``*` `size``    ``print``(``" Repeating elements are "``,end ``=` `"")``    ``for` `i ``in` `range``(``0``, size) :``        ``if``(count[arr[i]] ``=``=` `1``) :``            ``print``(arr[i], end ``=` `" "``)``        ``else` `:``            ``count[arr[i]] ``=` `count[arr[i]] ``+` `1`` ` ` ` `# Driver code``arr ``=` `[``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(arr)``printRepeating(arr, arr_size)`` ` ` ` `         ` `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# program to Find the two``// repeating elements in a given array``using` `System;`` ` `class` `GFG``{``         ` `    ``static` `void` `printRepeating(``int` `[]arr,``                                    ``int` `size) ``    ``{``        ``int` `[]count = ``new` `int``[size];``        ``int` `i;`` ` `        ``Console.Write(``"Repeated elements are: "``);``        ``for` `(i = 0; i < size; i++) ``        ``{``            ``if` `(count[arr[i]] == 1)``                ``Console.Write(arr[i] + ``" "``);``            ``else``                ``count[arr[i]]++;``        ``}``    ``}`` ` `    ``// driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = {4, 2, 4, 5, 2, 3, 1};``        ``int` `arr_size = arr.Length;``         ` `        ``printRepeating(arr, arr_size);``    ``}``}`` ` `//This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

` Repeating elements are 4 2 `

Time Complexity: O(n)
Auxiliary Space: O(n)

Method 3 (Make two equations)

Let the numbers which are being repeated are X and Y. We make two equations for X and Y and the simple task left is to solve the two equations.
We know the sum of integers from 1 to n is n(n+1)/2 and product is n!. We calculate the sum of input array when this sum is subtracted from n(n+1)/2, we get X + Y because X and Y are the two numbers missing from set [1..n]. Similarly calculate the product of input array, when this product is divided from n!, we get X*Y. Given the sum and product of X and Y, we can find easily out X and Y.
Let summation of all numbers in the array be S and product be P
X + Y = S – n(n+1)/2
XY = P/n!
Using the above two equations, we can find out X and Y. For array = 4 2 4 5 2 3 1, we get S = 21 and P as 960.
X + Y = 21 – 15 = 6
XY = 960/5! = 8
X – Y = sqrt((X+Y)^2 – 4*XY) = sqrt(4) = 2
Using below two equations, we easily get X = (6 + 2)/2 and Y = (6-2)/2
X + Y = 6
X – Y = 2
Thanks to geek4u for suggesting this method. As pointed by Beginner, there can be an addition and multiplication overflow problem with this approach.

The methods 3 and 4 use all useful information given in the question :

## C++

 `#include ``using` `namespace` `std; `` ` `/* function to get factorial of n */``int` `fact(``int` `n); `` ` `void` `printRepeating(``int` `arr[], ``int` `size) ``{ ``    ``int` `S = 0; ``/* S is for sum of elements in arr[] */``    ``int` `P = 1; ``/* P is for product of elements in arr[] */``    ``int` `x, y; ``/* x and y are two repeating elements */``    ``int` `D; ``/* D is for difference of x and y, i.e., x-y*/``    ``int` `n = size - 2, i; ``     ` `    ``/* Calculate Sum and Product of all elements in arr[] */``    ``for``(i = 0; i < size; i++) ``    ``{ ``        ``S = S + arr[i]; ``        ``P = P*arr[i]; ``    ``}     ``         ` `    ``S = S - n*(n+1)/2; ``/* S is x + y now */``    ``P = P/fact(n);     ``/* P is x*y now */``         ` `    ``D = ``sqrt``(S*S - 4*P); ``/* D is x - y now */``         ` `    ``x = (D + S)/2; ``    ``y = (S - D)/2; ``         ` `    ``cout<<``"The two Repeating elements are "``<

## C

 `#include``#include``#include`` ` `/* function to get factorial of n */``int` `fact(``int` `n);`` ` `void` `printRepeating(``int` `arr[], ``int` `size)``{``  ``int` `S = 0;  ``/* S is for sum of elements in arr[] */``  ``int` `P = 1;  ``/* P is for product of elements in arr[] */`  `  ``int` `x,  y;   ``/* x and y are two repeating elements */``  ``int` `D;      ``/* D is for difference of x and y, i.e., x-y*/``  ``int` `n = size - 2,  i;`` ` `  ``/* Calculate Sum and Product of all elements in arr[] */``  ``for``(i = 0; i < size; i++)``  ``{``    ``S = S + arr[i];``    ``P = P*arr[i];``  ``}        ``   ` `  ``S = S - n*(n+1)/2;  ``/* S is x + y now */``  ``P = P/fact(n);         ``/* P is x*y now */``   ` `  ``D = ``sqrt``(S*S - 4*P); ``/* D is x - y now */``   ` `  ``x = (D + S)/2;``  ``y = (S - D)/2;``   ` `  ``printf``(``"The two Repeating elements are %d & %d"``, x, y);``}     `` ` `int` `fact(``int` `n)``{``   ``return` `(n == 0)? 1 : n*fact(n-1);``}    `` ` `int` `main()``{``  ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1};``  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);  ``  ``printRepeating(arr, arr_size);``  ``getchar``();``  ``return` `0;``}`

## Java

 `class` `RepeatElement``{``    ``void` `printRepeating(``int` `arr[], ``int` `size) ``    ``{``        ``/* S is for sum of elements in arr[] */``        ``int` `S = ``0``;``         ` `        ``/* P is for product of elements in arr[] */``        ``int` `P = ``1``;``         ` `        ``/* x and y are two repeating elements */``        ``int` `x, y;``         ` `        ``/* D is for difference of x and y, i.e., x-y*/``        ``int` `D;``         ` `        ``int` `n = size - ``2``, i;`` ` `        ``/* Calculate Sum and Product of all elements in arr[] */``        ``for` `(i = ``0``; i < size; i++) ``        ``{``            ``S = S + arr[i];``            ``P = P * arr[i];``        ``}`` ` `        ``/* S is x + y now */``        ``S = S - n * (n + ``1``) / ``2``;``         ` `        ``/* P is x*y now */``        ``P = P / fact(n);``        ` `        ``/* D is x - y now */``        ``D = (``int``) Math.sqrt(S * S - ``4` `* P);``         ` ` ` `        ``x = (D + S) / ``2``;``        ``y = (S - D) / ``2``;`` ` `        ``System.out.println(``"The two repeating elements are :"``);``        ``System.out.print(x + ``" "` `+ y);``    ``}`` ` `    ``int` `fact(``int` `n) ``    ``{``        ``return` `(n == ``0``) ? ``1` `: n * fact(n - ``1``);``    ``}`` ` `    ``public` `static` `void` `main(String[] args) {``        ``RepeatElement repeat = ``new` `RepeatElement();``        ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``        ``int` `arr_size = arr.length;``        ``repeat.printRepeating(arr, arr_size);``    ``}``}`` ` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 code for Find the two repeating ``# elements in a given array``import` `math`` ` `def` `printRepeating(arr, size) :``     ` `    ``# S is for sum of elements in arr[] ``    ``S ``=` `0``; ``     ` `    ``# P is for product of elements in arr[] ``    ``P ``=` `1``;``     ` `    ``n ``=` `size ``-` `2`` ` `    ``# Calculate Sum and Product ``    ``# of all elements in arr[] ``    ``for` `i ``in` `range``(``0``, size) :``        ``S ``=` `S ``+` `arr[i]``        ``P ``=` `P ``*` `arr[i]``     ` `    ``# S is x + y now ``    ``S ``=` `S ``-` `n ``*` `(n ``+` `1``) ``/``/` `2` `     ` `     ``# P is x*y now ``    ``P ``=` `P ``/``/` `fact(n)    ``     ` `    ``# D is x - y now ``    ``D ``=` `math.sqrt(S ``*` `S ``-` `4` `*` `P) ``     ` `    ``x ``=` `(D ``+` `S) ``/``/` `2``    ``y ``=` `(S ``-` `D) ``/``/` `2``     ` `    ``print``(``"The two Repeating elements are "``, ``          ``(``int``)(x),``" & "` `,(``int``)(y))``     ` ` ` `def` `fact(n) :``    ``if``(n ``=``=` `0``) :``        ``return` `1``    ``else` `:``        ``return``(n ``*` `fact(n ``-` `1``))`` ` `# Driver code``arr ``=` `[``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(arr) ``printRepeating(arr, arr_size)`` ` `         ` `# This code is contributed by Nikita Tiwari.`

## C#

 `using` `System;`` ` `class` `GFG``{``         ` `    ``static` `void` `printRepeating(``int` `[]arr, ``int` `size) ``    ``{``        ``/* S is for sum of elements in arr[] */``        ``int` `S = 0;``         ` `        ``/* P is for product of elements in arr[] */``        ``int` `P = 1;``         ` `        ``/* x and y are two repeating elements */``        ``int` `x, y;``         ` `        ``/* D is for difference of x and y, i.e., x-y*/``        ``int` `D;``         ` `        ``int` `n = size - 2, i;`` ` `        ``/* Calculate Sum and Product ``         ``of all elements in arr[] */``        ``for` `(i = 0; i < size; i++) ``        ``{``            ``S = S + arr[i];``            ``P = P * arr[i];``        ``}`` ` `        ``/* S is x + y now */``        ``S = S - n * (n + 1) / 2;``         ` `        ``/* P is x*y now */``        ``P = P / fact(n);``         ` `        ``/* D is x - y now */``        ``D = (``int``) Math.Sqrt(S * S - 4 * P);``         ` ` ` `        ``x = (D + S) / 2;``        ``y = (S - D) / 2;`` ` `        ``Console.WriteLine(``"The two"` `+ ``                ``" repeating elements are :"``);``        ``Console.Write(x + ``" "` `+ y);``    ``}`` ` `    ``static` `int` `fact(``int` `n) ``    ``{``        ``return` `(n == 0) ? 1 : n * fact(n - 1);``    ``}`` ` `    ``// driver code``    ``public` `static` `void` `Main() {``        ``int` `[]arr = {4, 2, 4, 5, 2, 3, 1};``        ``int` `arr_size = arr.Length;``         ` `        ``printRepeating(arr, arr_size);``    ``}``}``// This code is contributed by Sam007 `

## PHP

 ``

## Javascript

 ``

Output

`The two Repeating elements are 4 & 2`

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 4 (Use XOR)

Thanks to neophyte for suggesting this method.
The approach used here is similar to method 2 of this post
Let the repeating numbers be X and Y, if we xor all the elements in the array and all integers from 1 to n, then the result is X xor Y.
The 1â€™s in binary representation of X xor Y is corresponding to the different bits between X and Y. Suppose that the kth bit of X xor Y is 1, we can xor all the elements in the array and all integers from 1 to n, whose kth bits are 1. The result will be one of X and Y.

## C++

 `#include ``using` `namespace` `std;`` ` `void` `printRepeating(``int` `arr[], ``int` `size) ``{ ``    ``int` `Xor = arr[0]; ``/* Will hold Xor of all elements */``    ``int` `set_bit_no; ``/* Will have only single set bit of Xor */``    ``int` `i; ``    ``int` `n = size - 2; ``    ``int` `x = 0, y = 0; ``         ` `    ``/* Get the Xor of all elements in arr[] and {1, 2 .. n} */``    ``for``(i = 1; i < size; i++) ``        ``Xor ^= arr[i]; ``    ``for``(i = 1; i <= n; i++) ``        ``Xor ^= i; ``     ` `    ``/* Get the rightmost set bit in set_bit_no */``    ``set_bit_no = Xor & ~(Xor-1); ``     ` `    ``/* Now divide elements in two sets by comparing rightmost set ``    ``bit of Xor with bit at same position in each element. */``    ``for``(i = 0; i < size; i++) ``    ``{ ``        ``if``(arr[i] & set_bit_no) ``        ``x = x ^ arr[i]; ``/*Xor of first set in arr[] */``        ``else``        ``y = y ^ arr[i]; ``/*Xor of second set in arr[] */``    ``} ``    ``for``(i = 1; i <= n; i++) ``    ``{ ``        ``if``(i & set_bit_no) ``        ``x = x ^ i; ``/*Xor of first set in arr[] and {1, 2, ...n }*/``        ``else``        ``y = y ^ i; ``/*Xor of second set in arr[] and {1, 2, ...n } */``    ``} ``         ` `    ``cout<<``"The two repeating elements are "``<

## C

 `void` `printRepeating(``int` `arr[], ``int` `size)``{``  ``int` `xor = arr[0]; ``/* Will hold xor of all elements */``  ``int` `set_bit_no;  ``/* Will have only single set bit of xor */``  ``int` `i;``  ``int` `n = size - 2;``  ``int` `x = 0, y = 0;``   ` `  ``/* Get the xor of all elements in arr[] and {1, 2 .. n} */``  ``for``(i = 1; i < size; i++)``    ``xor ^= arr[i];  ``  ``for``(i = 1; i <= n; i++)``    ``xor ^= i;   `` ` `  ``/* Get the rightmost set bit in set_bit_no */``  ``set_bit_no = xor & ~(xor-1);`` ` `  ``/* Now divide elements in two sets by comparing rightmost set``   ``bit of xor with bit at same position in each element. */``  ``for``(i = 0; i < size; i++)``  ``{``    ``if``(arr[i] & set_bit_no)``      ``x = x ^ arr[i]; ``/*XOR of first set in arr[] */``    ``else``      ``y = y ^ arr[i]; ``/*XOR of second set in arr[] */``  ``}``  ``for``(i = 1; i <= n; i++)``  ``{``    ``if``(i & set_bit_no)``      ``x = x ^ i; ``/*XOR of first set in arr[] and {1, 2, ...n }*/``    ``else``      ``y = y ^ i; ``/*XOR of second set in arr[] and {1, 2, ...n } */``  ``}``   ` `  ``printf``(``"n The two repeating elements are %d & %d "``, x, y);``}     `` ` ` ` `int` `main()``{``  ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1};``  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);  ``  ``printRepeating(arr, arr_size);``  ``getchar``();``  ``return` `0;``}`

## Java

 `class` `RepeatElement``{``    ``void` `printRepeating(``int` `arr[], ``int` `size) ``    ``{``        ``/* Will hold xor of all elements */``        ``int` `xor = arr[``0``];``         ` `        ``/* Will have only single set bit of xor */``        ``int` `set_bit_no;``         ` `        ``int` `i;``        ``int` `n = size - ``2``;``        ``int` `x = ``0``, y = ``0``;`` ` `        ``/* Get the xor of all elements in arr[] and {1, 2 .. n} */``        ``for` `(i = ``1``; i < size; i++)``            ``xor ^= arr[i];``        ``for` `(i = ``1``; i <= n; i++)``            ``xor ^= i;`` ` `        ``/* Get the rightmost set bit in set_bit_no */``        ``set_bit_no = (xor & ~(xor - ``1``));`` ` `        ``/* Now divide elements in two sets by comparing rightmost set``           ``bit of xor with bit at same position in each element. */``        ``for` `(i = ``0``; i < size; i++) {``            ``int` `a = arr[i] & set_bit_no;``            ``if` `(a != ``0``)``                ``x = x ^ arr[i]; ``/*XOR of first set in arr[] */``            ``else``                ``y = y ^ arr[i]; ``/*XOR of second set in arr[] */``        ``}``        ``for` `(i = ``1``; i <= n; i++) ``        ``{``            ``int` `a = i & set_bit_no;``            ``if` `(a != ``0``)``                ``x = x ^ i; ``/*XOR of first set in arr[] and {1, 2, ...n }*/``            ``else``                ``y = y ^ i; ``/*XOR of second set in arr[] and {1, 2, ...n } */``        ``}`` ` `        ``System.out.println(``"The two reppeated elements are :"``);``        ``System.out.println(x + ``" "` `+ y);``    ``}`` ` `    ``/* Driver program to test the above function */``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``RepeatElement repeat = ``new` `RepeatElement();``        ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``        ``int` `arr_size = arr.length;``        ``repeat.printRepeating(arr, arr_size);``    ``}``}`` ` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 code to Find the ``# two repeating elements ``# in a given array``def` `printRepeating(arr, size):``     ` `    ``# Will hold xor ``    ``# of all elements ``    ``xor ``=` `arr[``0``] ``    ``n ``=` `size ``-` `2``    ``x ``=` `0``    ``y ``=` `0``     ` `    ``# Get the xor of all ``    ``# elements in arr[] ``    ``# and 1, 2 .. n ``    ``for` `i ``in` `range``(``1` `, size):``        ``xor ^``=` `arr[i] ``    ``for` `i ``in` `range``(``1` `, n ``+` `1``):``        ``xor ^``=` `i ``     ` `    ``# Get the rightmost set``    ``# bit in set_bit_no ``    ``set_bit_no ``=` `xor & ~(xor``-``1``)``     ` `    ``# Now divide elements in two``    ``# sets by comparing rightmost ``    ``# set bit of xor with bit at``    ``# same position in each element. ``    ``for` `i ``in` `range``(``0``, size):``         ` `        ``if``(arr[i] & set_bit_no):``             ` `            ``# XOR of first ``            ``# set in arr[] ``            ``x ``=` `x ^ arr[i] ``        ``else``:``             ` `            ``# XOR of second``            ``# set in arr[] ``            ``y ``=` `y ^ arr[i] ``             ` `    ``for` `i ``in` `range``(``1` `, n ``+` `1``):`` ` `        ``if``(i & set_bit_no):``             ` `            ``# XOR of first set``            ``# in arr[] and ``            ``# 1, 2, ...n ``            ``x ``=` `x ^ i ``        ``else``:``             ` `             ``# XOR of second set ``             ``# in arr[] and``             ``# 1, 2, ...n ``            ``y ``=` `y ^ i``             ` `    ``print``(``"The two repeating"``,``         ``"elements are"``, y, x)`` ` `# Driver code    ``arr ``=` `[``4``, ``2``, ``4``, ``       ``5``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(arr) ``printRepeating(arr, arr_size)`` ` `# This code is contributed ``# by Smitha`

## C#

 `using` `System;`` ` `class` `GFG``{``    ``static` `void` `printRepeating(``int` `[]arr, ``int` `size) ``    ``{``        ``/* Will hold xor of all elements */``        ``int` `xor = arr[0];``         ` `        ``/* Will have only single set bit of xor */``        ``int` `set_bit_no;``         ` `        ``int` `i;``        ``int` `n = size - 2;``        ``int` `x = 0, y = 0;`` ` `        ``/* Get the xor of all elements``         ``in arr[] and {1, 2 .. n} */``        ``for` `(i = 1; i < size; i++)``            ``xor ^= arr[i];``         ` `        ``for` `(i = 1; i <= n; i++)``            ``xor ^= i;`` ` `        ``/* Get the rightmost set bit in set_bit_no */``        ``set_bit_no = (xor & ~(xor - 1));`` ` `        ``/* Now divide elements in two sets by ``         ``comparing rightmost set bit of xor with bit``         ``at same position in each element. */``        ``for` `(i = 0; i < size; i++) {``            ``int` `a = arr[i] & set_bit_no;``         ` `            ``if` `(a != 0)``                ``/* XOR of first set in arr[] */``                ``x = x ^ arr[i]; ``            ``else``                ``/* XOR of second set in arr[] */``                ``y = y ^ arr[i]; ``        ``}``        ``for` `(i = 1; i <= n; i++) ``        ``{``            ``int` `a = i & set_bit_no;``             ` `            ``if` `(a != 0)``             ` `                ``/* XOR of first set in``                 ``arr[] and {1, 2, ...n }*/``                ``x = x ^ i; ``            ``else``             ` `                ``/* XOR of second set in ``                 ``arr[] and {1, 2, ...n } */``                ``y = y ^ i; ``        ``}`` ` `        ``Console.WriteLine(``"The two"` `+ ``            ``" reppeated elements are :"``);``        ``Console.Write(x + ``" "` `+ y);``    ``}`` ` `    ``/* Driver program to test the above function */``    ``public` `static` `void` `Main() ``    ``{``        ``int` `[]arr = {4, 2, 4, 5, 2, 3, 1};``        ``int` `arr_size = arr.Length;``         ` `        ``printRepeating(arr, arr_size);``    ``}``}`` ` `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

`The two repeating elements are 4 2`

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 5 (Use array elements as index)
Thanks to Manish K. Aasawat for suggesting this method.

```Traverse the array. Do following for every index i of A[].
{
check for sign of A[abs(A[i])] ;
if positive then
make it negative by   A[abs(A[i])]=-A[abs(A[i])];
else  // i.e., A[abs(A[i])] is negative
this   element (ith element of list) is a repetition
}

Example: A[] =  {1, 1, 2, 3, 2}
i=0;
Check sign of A[abs(A[0])] which is A[1].  A[1] is positive, so make it negative.
Array now becomes {1, -1, 2, 3, 2}

i=1;
Check sign of A[abs(A[1])] which is A[1].  A[1] is negative, so A[1] is a repetition.

i=2;
Check sign of A[abs(A[2])] which is A[2].  A[2] is  positive, so make it negative. '
Array now becomes {1, -1, -2, 3, 2}

i=3;
Check sign of A[abs(A[3])] which is A[3].  A[3] is  positive, so make it negative.
Array now becomes {1, -1, -2, -3, 2}

i=4;
Check sign of A[abs(A[4])] which is A[2].  A[2] is negative, so A[4] is a repetition.```

Note that this method modifies the original array and may not be a recommended method if we are not allowed to modify the array.

## C++

 `#include ``using` `namespace` `std; `` ` `void` `printRepeating(``int` `arr[], ``int` `size) ``{ ``    ``int` `i; ``     ` `    ``cout << ``"The repeating elements are"``; ``         ` `    ``for``(i = 0; i < size; i++) ``    ``{ ``        ``if``(arr[``abs``(arr[i])] > 0) ``            ``arr[``abs``(arr[i])] = -arr[``abs``(arr[i])]; ``        ``else``            ``cout<<``" "` `<< ``abs``(arr[i]) <<``" "``; ``    ``}     ``} `` ` `// Driver code``int` `main() ``{ ``    ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1}; ``    ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]); ``    ``printRepeating(arr, arr_size); ``    ``return` `0; ``} `` ` `// This code is contributed by rathbhupendra`

## C

 `#include ``#include `` ` `void` `printRepeating(``int` `arr[], ``int` `size)``{``  ``int` `i;  ``  ` `  ``printf``(``"\n The repeating elements are"``);``   ` `  ``for``(i = 0; i < size; i++)``  ``{``    ``if``(arr[``abs``(arr[i])] > 0)``      ``arr[``abs``(arr[i])] = -arr[``abs``(arr[i])];``    ``else``      ``printf``(``" %d "``, ``abs``(arr[i]));``  ``}         ``}     `` ` `int` `main()``{``  ``int` `arr[] = {4, 2, 4, 5, 2, 3, 1};``  ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]);``  ``printRepeating(arr, arr_size);``  ``getchar``();``  ``return` `0;``}`

## Java

 `class` `RepeatElement``{``    ``void` `printRepeating(``int` `arr[], ``int` `size)``    ``{``        ``int` `i;  ``        ``System.out.println(``"The repeating elements are : "``);``    ` `        ``for``(i = ``0``; i < size; i++)``        ``{``           ``int` `abs_val = Math.abs(arr[i]);``            ``if``(arr[abs_val] > ``0``)``                ``arr[abs_val] = -arr[abs_val];``            ``else``                ``System.out.print(abs_val + ``" "``);``        ``}         ``    ``} `` ` `    ``/* Driver program to test the above function */``    ``public` `static` `void` `main(String[] args) ``    ``{``        ``RepeatElement repeat = ``new` `RepeatElement();``        ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``        ``int` `arr_size = arr.length;``        ``repeat.printRepeating(arr, arr_size);``    ``}``}`` ` `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Python3 code for Find the two repeating ``# elements in a given array`` ` ` ` `def` `printRepeating(arr, size) :``     ` `    ``print``(``" The repeating elements are"``,end``=``" "``)``     ` `    ``for` `i ``in` `range``(``0``,size) :``         ` `        ``if``(arr[``abs``(arr[i])] > ``0``) :``            ``arr[``abs``(arr[i])] ``=` `(``-``1``) ``*` `arr[``abs``(arr[i])]``        ``else` `:``            ``print``(``abs``(arr[i]),end ``=` `" "``)`` ` `# Driver code``arr ``=` `[``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``]``arr_size ``=` `len``(arr) ``printRepeating(arr, arr_size)`` ` ` ` `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# code for Find the two repeating ``// elements in a given array`` ``using` `System;`` ` `class` `GFG``{``    ``static` `void` `printRepeating(``int` `[]arr, ``int` `size)``    ``{``        ``int` `i; ``        ``Console.Write(``"The repeating elements are : "``);``     ` `        ``for``(i = 0; i < size; i++)``        ``{``          ``int` `abs_val = Math.Abs(arr[i]);``            ``if``(arr[abs_val] > 0)``                ``arr[abs_val] = -arr[abs_val];``            ``else``                ``Console.Write(abs_val + ``" "``);``        ``}         ``    ``} `` ` `    ``/* Driver program to test the above function */``    ``public` `static` `void` `Main() ``    ``{``        ``int` `[]arr = {4, 2, 4, 5, 2, 3, 1};``        ``int` `arr_size = arr.Length;``         ` `        ``printRepeating(arr, arr_size);``    ``}``}`` ` `// This code is contributed by Sam007`

## PHP

 ` 0)``    ``\$arr``[``abs``(``\$arr``[``\$i``])] = -``\$arr``[``abs``(``\$arr``[``\$i``])];``    ``else``    ``echo`  `abs``(``\$arr``[``\$i``]),``" "``;``}         ``}     `` ` ` ` `    ``\$arr` `= ``array` `(4, 2, 4, 5, 2, 3, 1);``    ``\$arr_size` `= sizeof(``\$arr``);``    ``printRepeating(``\$arr``, ``\$arr_size``);``     ` `     ` `#This code is contributed by aj_36``?>`

## Javascript

 ``

Output

`The repeating elements are 4  2 `

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 6 (Similar to method 5)

Thanks to Vivek Kumar for suggesting this method.

The point is to increment every element at (arr[i]th-1)th index by N-1 (as the elements are present upto N-2 only) and at the same time check if element at that index when divided by (N-1) gives 2. If this is true then it means that the element has appeared twice and we can easily say that this is one of our answers. This is one of the very useful techniques when we want to calculate Frequencies of Limited Range Array Elements  (see this post to know more).

This method works on the fact that the remainder of an element when divided by any number greater than that element will always give that same element. Similarly, as we are incrementing each element at (arr[i]th-1) index by N-1, so when this incremented element is divided by N-1 it will give number of times we have added N-1 to it, hence giving us the occurrence of that index (according to 1-based indexing).

Below given code applies this method:

## C++

 `#include ``using` `namespace` `std;`` ` `void` `twoRepeated(``int` `arr[], ``int` `N)``{``    ``int` `m = N - 1;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``arr[arr[i] % m - 1] += m;``        ``if` `((arr[arr[i] % m - 1] / m) == 2)``            ``cout << arr[i] % m << ``" "``;``    ``}``}``// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 2, 4, 5, 2, 3, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << ``"The two repeating elements are "``;``    ``twoRepeated(arr, n);`` ` `    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `#include `` ` `void` `twoRepeated(``int` `arr[], ``int` `N)``{``    ``int` `m = N - 1;``    ``for` `(``int` `i = 0; i < N; i++) {``        ``arr[arr[i] % m - 1] += m;``        ``if` `((arr[arr[i] % m - 1] / m) == 2)``            ``printf``(``"%d "``, arr[i]);``    ``}``}``// Driver Code``int` `main()``{``    ``int` `arr[] = { 4, 2, 4, 5, 2, 3, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``printf``(``"The two repeating elements are "``);``    ``twoRepeated(arr, n);`` ` `    ``return` `0;``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `import` `java.io.*;`` ` `class` `GFG {`` ` `    ``public` `static` `void` `twoRepeated(``int` `arr[], ``int` `N)``    ``{``        ``int` `m = N - ``1``;``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``arr[arr[i] % m - ``1``] += m;`` ` `            ``if` `((arr[arr[i] % m - ``1``] / m) == ``2``)``                ``System.out.printf(arr[i] % m + ``" "``);``        ``}``    ``}`` ` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1` `};``        ``int` `n = ``7``;``        ``System.out.printf(``            ``"The two repeating elements are "``);``        ``twoRepeated(arr, n);``    ``}``}`` ` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python program for the above approach``def` `twoRepeated(arr, N):``    ``m ``=` `N ``-` `1``    ``for` `i ``in` `range``(N):``        ``arr[arr[i] ``%` `m ``-` `1``] ``+``=` `m``        ``if` `((arr[arr[i] ``%` `m ``-` `1``] ``/``/` `m) ``=``=` `2``):``            ``print``(arr[i] ``%` `m ,end``=` `" "``)``     ` `# Driver Code``arr ``=` `[``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``]``n ``=` `len``(arr)``print``(``"The two repeating elements are "``, end ``=` `"")``twoRepeated(arr, n)`` ` `# This code is contributed by Shubham Singh`

## C#

 `// C# program for the above approach``using` `System;`` ` `public` `class` `GFG``{``public` `static` `void` `twoRepeated(``int``[] arr, ``int` `N)``{``    ``int` `m = N - 1;``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``arr[arr[i] % m - 1] += m;``         ` `        ``if` `((arr[arr[i] % m - 1] / m) == 2)``            ``Console.Write(arr[i] % m + ``" "``);``    ``}``}`` ` `// Driver code``public` `static` `void` `Main(String []args)``{``    ``int``[] arr = { 4, 2, 4, 5, 2, 3, 1 };``    ``int` `n = 7;``     ` `    ``Console.Write(``"The two repeating elements are "``);``     ` `    ``twoRepeated(arr, n);``}``}`` ` `// This code is contributed by splevel62.`

## Javascript

 ``

Output

`The two repeating elements are 4 2 `

Time Complexity: O(n)
Auxiliary Space: O(1)

Method 7
The point here is to enter the array elements one by one into the unordered set. If a particular element is already present in the set it’s a repeating element.

## C++

 `// C++ program to Find the two repeating ``// elements in a given array``#include ``using` `namespace` `std;`` ` `void` `printRepeating(``int` `arr[], ``int` `size)``{``      ``unordered_set<``int``>s;``      ``cout<<``"The two Repeating elements are : "``;``    ``for``(``int` `i=0;i

## Java

 `// Java program to Find the two repeating ``// elements in a given array``import` `java.util.*;``class` `GFG{`` ` `  ``static` `void` `printRepeating(``int` `arr[], ``int` `size)``  ``{``    ``HashSets = ``new` `HashSet<>();``    ``System.out.print(``"The two Repeating elements are : "``);``    ``for``(``int` `i = ``0``; i < size; i++)``    ``{``      ``if``(!s.isEmpty() && s.contains(arr[i]))``        ``System.out.print(arr[i]+``"  "``);``      ``s.add(arr[i]);``    ``}``  ``}`` ` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `arr[] = {``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1``};``    ``int` `arr_size = arr.length;``    ``printRepeating(arr, arr_size);``  ``}``}`` ` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to find the two repeating ``# elements in a given array``def` `printRepeating(arr, size):``     ` `    ``s ``=` `set``()``    ``print``(``"The two Repeating elements are : "``, end ``=` `"")``     ` `    ``for` `i ``in` `range``(size):``        ``if` `(``len``(s) ``and` `arr[i] ``in` `s):``            ``print``(arr[i], end ``=` `"  "``)``             ` `        ``s.add(arr[i])``         ` `# Driver code``arr ``=` `[ ``4``, ``2``, ``4``, ``5``, ``2``, ``3``, ``1` `]``arr_size ``=` `len``(arr)``printRepeating(arr, arr_size)`` ` `# This code is contributed by Shubham Singh`

## C#

 `// C# program to Find the two repeating ``// elements in a given array``using` `System;``using` `System.Collections.Generic;`` ` `public` `class` `GFG{``     ` `  ``static` `void` `printRepeating(``int``[] arr, ``int` `size)``  ``{``    ``HashSet<``int``>s = ``new` `HashSet<``int``>();``    ``Console.Write(``"The two Repeating elements are : "``);``    ``for``(``int` `i = 0; i < size; i++)``    ``{``      ``if``(s.Count != 0 && s.Contains(arr[i]))``        ``Console.Write(arr[i] + ``"  "``);``      ``s.Add(arr[i]);``    ``}``  ``}`` ` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int``[] arr = {4, 2, 4, 5, 2, 3, 1};``    ``int` `arr_size = arr.Length;``    ``printRepeating(arr, arr_size);``  ``}``}`` ` `// This code is contributed by Shubham Singh`

## Javascript

 ``

Output

`The two Repeating elements are : 4  2  `

Time Complexity: O(n)

Auxiliary Space: O(n)

Please write comments if you find the above codes/algorithms incorrect, or find better ways to solve the same problem.

My Personal Notes arrow_drop_up