 GFG App
Open App Browser
Continue

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

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