Python - Nth smallest Greater than K

The task of finding the Nth smallest element greater than K is a common problem in data analysis. Python provides several efficient approaches using filtering and sorting techniques to solve this challenge.

Understanding the Problem

We need to find the Nth smallest number that is greater than a given value K from a list. For example, if we have numbers [2, 6, 4, 7, 8, 10, 15, 9], K=5, and N=3, we first filter numbers greater than 5: [6, 7, 8, 10, 15, 9], then sort them: [6, 7, 8, 9, 10, 15], and return the 3rd element: 8.

Using List Comprehension and Sorting

This approach filters elements greater than K using list comprehension, sorts them, and returns the Nth element ?

def get_nth_smallest_greater(numbers, k, n):
    # Filter numbers greater than k
    filtered_nums = [num for num in numbers if num > k]
    
    # Sort the filtered numbers
    sorted_nums = sorted(filtered_nums)
    
    # Check if we have enough elements
    if len(sorted_nums) < n:
        return None
    
    # Return the nth smallest (index n-1)
    return sorted_nums[n-1]

# Example usage
numbers = [2, 6, 4, 7, 8, 10, 15, 9]
k = 5
n = 3

result = get_nth_smallest_greater(numbers, k, n)
print(f"The {n}rd smallest number greater than {k} is: {result}")

The 3rd smallest number greater than 5 is: 8

Using filter() with Lambda Function

This approach uses Python's built-in filter() function with a lambda expression for a more functional programming style ?

def get_nth_smallest_functional(numbers, k, n):
    # Filter using lambda function
    filtered_nums = list(filter(lambda x: x > k, numbers))
    
    # Sort and check bounds
    filtered_nums.sort()
    
    if len(filtered_nums) < n:
        return None
        
    return filtered_nums[n-1]

# Example usage
numbers = [2, 6, 4, 7, 8, 10, 15, 9]
k = 7
n = 2

result = get_nth_smallest_functional(numbers, k, n)
print(f"The {n}nd smallest number greater than {k} is: {result}")

The 2nd smallest number greater than 7 is: 9

Handling Edge Cases

It's important to handle cases where there aren't enough elements greater than K ?

def get_nth_smallest_safe(numbers, k, n):
    filtered_nums = [num for num in numbers if num > k]
    
    if not filtered_nums:
        return f"No numbers greater than {k} found"
    
    if len(filtered_nums) < n:
        return f"Only {len(filtered_nums)} numbers greater than {k}, cannot find {n}th smallest"
    
    sorted_nums = sorted(filtered_nums)
    return sorted_nums[n-1]

# Test edge cases
numbers = [1, 2, 3]
print(get_nth_smallest_safe(numbers, 10, 2))  # No numbers > 10
print(get_nth_smallest_safe(numbers, 1, 5))   # Not enough numbers

No numbers greater than 10 found
Only 2 numbers greater than 1, cannot find 5th smallest

Comparison

Where n is the total number of elements and m is the number of elements greater than K

Conclusion

Both approaches have O(n log n) time complexity due to sorting. List comprehension offers better readability, while filter() provides a functional programming style. Always handle edge cases when there aren't enough qualifying elements.