Kth Missing Positive Number - Practice Coding Problems

Kth Missing Positive Number - Problem

Find the Kth Missing Positive Integer

You're given a sorted array of positive integers with some numbers missing from the sequence. Your task is to find the kth missing positive integer that should have been in the natural sequence but isn't present in the array.

For example, if the array is [2, 3, 4, 7, 11], the missing positive integers are 1, 5, 6, 8, 9, 10, 12, ...

Goal: Return the kth missing positive integer efficiently.
Input: A sorted array of positive integers and an integer k
Output: The kth missing positive integer

Input & Output

example_1.py — Basic Case

$ Input: arr = [2,3,4,7,11], k = 5

› Output: 9

💡 Note: The missing positive integers are [1,5,6,8,9,10,12,...]. The 5th missing positive integer is 9.

example_2.py — Small Array

$ Input: arr = [1,2,3,4], k = 2

› Output: 6

💡 Note: The missing positive integers are [5,6,7,8,...]. The 2nd missing positive integer is 6.

example_3.py — Array Starts High

$ Input: arr = [10,20,30], k = 1

› Output: 1

💡 Note: The missing positive integers are [1,2,3,4,5,6,7,8,9,11,...]. The 1st missing positive integer is 1.

Constraints

1 ≤ arr.length ≤ 1000
1 ≤ arr[i] ≤ 1000
1 ≤ k ≤ 1000
arr is sorted in strictly increasing order

Visualization

Tap to expand

Understanding the Visualization

Identify Reserved Seats

The array represents VIP-reserved seats [2,3,4,7,11]

Count Available Seats

For each reserved seat, calculate how many regular seats are available before it

Binary Search

Use binary search to quickly find which section contains the kth available seat

Calculate Final Seat

Once we know the section, calculate the exact seat number

Key Takeaway

🎯 Key Insight: By calculating how many seats are missing before each VIP reservation, we can use binary search to jump directly to the section containing our answer, achieving O(log n) time complexity!

Asked in

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

The optimal solution uses binary search to find the kth missing positive number in O(log n) time. The key insight is that for any element arr[i], exactly arr[i] - i - 1 positive integers are missing before it. We binary search to find the position where we need to insert the kth missing number.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n*k)	O(1)	Check each positive integer sequentially until we find k missing ones
Binary Search (Optimal)	O(log n)	O(1)	Use binary search to find the position where the kth missing number should be

Brute Force (Linear Search) — Algorithm Steps

Initialize missing count to 0 and current number to 1
For each positive integer starting from 1:
Check if current number exists in the array
If not found, increment missing count
If missing count equals k, return current number
Otherwise, increment current number and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with missing_count=0, current=1

Check Numbers

For each number, check if it's in the array

Count Missing

If not found, increment missing count

Found Result

When missing_count reaches k, return current number

Code -

solution.c — C

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

int findKthPositive(int* arr, int arrSize, int k) {
    int missingCount = 0;
    int current = 1;
    int arrIndex = 0;
    
    while (missingCount < k) {
        // If current number is in array, skip it
        if (arrIndex < arrSize && arr[arrIndex] == current) {
            arrIndex++;
        } else {
            // Current number is missing
            missingCount++;
            if (missingCount == k) {
                return current;
            }
        }
        current++;
    }
    
    return current - 1;
}

int main() {
    int arr[1000];
    int size = 0;
    int k;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        k = atoi(token);
        if (size > 0) {
            arr[size-1] = arr[size-1] ? arr[size-1] : k;
            arr[size] = k;
        } else {
            arr[0] = k;
        }
        size++;
        token = strtok(NULL, " ");
    }
    size--;
    
    printf("%d\n", findKthPositive(arr, size, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

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

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting

✓ Linear Space

62.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler