 Open in App
Not now

# Find any one of the multiple repeating elements in read only array | Set 2

• Difficulty Level : Medium
• Last Updated : 22 Oct, 2021

Given a read-only array arr[] of size N + 1, find one of the multiple repeating elements in the array where the array contains integers only between 1 and N
Note: Read-only array means that the contents of the array can’t be modified.

Examples:

Input: N = 5, arr[] = {1, 1, 2, 3, 5, 4}
Output:
Explanation:
1 is the only number repeated in the array.

Input: N = 10, arr[] = {10, 1, 2, 3, 5, 4, 9, 8, 5, 6, 4}
Output:
Explanation:
5 is the one of the number repeated in the array.

In the previous post, we have discussed the same article with a space complexity O(N) and O(sqrt(N)).

Approach: This approach is based on Floyd’s Tortoise and Hare Algorithm (Cycle Detection Algorithm).

• Use the function f(x) = arr[x] to construct the sequence:

arr, arr[arr], arr[arr[arr]], arr[arr[arr[arr]]] …….

• Each new element in the sequence is an element in arr[] at the index of the previous element.
• Starting from x = arr, it will produce a linked list with a cycle.
• The cycle appears because arr[] contains duplicate elements(at least one). The duplicate value is an entrance to the cycle. Given below is an example to show how cycle exists:
For Example: Let the array arr[] = {2, 6, 4, 1, 3, 1, 5}

Starting from index 0, the traversal looks as follows:

arr = 2 –> arr = 4 –> arr = 3 –> arr = 1 –> arr = 6 –> arr = 5 –> arr = 1

The sequence forms cycle as shown below: • Algorithm consists of two parts and uses two pointers, usually called tortoise and hare.
•  hare = arr[arr[hare]] is twice as fast as tortoise = arr[tortoise].
• Since the hare goes fast, it would be the first one who enters the cycle and starts to run around the cycle.
• At some point, the tortoise enters the cycle as well, and since it’s moving slower the hare catches the tortoise up at some intersection point.
• Note that the intersection point is not the cycle entrance in the general case, but the two intersect at somewhere middle in cycle.
• Move tortoise to the starting point of sequence and hare remains within cycle and both move with the same speed i.e. tortoise = arr[tortoise] and hare = arr[hare]. Now they intersect at duplicate element.

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Function to find the duplicate``// value in the given array arr[]``void` `findDuplicate(``int` `arr[])``{` `    ``// Initialise variables``    ``int` `tortoise = arr;``    ``int` `hare = arr;` `    ``// Loop till we find the``    ``// duplicate element``    ``while` `(1) {` `        ``tortoise = arr[tortoise];` `        ``// Hare moves with twice``        ``// the speed of tortoise``        ``hare = arr[arr[hare]];``        ``if` `(tortoise == hare)``            ``break``;``    ``}` `    ``tortoise = arr;` `    ``// Loop to get start point``    ``// of the cycle as start``    ``// point will be the duplicate``    ``// element``    ``while` `(tortoise != hare) {``        ``tortoise = arr[tortoise];``        ``hare = arr[hare];``    ``}` `    ``// Print the duplicate element``    ``cout << tortoise;``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 6, 4, 1, 3, 1, 5 };` `    ``// Function Call``    ``findDuplicate(arr);` `    ``return` `0;``}`

## Java

 `// Java code for the above approach``class` `GFG{` `// Function to find the duplicate``// value in the given array arr[]``static` `void` `findDuplicate(``int` `arr[])``{``    ` `    ``// Initialise variables``    ``int` `tortoise = arr[``0``];``    ``int` `hare = arr[``0``];` `    ``// Loop till we find the``    ``// duplicate element``    ``while` `(``true``)``    ``{``        ``tortoise = arr[tortoise];``        ` `        ``// Hare moves with twice``        ``// the speed of tortoise``        ``hare = arr[arr[hare]];``        ``if` `(tortoise == hare)``            ``break``;``    ``}``    ` `    ``tortoise = arr[``0``];` `    ``// Loop to get start point``    ``// of the cycle as start``    ``// point will be the duplicate``    ``// element``    ``while` `(tortoise != hare)``    ``{``        ``tortoise = arr[tortoise];``        ``hare = arr[hare];``    ``}` `    ``// Print the duplicate element``    ``System.out.print(tortoise);``}` `// Driver Code``public` `static` `void` `main (String []args)``{``    ` `    ``// Given array``    ``int` `arr[] = { ``2``, ``6``, ``4``, ``1``, ``3``, ``1``, ``5` `};` `    ``// Function Call``    ``findDuplicate(arr);``}``}` `// This code is contributed by chitranayal`

## Python3

 `# Python3 program for the above approach` `# Function to find the duplicate``# value in the given array arr[]``def` `findDuplicate(arr):` `    ``# Initialise variables``    ``tortoise ``=` `arr[``0``]``    ``hare ``=` `arr[``0``]` `    ``# Loop till we find the``    ``# duplicate element``    ``while` `(``1``):` `        ``tortoise ``=` `arr[tortoise]` `        ``# Hare moves with twice``        ``# the speed of tortoise``        ``hare ``=` `arr[arr[hare]]``        ``if` `(tortoise ``=``=` `hare):``            ``break` `    ``tortoise ``=` `arr[``0``]` `    ``# Loop to get start point``    ``# of the cycle as start``    ``# point will be the duplicate``    ``# element``    ``while` `(tortoise !``=` `hare):``        ``tortoise ``=` `arr[tortoise]``        ``hare ``=` `arr[hare]` `    ``# Print the duplicate element``    ``print` `(tortoise)` `# Driver Code` `# Given array``arr ``=` `[ ``2``, ``6``, ``4``, ``1``, ``3``, ``1``, ``5` `]` `# Function Call``findDuplicate(arr)` `# This code is contributed by PratikBasu`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{`` ` `// Function to find the duplicate``// value in the given array []arr``static` `void` `findDuplicate(``int` `[]arr)``{``     ` `    ``// Initialise variables``    ``int` `tortoise = arr;``    ``int` `hare = arr;`` ` `    ``// Loop till we find the``    ``// duplicate element``    ``while` `(``true``)``    ``{``        ``tortoise = arr[tortoise];``         ` `        ``// Hare moves with twice``        ``// the speed of tortoise``        ``hare = arr[arr[hare]];``        ``if` `(tortoise == hare)``            ``break``;``    ``}``     ` `    ``tortoise = arr;`` ` `    ``// Loop to get start point``    ``// of the cycle as start``    ``// point will be the duplicate``    ``// element``    ``while` `(tortoise != hare)``    ``{``        ``tortoise = arr[tortoise];``        ``hare = arr[hare];``    ``}`` ` `    ``// Print the duplicate element``    ``Console.Write(tortoise);``}`` ` `// Driver Code``public` `static` `void` `Main(String []args)``{``     ` `    ``// Given array``    ``int` `[]arr = { 2, 6, 4, 1, 3, 1, 5 };`` ` `    ``// Function Call``    ``findDuplicate(arr);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`1`

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

My Personal Notes arrow_drop_up