Beste art um Kombinationen zu programmieren?

I still don’t know what you want.

You obviously have a lot of D={ D_1, D_2, …} of files that can each be seen as a lot of D_i of lines. You know the amount Z of all possible lines. And now you’re looking for groups of 15 files whose association not Z is. You need:

• any such group?
• all possible groups? That could be a lot!
• a breakdown of all files into such groups? Then, however, there is always a remainder because 100 is not divisible by 15.

I would process such amounts of data in Python and manage for each line a set of files that contain this line. These quantities can be efficiently reproduced as integers, each bit corresponding to a file:

from os import listdir

# lineinfo: line --> files (as Bit-Set)
lineinfo = { (line, 0) for line in open("all.txt") }

index = 1 # 2, 4, 8, ... 2^n
datainfo = {} # index --> filename
for data in listdir("input"):
    datainfo[index] = data
    for line in open(data):
        lineinfo[line] |= index # total count
    index *= 2

If after that any row occurs in at most 85 (=100-15) files, any 15 files from the rest are a possible solution. Otherwise (if all lines occur at least 86 times) there is no solution:

for line, lineset in lineinfo.items():
    int count = 0
    int idx = 1
    while idx= 15:
        int idx = 1
        while idx

A bit more difficult it becomes to enumerate all possible groups. Actually, each group of 15 files (as above) counts for each line. However, groups are counted several times if two or more lines are missing in their association. It is certainly not practical to remember all already calculated groups in order to avoid doublettes, because they are much too many.

In principle, you can ignore all rows that occur in 86 or more files (because they occur in each group), and then sort out the files that are in the cut of the other rows. This is likely to greatly reduce the amount of data.

However, how to proceed exactly depends on whether you want to distinguish two different file groups with the same amount of association:

• If not, you can find iterative for any interesting line z_i all the solutions that z_i not and then only consider solutions containing z_1 to z_i. That should be really hard.
• If you don't, you'd have to do something to don't have to iterate over all kinds of 15-some groups...