Find Missing Observations - Leetcode Solution

Problem Statement:

You are given an integer array, nums, of length n that contains all distinct values from 1 to n + k inclusive, where k is a positive integer. You are also given an integer array, queries, of length m.

The ith query asks for the number of elements in nums that are less than or equal to queries[i].

Return an integer array answer, where answer[j] is the answer to the jth query.

It is guaranteed that each query requires exactly one traversal through nums.

Solution:

We can approach this problem by using binary search. First, we need to sort nums in ascending order. Then, for each query, we can perform a binary search to find the index of the largest element in nums that is less than or equal to the query. The answer to the query would be the index + 1.

However, we need to take into account the missing observations in nums. Since nums contains all distinct values from 1 to n + k inclusive, we can calculate the total sum of this range as:

sum = (n + k) * (n + k + 1) / 2

We can then iterate through nums and subtract each element from the total sum. The result would be the sum of the missing numbers.

We can then modify the binary search algorithm to take into account the missing numbers. Instead of searching for the index of the largest element in nums that is less than or equal to the query, we search for the index of the largest element in nums and the missing numbers that is less than or equal to the query. If the search reaches the end of nums and the missing numbers, we return the length of nums + the number of missing numbers, which is the index of the largest element that is less than or equal to the query.

Here is the Python code:

def findMissingObservations(nums, queries): nums.sort() n = len(nums) k = queries[-1] - n totalSum = (n + k) * (n + k + 1) / 2 missingSum = sum(nums[i] - i - 1 for i in range(n)) missingNumbers = totalSum - sum(nums) + missingSum

def binarySearch(target):
    left = 0
    right = n + missingNumbers
    while left < right:
        mid = (left + right + 1) // 2
        num = mid if mid <= n else mid + missingNumbers
        if nums[num - 1] <= target:
            left = mid
        else:
            right = mid - 1
    return left + 1

return [binarySearch(query) for query in queries]

Time Complexity:

The time complexity of sorting nums is O(nlogn). The time complexity of calculating the total sum and the missing sum is O(n). The time complexity of the binary search algorithm is O(mlogn), where m is the length of queries. Therefore, the overall time complexity is O(nlogn + mlogn) = O((n + m)logn).

Space Complexity:

The space complexity of the algorithm is O(n), where n is the length of nums, since we need to store the sorted nums and the missing numbers.

1