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:1

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:5

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[0], arr[arr[0]], arr[arr[arr[0]]], arr[arr[arr[arr[0]]]] …….

- Each new element in the sequence is an element in
**arr[]**at the index of the previous element. - Starting from
**x = arr[0]**, 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}index 0 1 2 3 4 5 6 arr 2 6 4 1 3 1 5 Starting from index 0, the traversal looks as follows:

arr[0] =

**2**–> arr[2] =**4**–> arr[4] =**3**–> arr[3] =**1**–> arr[1] =**6**–> arr[6] =**5**–> arr[5] =**1**. - 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 <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the duplicate ` `// value in the given array arr[] ` `void` `findDuplicate(` `int` `arr[]) ` `{ ` ` ` ` ` `// Initialise variables ` ` ` `int` `tortoise = arr[0]; ` ` ` `int` `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 ` ` ` `cout << tortoise; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `// Given array ` ` ` `int` `arr[] = { 2, 6, 4, 1, 3, 1, 5 }; ` ` ` ` ` `// Function Call ` ` ` `findDuplicate(arr); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

## 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[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 ` ` ` `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 ` |

*chevron_right*

*filter_none*

**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.

## Recommended Posts:

- Find any one of the multiple repeating elements in read only array
- Find the only repeating element in a sorted array of size n
- Queries to check if any non-repeating element exists within range [L, R] of an Array
- Make all elements zero by decreasing any two elements by one at a time
- Merge K minimum elements of the array until there is only one element
- Find the two repeating elements in a given array
- Find sum of non-repeating (distinct) elements in an array
- Count all distinct pairs of repeating elements from the array for every array element
- Maximize sum of atmost K elements in array by taking only corner elements | Set 2
- Count of subarrays whose products don't have any repeating prime factor
- Strings formed from given characters without any consecutive repeating characters
- Count subarrays consisting of only 0's and only 1's in a binary array
- Find set of m-elements with difference of any two elements is divisible by k
- Make the list non-decreasing by changing only one digit of the elements
- Sum of all elements repeating 'k' times in an array
- Product of non-repeating (distinct) elements in an Array
- Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
- Split array into subarrays at minimum cost by minimizing count of repeating elements in each subarray
- Maximize sum of K elements in Array by taking only corner elements
- Closest pair in an Array such that one number is multiple of the other

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.