First Missing Positive - Practice Coding Problems

First Missing Positive - Problem

Given an unsorted integer array nums, you need to find the smallest positive integer that is missing from the array. This is a challenging problem that tests your ability to think creatively about array manipulation.

For example, if you have the array [1, 2, 0], the smallest missing positive is 3. If you have [3, 4, -1, 1], the missing positive is 2.

The real challenge here is the constraint: you must solve this in O(n) time using only O(1) auxiliary space. This means you cannot use extra hash tables or arrays that grow with input size!

Input & Output

example_1.py — Basic Case

$ Input: [1,2,0]

› Output: 3

💡 Note: The numbers 1 and 2 are present, but 3 is the first positive integer that is missing.

example_2.py — Unordered Array

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

› Output: 2

💡 Note: The array contains 1, 3, and 4, but is missing 2, which is the smallest positive integer not present.

example_3.py — All Consecutive

$ Input: [7,8,9,11,12]

› Output: 1

💡 Note: The smallest positive integer 1 is missing from this array of larger numbers.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
Follow up: Could you implement an algorithm that runs in O(n) time and uses constant extra space?

Visualization

Tap to expand

Understanding the Visualization

Chaos to Order

Initially, guests are requesting random rooms: some want impossible rooms (0, -1), others want rooms beyond capacity

Smart Assignment

Instead of creating a separate registry, use the guest list itself as a room chart

Cyclic Arrangement

For each valid request, place the guest in their preferred position in the list

Find Empty Room

Scan the arranged list - the first position without correct occupant reveals the available room

Key Takeaway

🎯 Key Insight: Transform the array into a position-based hash table where index i represents number i+1. This allows O(n) time with O(1) space by leveraging the constraint that answers are bounded by array length.

Asked in

G Google 85 a Amazon 72 f Meta 65 ⊞ Microsoft 58 Apple 45

The optimal solution uses the array itself as a hash table by placing each number i at index i-1. This achieves O(n) time and O(1) space complexity. The key insight is that for an array of length n, the answer must be in range [1, n+1], so we can use cyclic sort to position elements correctly, then scan for the first mismatch.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Approach (Two Pass)	O(n)	O(n)	Build a hash set of all numbers, then check 1, 2, 3... until we find a missing one
Cyclic Sort / Index Mapping (Optimal O(n) Space)	O(n)	O(1)	Use array indices as hash table - place each number at its corresponding index position
Brute Force (Linear Search for Each Positive)	O(n²)	O(1)	For each positive integer starting from 1, scan the entire array to check if it exists

Hash Set Approach (Two Pass) — Algorithm Steps

Create a hash set and add all numbers from the array
Start checking from candidate = 1
For each candidate, check if it exists in the hash set
Return the first candidate that's not in the hash set

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Set

Add all array elements to hash set

Sequential Search

Check 1, 2, 3... in hash set

Found Missing

First number not in set is the answer

Code -

solution.c — C

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

int firstMissingPositive(int* nums, int numsSize) {
    // Simple hash table using array (assuming reasonable input range)
    bool present[100001] = {false};
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0 && nums[i] <= 100000) {
            present[nums[i]] = true;
        }
    }
    
    for (int candidate = 1; candidate <= 100000; candidate++) {
        if (!present[candidate]) {
            return candidate;
        }
    }
    return 100001;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to build hash set, at most n+1 lookups to find answer

✓ Linear Growth

Space Complexity

O(n)

Hash set can store up to n elements in worst case

⚡ Linearithmic Space

89.5K Views

High Frequency

~25 min Avg. Time

3.4K 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

Hash Set Approach (Two Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler