从一组2元组生成3元组

Question

In an earlier question:

Generating maximum number of 3-tuples from a list of 2-tuples

I got an answer from @AChampion that seems to work if the number of 2-tuples is divisible by 3. However, the solution fails if we, for example, have 10 2-tuples. After fumbling with it for a while I'm under the impression that it is impossible to find a perfect solution for say:

(1,2)(1,3),(1,4),(2,3),(2,4),(3,4)

So I'm interested in finding one solution that minimizes the number of remainder tuples. In the example above the result could be:

(1,2,3)           # derived from (1,2), (1,3), (2,3)
(1,4),(2,4),(3,4) # remainder tuples 

The rule for generating 3-tuple from 3 2-tuple is:

(a,b), (b,c), (c,a) -> (a, b, c)

ie the 2-tuples is a cycle with length 3. The order of the elements in a 3-tuple is not important, ie:

(a,b,c) == (c,a,b)

I'm actually interested in the case where we have a number n:

for x in range(1,n+1):
    for y in range(1,n+1):
        if x!=y:
            a.append((x,y))

# a = [ (1,2),...,(1,n), (2,1),(2,3),...,(2,n),...(n,1),...,(n,n-1) ]

From a, minimize the number of 2-tuples that is left when producing 3-tuples. Each 2-tuple can only be used once.

I wrapped my brain around this for several hours but I can't seem to come up with an elegant solution (well, neither have I found an ugly one:-) for the general case. Any thoughts?

Answer 1

For this you need to create number of combinations that will use for replacement. Then loop over you data for 3 item that contains any of above combinations and replace them. I have done thi in several steps.

from itertools import combinations

# create replacements elements
number_combinations_raw = list(combinations(range(1, 5), 3))

# create proper number combinations
number_combinations = []
for item in number_combinations_raw:
    if (item[0] + 1 == item[1]) and (item[1] + 1 == item[2]):
        number_combinations.append(item)

# create test data
data = [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4)]

# reduce data
reduce_data = []
for number_set in number_combinations:
    count = 0
    merged_data = []
    for item in data:
        if (number_set[0] in item and number_set[1] in item) or (number_set[1] in item and number_set[2] in item) \
            or (number_set[0] in item and number_set[2] in item):
            merged_data.append(item)
            count += 1
    if count == 3:
        reduce_data.append((number_set, merged_data))

# delete merged elements from data list and add replacement
for item in data:
    for reduce_item in reduce_data:
        for element in reduce_item[1]:
            if element in data:
                data.remove(element)

        data = [reduce_item[0]] + data

# remove duplicated replaced elements
final_list = list(dict.fromkeys(data))

Output:

[(1, 2, 3), (1, 4), (2, 4)]