Return tuple of any two items in list, which if summed equal given int

Question

For example, assume a given list of ints:

int_list = list(range(-10,10))
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

What is the most efficient way to find if any given two values in int_list sum to equal a given int, say 2?

I was asked this in a technical phone interview this morning on how to efficiently handle this scenario with an int_list of say, 100 million items (I rambled and had no good answer :/).

My first idea was:

from itertools import combinations
int_list = list(range(-10,10))
combo_list = list(combinations(int_list, 2))
desired_int = 4
filtered_tuples = list(filter(lambda x: sum(x) == desired_int, combo_list))
filtered_tuples
[(-5, 9), (-4, 8), (-3, 7), (-2, 6), (-1, 5), (0, 4), (1, 3)]

Which doesn't even work with a range of only range(-10000, 10000)

Also, does anyone know of a good online Python performance testing tool?

Answer 1

For any integer A there is at most one integer B that will sum together to equal integer N. It seems easier to go through the list, do the arithmetic, and do a membership test to see if B is in the set.

int_list = set(range(-500000, 500000))
TARGET_NUM = 2

def filter_tuples(int_list, target):
    for int_ in int_list:
        other_num = target - int_
        if other_num in int_list:
            yield (int_, other_num)

filtered_tuples = filter_tuples(int_list, TARGET_NUM)

Note that this will duplicate results. E.g. (-2, 4) is a separate response from (4, -2). You can fix this by changing your function:

def filter_tuples(int_list, target):
    for int_ in int_list:
        other_num = target - int_
        if other_num in int_list:
            set.remove(int_)
            set.remove(other_num)
            yield (int_, other_num)

Answer 2

EDIT: See my other answer for an even better approach (with caveats).

What is the most efficient way to find if any given two values in int_list sum to equal a given int, say 2?

My first inclination was to do it with the itertools module's combinations and the short-cutting power of any, but it could be quite slower than Adam's approach:

>>> import itertools
>>> int_list = list(range(-10,10))
>>> any(i + j == 2 for i, j in itertools.combinations(int_list, 2))
True

Seems to be fairly responsive for larger ranges:

>>> any(i + j == 2 for i, j in itertools.combinations(xrange(-10000,10000), 2))
True
>>> any(i + j == 2 for i, j in itertools.combinations(xrange(-1000000,1000000), 2))
True

Takes about 10 seconds on my machine:

>>> any(i + j == 2 for i, j in itertools.combinations(xrange(-10000000,10000000), 2))
True

Answer 3

A more literal approach using math:

Assume a given list of ints:

int_list = list(range(-10,10)) ... [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

What is the most efficient way to find if any given two values in int_list sum to equal a given int, say 2? ... how to efficiently handle this scenario with an int_list of say, 100 million items.

It's clear that we can deduce the requirements that we can apply a single parameter, n, for the range of integers, of the form range(-n, n), which means every integer from negative n up to but not including positive n. From there the requirements are clearly to whether some number, x, is a sum of any two integers in that range.

Any such range can be trivially shown to contain a pair that sum to any number in that range and n-1 beyond it, so it's a waste of computing power to search for it.

def x_is_sum_of_2_diff_numbers_in_range(x, n):
    if isinstance(x, int) and isinstance(n, int):
        return -(n*2) < x < (n - 1)*2
    else:
        raise ValueError('args x and n must be ints')

Computes nearly instantly:

>>> x_is_sum_of_2_diff_numbers_in_range(2, 1000000000000000000000000000)
True

Testing the edge-cases:

def main():
    print x_is_sum_of_2_diff_numbers_in_range(x=5, n=4) # True
    print x_is_sum_of_2_diff_numbers_in_range(x=6, n=4) # False
    print x_is_sum_of_2_diff_numbers_in_range(x=-7, n=4) # True
    print x_is_sum_of_2_diff_numbers_in_range(x=-8, n=4) # False

EDIT:

Since I can see that a more generalized version of this problem (where the list could contain any given numbers) is a common one, I can see why some people have a preconceived approach to this, but I still stand by my interpretation of this question's requirements, and I consider this answer the best approach for this more specific case.

Answer 4

I would have thought that any solution that depends on a doubly nested iteration over the list (albeit having the inner loop concealed by a nifty Python function) is O(n^2).

It is worth considering sorting the input. For any reasonable comparison-based sort, this will be O(n.lg(n)), which is already better than O(n^2). You might do better with a radix sort or pre-sort (making something like a bucket sort) depending on the range of the input list.

Having sorted the input, it is an O(n) operation to find a pair of numbers that sum to any given number, so your overall complexity is O(n.lg(n)).

In practice, it's an open question whether, for the stipulated “large number” of elements, a brute-force O(n^2) algorithm with nice cache behavior (zipping through arrays in order) would outperform the asymptotically better algorithm that moves a lot of data around, but eventually the one with the lower asymptotic complexity will win.