Find All Duplicates in an Array

Find All Duplicates in an Array - Problem

Given an integer array nums of length n where all the integers are in the range [1, n] and each integer appears at most twice, return an array of all the integers that appear exactly twice.

Constraint: You must write an algorithm that runs in O(n) time and uses only constant auxiliary space (excluding the space needed to store the output).

Since all numbers are in range [1, n], we can use the array indices cleverly to track which numbers we've seen before.

Input & Output

Example 1 — Multiple Duplicates

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

› Output: [2,3]

💡 Note: Numbers 2 and 3 each appear exactly twice in the array. Number 2 appears at indices 2 and 5, number 3 appears at indices 1 and 6.

Example 2 — Single Duplicate

$ Input: nums = [1,1,2]

› Output: [1]

💡 Note: Only number 1 appears twice (at indices 0 and 1). Number 2 appears once, so it's not included.

Example 3 — No Duplicates

$ Input: nums = [1]

› Output: []

💡 Note: Array has only one element, so no number can appear twice. Return empty array.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ n
Each element in nums appears once or twice

Visualization

Tap to expand

Asked in

G Google 28 a Amazon 22 M Microsoft 15 A Apple 12

The key insight is using the constraint that all numbers are in range [1, n] to treat array indices as a hash map. The optimal approach marks indices negative when first seeing a number, detecting duplicates when encountering already-negative indices. Best solution: Index marking with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Count Each Number

⏱️ Time: O(n²) Space: O(1)

Check every number from 1 to n and count its occurrences in the array. If a number appears exactly twice, add it to the result. This approach is simple but inefficient.

Hash Map Frequency Count

⏱️ Time: O(n) Space: O(n)

Make two passes through the array: first pass counts the frequency of each number using a hash map, second pass collects all numbers that appear exactly twice. This is faster than brute force but uses O(n) extra space.

Index Marking (Constant Space)

⏱️ Time: O(n) Space: O(1)

Since all numbers are in range [1, n], we can use the array itself as a hash map. For each number, we mark the corresponding index by making it negative. If we encounter an already negative number, we found a duplicate.

Brute Force - Count Each Number — Algorithm Steps

For each number i from 1 to n
Count how many times i appears in nums
If count equals 2, add i to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Number 1

Count how many times 1 appears

Check Number 2

Count how many times 2 appears

Continue

Repeat for all numbers 1 to n

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    int* result = malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 1; i <= numsSize; i++) {
        int count = 0;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == i) {
                count++;
            }
        }
        if (count == 2) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[100000];
    int size = 0;
    
    // Parse JSON array [1,2,3] -> extract numbers
    int i = 1; // Skip opening bracket
    while (i < strlen(line) - 1) { // Skip closing bracket
        if (line[i] >= '0' && line[i] <= '9') {
            int num = 0;
            while (i < strlen(line) && line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            nums[size++] = num;
        } else {
            i++;
        }
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n numbers, we scan the entire array of n elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

178.0K Views

Medium-High Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Count Each Number — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler