Find the Duplicate Number - Practice Coding Problems

Find the Duplicate Number - Problem

You're given an array nums containing n + 1 integers, where each integer is in the range [1, n] inclusive. Here's the catch: exactly one number appears twice, while all others appear exactly once.

Your mission: Find that duplicate number!

The Challenge: You must solve this without modifying the original array and using only constant extra space (O(1)).

Example: If nums = [1,3,4,2,2], then n = 4 and we have 5 integers. The duplicate is 2.

This problem has several elegant solutions - from brute force to a brilliant cycle detection approach that treats the array like a linked list!

Input & Output

example_1.py — Basic Case

$ Input: [1,3,4,2,2]

› Output: 2

💡 Note: The number 2 appears twice in the array, so it's the duplicate we need to find.

example_2.py — Different Duplicate

$ Input: [3,1,3,4,2]

› Output: 3

💡 Note: Here, the number 3 appears at indices 0 and 2, making it the duplicate number.

example_3.py — Minimum Size

$ Input: [1,1]

› Output: 1

💡 Note: With n=1, we have 2 elements. Since both are 1, the duplicate is 1.

Visualization

Tap to expand

Understanding the Visualization

The Problem Setup

We have n+1 numbers in range [1,n], so one number must appear twice by pigeonhole principle

Brute Force Approach

Compare every pair - like checking every combination of keys to find matching room numbers

Binary Search Insight

Count elements ≤ mid value. If count > mid, duplicate is in lower half of range

The Cycle Detection Breakthrough

Treat array as linked list. Duplicate creates cycle. Find cycle start using Floyd's algorithm

Key Takeaway

🎯 Key Insight: The duplicate number creates a cycle when we treat the array as a linked list. Floyd's cycle detection algorithm elegantly finds where this cycle begins in optimal time and space complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pointer traverses the array at most twice, giving us linear time

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, constant extra space

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
nums.length == n + 1
1 ≤ nums[i] ≤ n
All integers in nums appear only once except for exactly one integer which appears twice

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 28 Apple 22

The optimal solution uses Floyd's Cycle Detection Algorithm with O(n) time and O(1) space. By treating the array as a linked list where each value points to an index, the duplicate number creates a cycle. The tortoise and hare approach elegantly finds where this cycle begins - which is our duplicate number!

Common Approaches

Approach	Time	Space	Notes
✓ Floyd's Cycle Detection (Two Pointers)	O(n)	O(1)	Treat the array as a linked list and use Floyd's algorithm to detect the cycle
Brute Force (Nested Loops)	O(n²)	O(1)	Compare every element with every other element to find the duplicate
Binary Search on Answer	O(n log n)	O(1)	Use binary search on the range [1,n] and count elements to find the duplicate

Floyd's Cycle Detection (Two Pointers) — Algorithm Steps

Phase 1: Use slow and fast pointers to detect cycle existence
Move slow pointer one step, fast pointer two steps
When they meet, we know there's a cycle
Phase 2: Find the start of the cycle (duplicate number)
Reset one pointer to start, keep other at meeting point
Move both one step at a time until they meet again

Visualization

Tap to expand

Step-by-Step Walkthrough

Treat array as linked list

Each value points to an index, creating a graph structure

Phase 1: Detect cycle

Slow and fast pointers will eventually meet inside the cycle

Phase 2: Find cycle start

Reset one pointer and move both at same speed to find entry point

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findDuplicate(int* nums, int numsSize) {
    // Phase 1: Detect if cycle exists
    int slow = nums[0];
    int fast = nums[0];
    
    // Move slow one step, fast two steps
    do {
        slow = nums[slow];
        fast = nums[nums[fast]];
    } while (slow != fast);
    
    // Phase 2: Find the start of cycle
    slow = nums[0];
    while (slow != fast) {
        slow = nums[slow];
        fast = nums[fast];
    }
    
    return slow;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int nums[1000];
    int size = 0;
    char *token = strtok(input + 1, ",]");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", findDuplicate(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each pointer traverses the array at most twice, giving us linear time

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, constant extra space

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
nums.length == n + 1
1 ≤ nums[i] ≤ n
All integers in nums appear only once except for exactly one integer which appears twice

68.3K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Floyd's Cycle Detection (Two Pointers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler