unreasonably effective

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        nums.sort()
        i, j = 0, len(nums)-1
        max_sum = -1
        while i < j:
            s = nums[i] + nums[j]
            if s >= k:
                j -= 1
                continue
            max_sum = max(max_sum, s)
            i += 1
        return max_sum

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        # 1 <= nums[i] <= 1000
        n = 1000
        counts = [0] * (n+1)
        for x in nums:
            counts[x] += 1
        i, j = 1, n-1
        max_sum = -1
        while i < j:
            if counts[i] == 0:
                i += 1
                continue
            
            if counts[j] == 0:
                j -= 1
                continue
            
            if (s := i+j) >= k:
                j -= 1
                continue
            
            max_sum = max( max_sum, s )
            i += 1
        
        if counts[i] > 1 and (s := i+i) < k:
            max_sum = max(max_sum, s)
        return max_sum

class Solution:
    def twoSumLessThanK(self, nums: List[int], k: int) -> int:
        # 1 <= nums[i] <= 1000
        count_map = defaultdict(int)
        for x in nums:
            count_map[x] += 1
        
        sorted_nums = [x for x in sorted(count_map)]
        max_sum = -1
        i, j = 0, len(sorted_nums)-1
        while i < j:
            s = sorted_nums[i] + sorted_nums[j]
            if s >= k:
                j -= 1
                continue
            
            max_sum = max( max_sum, s )
            i += 1

        if count_map[ (x := sorted_nums[i]) ] > 1 and (s := x+x) < k:
            max_sum = max( max_sum, s )

        return max_sum