Python - Find Minimum Pair Sum in list

The Minimum pair sum is defined by finding the smallest possible sum of two numbers taken from a given list. This concept is useful in optimization problems where you need to minimize costs, distances, or time for operations. Python provides several approaches to solve this using built-in functions like sort(), combinations(), and float().

Using Nested for Loop

This approach uses nested loops to iterate through all possible pairs and track the minimum sum ?

def min_pair(nums):
    min_sum = float('inf')
    min_pair = ()
    
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            pair_sum = nums[i] + nums[j]
            if pair_sum < min_sum:
                min_sum = pair_sum
                min_pair = (nums[i], nums[j])
    
    return min_sum, min_pair

# Create the list
numbers = [40, 21, 91, 50, 11]
result_sum, result_pair = min_pair(numbers)
print("Minimum pair sum:", result_sum)
print("Pair:", result_pair)

Minimum pair sum: 32
Pair: (21, 11)

Using Sorting (Most Efficient)

The most efficient approach is to sort the list first. The minimum pair sum will always be the sum of the two smallest elements ?

def min_pair_sorted(nums):
    nums_copy = nums.copy()  # Avoid modifying original list
    nums_copy.sort()
    min_sum = nums_copy[0] + nums_copy[1]
    min_pair = (nums_copy[0], nums_copy[1])
    return min_sum, min_pair

# Create the list  
numbers = [11, 10, 9, 5, 1]
result_sum, result_pair = min_pair_sorted(numbers)
print("Minimum pair sum:", result_sum)
print("Pair:", result_pair)

Minimum pair sum: 6
Pair: (1, 5)

Using sum() and sorted()

This method combines sorted() with sum() for a more concise solution ?

def min_pair_sum(nums):
    sorted_nums = sorted(nums)
    min_sum = sum(sorted_nums[:2])
    min_pair = tuple(sorted_nums[:2])
    return min_sum, min_pair

# Create the list
numbers = [10, 11, 12, 13, 14]
result_sum, result_pair = min_pair_sum(numbers)
print("Minimum pair sum:", result_sum)
print("Pair:", result_pair)

Minimum pair sum: 21
Pair: (10, 11)

Using itertools.combinations

This approach uses the combinations() function to generate all possible pairs systematically ?

from itertools import combinations

def find_min_pair_sum(nums):
    pairs = combinations(nums, 2)
    min_sum = float('inf')
    min_pair = ()
    
    for pair in pairs:
        pair_sum = sum(pair)
        if pair_sum < min_sum:
            min_sum = pair_sum
            min_pair = pair
    
    return min_sum, min_pair

# Create the list
numbers = [4, 2, 9, 5, 1]
result_sum, result_pair = find_min_pair_sum(numbers)
print("Minimum pair sum:", result_sum)
print("Pair:", result_pair)

Minimum pair sum: 3
Pair: (2, 1)

Performance Comparison

Conclusion

The sorting approach is the most efficient with O(n log n) time complexity. Use nested loops for small lists or when you need to understand the basic algorithm. The itertools.combinations method is useful when you need to examine all pairs systematically.