Find All Duplicates in an Array - Practice Coding Problems

Find All Duplicates in an Array - Problem

You're given an integer array nums of length n where all integers are in the range [1, n] and each integer appears at most twice. Your task is to find and return an array containing all integers that appear exactly twice.

🎯 Challenge: Can you solve this in O(n) time using only O(1) extra space (excluding output space)?

Example: Given [4,3,2,7,8,2,3,1], the duplicates are [2,3] since they each appear twice.

Input & Output

example_1.py — Basic Case

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

› Output: [2,3]

💡 Note: Numbers 2 and 3 each appear exactly twice in the array, so they are the duplicates we need to return.

example_2.py — Single Duplicate

$ Input: [1,1,2]

› Output: [1]

💡 Note: Only the number 1 appears twice, so it's the only duplicate to return.

example_3.py — No Duplicates

$ Input: [1]

› Output: []

💡 Note: Single element array cannot have duplicates, so return empty array.

Visualization

Tap to expand

Understanding the Visualization

Read Current Element

Take the absolute value of current element to get the actual number

Calculate Target Index

Subtract 1 from the number to get the corresponding array index (1-indexed to 0-indexed)

Check Marker

If the value at target index is negative, this number was seen before - it's a duplicate!

Set Marker

If positive, make it negative to mark this number as 'seen' for future iterations

Key Takeaway

🎯 Key Insight: Transform constraints into advantages - use the [1,n] range property to create an in-place hash table with negative markers!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with O(1) hash set operations

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n elements in worst case

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ n
Each integer appears at most twice

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses the array itself as a hash table by leveraging the constraint that all numbers are in range [1,n]. When processing number x, we mark position nums[x-1] as negative. If we encounter an already negative value, we've found a duplicate! This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First pass counts frequencies, second pass finds duplicates
Optimal: Array Index as Hash (Constant Space)	O(n)	O(1)	Use array indices as hash table by marking visited positions negative
One-Pass Hash Table	O(n)	O(n)	Track seen elements and identify duplicates in single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Compare each element with every other element to find duplicates

Two-Pass Hash Table — Algorithm Steps

First pass: Count frequency of each element using hash table
Second pass: Iterate through array and collect elements with frequency 2
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

First pass: Count

Build frequency map of all elements

Second pass: Collect

Find elements with frequency exactly 2

Code -

solution.c — C

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

int* findDuplicates(int* nums, int numsSize, int* returnSize) {
    // Use array as hash table since values are in range [1, n]
    int* count = (int*)calloc(numsSize + 1, sizeof(int));
    
    // First pass: count frequencies
    for (int i = 0; i < numsSize; i++) {
        count[nums[i]]++;
    }
    
    // Second pass: find elements with frequency 2
    int* result = (int*)malloc(numsSize * sizeof(int));
    int resultSize = 0;
    int* seen = (int*)calloc(numsSize + 1, sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        if (count[nums[i]] == 2 && !seen[nums[i]]) {
            result[resultSize++] = nums[i];
            seen[nums[i]] = 1;
        }
    }
    
    *returnSize = resultSize;
    free(count);
    free(seen);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two separate passes through the array

✓ Linear Growth

Space Complexity

O(n)

Hash table stores up to n elements in worst case

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ n
Each integer appears at most twice

78.5K Views

High Frequency

~18 min Avg. Time

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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler