如何确定数字组合是否在另一个数字组合中？

Question

Is there a way to find out if a combination of numbers (stored in a list) are in a longer combination of numbers (stored in a separate list)?

Eg

mylist = [(1, 4, 7), (3, 6, 9)]

serieslist = list(itertools.combinations((range(1, 50)), 5))
>> [(1, 2, 3, 4, 5), (1, 2, 3, 4, 6), (1, 2, 3, 4, 7)...etc...]

In the example above, I would want to return that the combination of numbers (1, 4, 7) is in the combination of numbers (1, 2, 3, 4, 7) .

Specifically though, I don't want to split (1, 2, 3, 4, 7) into further combinations of three.

Ideally, I'd like to write this into a for statement to compare each element of mylist to each element of serieslist .

Answer 1

Use sets to see if a your tuple is part of the larger tuple:

if set(short_tuple).issubset(longer_tuple):
    # all elements of short_tuple are in longer_tuple

You want to turn short_tuple into a set once :

for short_tuple in mylist:
    short_tuple_set = set(short_tuple)

    for combo in itertools.combinations((range(1, 50)), 5):
        if short_tuple_set.issubset(combo):
            # matched!

It'd be more efficient to generate all combinations that are guaranteed to be matches though:

for short_tuple in mylist:
    short_tuple_set = set(short_tuple)

    remainder = (i for i in range(1, 50) if i not in short_tuple_set)
    for combo in itertools.combinations(remainder, 5 - len(short_tuple)):
        combo = sorted(combo + short_tuple)

Each combo is a valid combination of 5 numbers between 1 and 49 inclusive that have all 3 numbers of the short_tuple in them, without having to create all possible combinations.

If you create these as generator functions, you can verify that they produce the same output (apart from tuples versus lists; sorted() returns a list):

>>> def set_test(mylist):
...     for short_tuple in mylist:
...         short_tuple_set = set(short_tuple)
...         for combo in itertools.combinations((range(1, 50)), 5):
...             if short_tuple_set.issubset(combo):
...                 yield combo
... 
>>> def create_combos(mylist):
...     for short_tuple in mylist:
...         short_tuple_set = set(short_tuple)
...         remainder = (i for i in range(1, 50) if i not in short_tuple_set)
...         for combo in itertools.combinations(remainder, 5 - len(short_tuple)):
...             combo = sorted(combo + short_tuple)
...             yield combo
... 
>>> all(a == tuple(b) for a, b in itertools.izip_longest(set_test(mylist), create_combos(mylist)))
True

but the second method is so much faster:

>>> timeit('list(f(mylist))', 'from __main__ import set_test as f, mylist', number=10)
14.483195066452026
>>> timeit('list(f(mylist))', 'from __main__ import create_combos as f, mylist', number=10)
0.019912004470825195

Yes, that is nearly 1000 times faster.

Answer 2

If all your sequences only contain unique numbers (no duplicates):

a = (1,4,7)
b = (1,2,3,4,7)
a_in_b = all(x in b for x in a)