Related Articles

# 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up