重复列表中的有序对

Question

I have a list which may or may not have repeating elements, i wish to create ordered pairs such that in an element x is repeated the x,x is a valid pair other wise all x,y when x

so far i have found a very non - pythonic way of doing this

def foo(a):
    n = list()
    for x in range(len(a)):
        for y in range(x+1,len(a)):
            if a[x] < a[y]:
                n.append([a[x],a[y]])
            else:
                n.append([a[y],a[x]])
    o = list()
    for p in n:
        if not (p in o):
            o.append(p)
    return o

print(foo([1,3,5,-1]))
# [[1, 3], [1, 5], [-1, 1], [3, 5], [-1, 3], [-1, 5]]

print(foo([1,1,5,5]))
# [[1, 1], [1, 5], [5, 5]]

print(foo([1,1,1,1]))
# [[1, 1]]

i am aware i can use list comprehension but the solution i tried either skips the x,x type when repeats are present or and phantom x,x which should not be present

a = [1,3,5,-1]
o = [[x,y] for x in a for y in a if x<=y]
print(o)
[[1, 1], [1, 3], [1, 5], [3, 3], [3, 5], [5, 5], [-1, 1], [-1, 3], [-1, 5], [-1, -1]]

what will be the appropriate pythonic solution for readability.

Additionally what will the be most efficient solution time wise (memory is not a constraint) in case the pythonic solution is not the most efficient

Answer 1

If you're happy using itertools, you can use itertools.combinations :

from itertools import combinations

a = [1, 3, 5, -1]
o = sorted(set(combinations(sorted(a), 2)))

>>> [(-1, 1), (-1, 3), (-1, 5), (1, 3), (1, 5), (3, 5)]

a = [1, 1, 5, 5]
o = sorted(set(combinations(sorted(a), 2)))

>>> [(1, 1), (1, 5), (5, 5)]

The inner call to sorted ensures that each pair will be ordered, which I understand was your intention. The outer call to sorted ensures that the pairs are ordered. If this is not necessary, you can replace this sorted with simply list .

Answer 2

Have you tried using itertools.combinations()

Something like this

import itertools
iterable = [1,1,5,5]
r=2
comb = sorted(set(itertools.combinations(sorted(iterable), r)))
for el in comb:
  print(el)

Answer 3

If you're not happy with itertools , you can use a list comprehension.

>>> xs = [1,3,5,-1]

If you zip xs with all sublists of itself, starting at index 1, 2, ..., len(xs)-1, you get all the combinations:

>>> [list(zip(xs,xs[n:])) for n in range(1,len(xs))]
[[(1, 3), (3, 5), (5, -1)], [(1, 5), (3, -1)], [(1, -1)]]

(Note that I wrapped here zip in a list for a nicer output.) Now, you have to flatten the list of tuples. This is just a list comprehension with every tuple of every list of tuples yielded by zip :

>>> [t for ys in [zip(xs,xs[n:]) for n in range(1,len(xs))] for t in ys]
[(1, 3), (3, 5), (5, -1), (1, 5), (3, -1), (1, -1)]

You want sorted tuples: this is tuple(sorted(t)) because sorted returns a list. Put everything in a set to remove the duplicates.

>>> set(tuple(sorted(t)) for ys in [zip(xs,xs[n:]) for n in range(1,len(xs))] for t in ys)
{(-1, 1), (1, 3), (-1, 3), (1, 5), (-1, 5), (3, 5)}

(You may also, as thesilkworm did, sort the list before you output the tuples.) Other test cases:

>>> xs = [1,1,1,1]
>>> set(tuple(sorted(t)) for ys in [zip(xs,xs[n:]) for n in range(1,len(xs))] for t in ys)
{(1, 1)}
>>> xs = [1,1,5,5]
>>> set(tuple(sorted(t)) for ys in [zip(xs,xs[n:]) for n in range(1,len(xs))] for t in ys)
{(1, 5), (5, 5), (1, 1)}

Advice: you should use itertools ...