Find All Numbers Disappeared in an Array - Practice Coding Problems

Find All Numbers Disappeared in an Array - Problem

You're given an array nums containing n integers where each number is guaranteed to be in the range [1, n]. Your task is to find all the missing numbers from this range that don't appear in the array.

Think of it like a roll call - you have a list of student IDs from 1 to n, but some students are absent. You need to identify which student numbers are missing from your attendance list.

Goal: Return an array containing all integers in the range [1, n] that are not present in the input array.

Example: If nums = [4,3,2,7,8,2,3,1] and n = 8, the missing numbers are [5, 6] because all numbers from 1 to 8 should be present, but 5 and 6 are nowhere to be found.

Input & Output

example_1.py — Basic Case

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

› Output: [5,6]

💡 Note: The array contains numbers in range [1,8]. Numbers 1,2,3,4,7,8 are present (some appear multiple times), but 5 and 6 are completely missing.

example_2.py — Single Missing

$ Input: [1,1]

› Output: [2]

💡 Note: Array length is 2, so we expect numbers [1,2]. Number 1 appears twice, but number 2 is missing.

example_3.py — All Present

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

› Output: []

💡 Note: All numbers from 1 to 4 are present in the array, so no numbers are missing.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ n
Follow up: Could you do it without extra space and in O(n) runtime?

Visualization

Tap to expand

Understanding the Visualization

The Messy List

Your attendance shows: [4,3,2,7,8,2,3,1] - some duplicates, some missing

Smart Marking

Use the list positions as markers - mark position (number-1) as 'present' by making it negative

Find the Absent

After marking, positions that remain positive indicate missing students

Key Takeaway

🎯 Key Insight: When numbers are in range [1,n] and you have n positions, you can use the array itself as a hash table by leveraging the sign bit to mark presence!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

This problem can be solved optimally using in-place marking with O(n) time and O(1) space. The key insight is to use the array itself as a hash table by marking visited numbers as negative values. Since all numbers are in range [1,n], we can map each number to its corresponding array index and use the sign bit to track presence.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each number 1 to n, scan the entire array to check if it exists
In-Place Marking (Optimal)	O(n)	O(1)	Use array indices as hash keys by marking visited positions as negative
Two-Pass Hash Set	O(n)	O(n)	First pass: build a set of present numbers. Second pass: find missing ones

Brute Force (Nested Loops) — Algorithm Steps

Create an empty result list to store missing numbers
For each number i from 1 to n:
Scan through the entire input array to find number i
If number i is not found, add it to result list
Return the result list

Visualization

Tap to expand

Step-by-Step Walkthrough

Check number 1

Scan entire array [4,3,2,7,8,2,3,1] looking for 1 - Found!

Check number 2

Scan entire array looking for 2 - Found!

Check number 5

Scan entire array looking for 5 - Not found, add to result

Code -

solution.c — C

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

int* findDisappearedNumbers(int* nums, int numsSize, int* returnSize) {
    int* result = (int*)malloc(numsSize * sizeof(int));
    *returnSize = 0;
    
    // Check each number from 1 to n
    for (int i = 1; i <= numsSize; i++) {
        int found = 0;
        // Scan entire array to find number i
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == i) {
                found = 1;
                break;
            }
        }
        
        // If not found, add to result
        if (!found) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    // Simple input parsing for demonstration
    int nums[] = {4, 3, 2, 7, 8, 2, 3, 1};
    int numsSize = 8;
    int returnSize;
    
    int* result = findDisappearedNumbers(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n numbers, we scan through the array of size n, giving us n × n operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space besides the result array (which doesn't count toward space complexity)

✓ Linear Space

32.9K Views

High Frequency

~15 min Avg. Time

1.2K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler