The repeated number, without changing the array

def find_duplicate(nums):
    slow, fast = nums[0], nums[nums[0]]
    while slow != fast:                 # phase 1: meet somewhere in the cycle
        slow = nums[slow]
        fast = nums[nums[fast]]
    a = 0
    while a != slow:                    # phase 2: walk in to the start of the cycle
        a = nums[a]
        slow = nums[slow]
    return a

#include <vector>

int solve(const std::vector<int>& nums) {
    int slow = nums[0], fast = nums[nums[0]];
    while (slow != fast) { slow = nums[slow]; fast = nums[nums[fast]]; }   // phase 1: meet in the cycle
    int a = 0;
    while (a != slow) { a = nums[a]; slow = nums[slow]; }                 // phase 2: walk in to its start
    return a;
}

class Solution {
    public int findDuplicate(int[] nums) {
        int slow = nums[0], fast = nums[nums[0]];
        while (slow != fast) { slow = nums[slow]; fast = nums[nums[fast]]; }   // phase 1: meet in the cycle
        int a = 0;
        while (a != slow) { a = nums[a]; slow = nums[slow]; }                 // phase 2: walk in to its start
        return a;
    }
}

function findDuplicate(nums) {
  let slow = nums[0], fast = nums[nums[0]];
  while (slow !== fast) { slow = nums[slow]; fast = nums[nums[fast]]; }   // phase 1: meet in the cycle
  let a = 0;
  while (a !== slow) { a = nums[a]; slow = nums[slow]; }                 // phase 2: walk in to its start
  return a;
}

fn solve(nums: &[i64]) -> i64 {
    let at = |i: i64| nums[i as usize];
    let (mut slow, mut fast) = (at(0), at(at(0)));
    while slow != fast { slow = at(slow); fast = at(at(fast)); }   // phase 1: meet in the cycle
    let mut a = 0;
    while a != slow { a = at(a); slow = at(slow); }                 // phase 2: walk in to its start
    a
}

import Data.Array

solve :: [Int] -> Int
solve nums = walk 0 meet
  where
    arr = listArray (0, length nums - 1) nums
    f i = arr ! i
    -- phase 1: slow takes one step, fast two, until they meet in the cycle
    meet = go (f 0) (f (f 0))
    go s q | s == q    = s
           | otherwise = go (f s) (f (f q))
    -- phase 2: one from 0, one from the meeting point, one step each
    walk a s | a == s    = a
             | otherwise = walk (f a) (f s)