Kth Missing Positive Number
The problem requires us to find the kth
missing positive integer from a given strictly increasing array.
The simplest way to solve this problem is to use a counter to track the current number and a second counter to track how many missing numbers we’ve found. We’ll increment the first counter from 1 upwards and check if the current number exists in the given array. If not, we increment the second counter. When the second counter equals k
, we return the current number.
This can be implemented in Python as follows:


This solution works by iterating over the positive integers, checking for each one whether it is in the array, and counting the ones that are not until it has found k
missing numbers. It has a time complexity of O(n) where n is the maximum value in the array or the value of k
, whichever is larger.
Please note that in a largescale scenario, this approach might not be the most efficient, as the operation num_counter not in arr
itself is an O(n) operation, resulting in an overall complexity of O(n^2). A more efficient solution could involve binary search or other techniques.
The termination condition is either reaching the end of the array or we have reached the value of k. Is this correct?
Yes, that’s correct. The process continues until one of two conditions is met:
The number of missing integers found (
missing_counter
) is equal tok
. This means that we have found thekth
missing positive integer, so we can stop and return the current number (num_counter
).If you iterate over the array instead of positive integers, the process would continue until you reach the end of the array. In this case, if you haven’t found the
kth
missing positive integer within the array, you would have to continue checking the numbers beyond the array untilmissing_counter
is equal tok
.
In the provided solution, we use the first termination condition. We iterate over positive integers starting from 1, not over the elements of the array. The loop ends when we find k
missing positive integers, whether these are in the array or beyond it.
What are the basic building blocks of the solution?
The basic building blocks of the solution are:
Iteration: A loop to iterate over the integers starting from 1.
Checking for Membership : A test to check if the current integer is in the provided array.
Counter Manipulation: Two counters  one for the current number (incremented at each step of the iteration) and one for the count of missing numbers (incremented each time the current number is found to be missing from the array).
Conditional Termination: A check to end the loop when the count of missing numbers reaches
k
. This condition is the driving force for terminating the iteration and returning the result.
These building blocks come together to form a procedure that systematically checks each positive integer in order, determining if it’s in the array and if it contributes to the count of missing numbers, until the kth
missing number is found.
What is the invariant ?
The invariant in this problem is the relationship between num_counter
and missing_counter
. At any point during the iteration, missing_counter
equals the number of positive integers between 1 and num_counter
(inclusive) that are not present in the array.
This property remains constant throughout the loop, making it the invariant. It’s what allows the algorithm to correctly identify the kth
missing positive integer.
To put it simply, if you’ve iterated up to num_counter = x
, then missing_counter
will tell you how many positive integers less than or equal to x
are missing from the array.
What is the loop invariant?
The loop invariant in this case would be the condition that at any given point in the loop, missing_counter
represents the count of positive integers that are missing from the array in the range from 1 to num_counter
.
This condition is the invariant because:
Initialization: Before the loop starts,
missing_counter
is 0 andnum_counter
is 0, which correctly signifies that no positive integers in the range [1, 0] are missing from the array.Maintenance: During each iteration,
num_counter
is incremented, and ifnum_counter
is not found in the array,missing_counter
is also incremented. This maintains the condition thatmissing_counter
equals the count of missing integers in the range [1,num_counter
].Termination: When the loop terminates,
missing_counter
equalsk
, meaning thatk
positive integers are missing in the range [1,num_counter
]. Thus,num_counter
is thekth
missing positive integer from the array. This is the desired outcome of the algorithm.
Therefore, the loop invariant holds at all stages of the loop: before the loop starts, during each iteration, and after the loop terminates.
In this context, the terms “invariant” and “loop invariant” are being used to describe the same concept. An invariant is a condition that remains true before, during, and after each iteration of a loop. In other words, it’s something that doesn’t change as your loop executes.
For this problem, the invariant or loop invariant is the relationship between num_counter
and missing_counter
. At any point during the loop, missing_counter
represents the number of positive integers up to num_counter
that are missing from the array. This condition holds true before the loop starts (when both counters are 0), during each iteration of the loop, and after the loop completes (when missing_counter
equals k
).