Wie findet man Listenschnittpunkte?

Question

a = [1,2,3,4,5]
b = [1,3,5,6]
c = a and b
print c

tatsächliche Leistung: [1,3,5,6] erwartete Ausgabe: [1,3,5]

Wie kann man eine boolesche UND-Verknüpfung (Listenschnittmenge) zweier Listen erreichen?

Answer 1

Dies ist ein Beispiel, wenn Sie benötigen Jedes Element im Ergebnis sollte so oft erscheinen, wie es in beiden Arrays vorkommt.

def intersection(nums1, nums2):
    #example:
    #nums1 = [1,2,2,1]
    #nums2 = [2,2]
    #output = [2,2]
    #find first 2 and remove from target, continue iterating

    target, iterate = [nums1, nums2] if len(nums2) >= len(nums1) else [nums2, nums1] #iterate will look into target

    if len(target) == 0:
            return []

    i = 0
    store = []
    while i < len(iterate):

         element = iterate[i]

         if element in target:
               store.append(element)
               target.remove(element)

         i += 1

    return store

Answer 2

Es mag spät sein, aber ich dachte nur, ich sollte es für den Fall mitteilen, dass Sie es manuell machen müssen (zeigen, dass es funktioniert - haha) ODER wenn Sie alle Elemente so oft wie möglich brauchen oder wenn Sie auch brauchen, dass es einzigartig ist.

Bitte beachten Sie, dass auch dafür Tests geschrieben worden sind.

    from nose.tools import assert_equal

    '''
    Given two lists, print out the list of overlapping elements
    '''

    def overlap(l_a, l_b):
        '''
        compare the two lists l_a and l_b and return the overlapping
        elements (intersecting) between the two
        '''

        #edge case is when they are the same lists
        if l_a == l_b:
            return [] #no overlapping elements

        output = []

        if len(l_a) == len(l_b):
            for i in range(l_a): #same length so either one applies
                if l_a[i] in l_b:
                    output.append(l_a[i])

            #found all by now
            #return output #if repetition does not matter
            return list(set(output))

        else:
            #find the smallest and largest lists and go with that
            sm = l_a if len(l_a)  len(l_b) else l_b

            for i in range(len(sm)):
                if sm[i] in lg:
                    output.append(sm[i])

            #return output #if repetition does not matter
            return list(set(output))

    ## Test the Above Implementation

    a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
    exp = [1, 2, 3, 5, 8, 13]

    c = [4, 4, 5, 6]
    d = [5, 7, 4, 8 ,6 ] #assuming it is not ordered
    exp2 = [4, 5, 6]

    class TestOverlap(object):

        def test(self, sol):
            t = sol(a, b)
            assert_equal(t, exp)
            print('Comparing the two lists produces')
            print(t)

            t = sol(c, d)
            assert_equal(t, exp2)
            print('Comparing the two lists produces')
            print(t)

            print('All Tests Passed!!')

    t = TestOverlap()
    t.test(overlap)

Answer 3

Die meisten Lösungen hier berücksichtigen nicht die Reihenfolge der Elemente in der Liste und behandeln Listen wie Mengen. Wenn Sie hingegen eine der längsten Teilfolgen finden wollen, die in beiden Listen enthalten sind, können Sie den folgenden Code ausprobieren.

def intersect(a, b):
    if a == [] or b == []: 
        return []
    inter_1 = intersect(a[1:], b)
    if a[0] in b:
        idx = b.index(a[0])
        inter_2 = [a[0]] + intersect(a[1:], b[idx+1:])        
        if len(inter_1) <= len(inter_2):
            return inter_2
    return inter_1

Para a=[1,2,3] y b=[3,1,4,2] dies ergibt [1,2] statt [1,2,3] . Beachten Sie, dass eine solche Teilfolge nicht eindeutig ist, da [1] , [2] , [3] sind alle Lösungen für a=[1,2,3] y b=[3,2,1] .

Answer 4

Wenn Sie mit Booleschem UND Elemente meinen, die in beiden Listen vorkommen, z. B. Schnittmengen, dann sollten Sie sich Pythons set y frozenset Typen.

Answer 5

Sie können auch einen Zähler verwenden! Dabei wird die Reihenfolge nicht beibehalten, aber es werden die Duplikate berücksichtigt:

>>> from collections import Counter
>>> a = [1,2,3,4,5]
>>> b = [1,3,5,6]
>>> d1, d2 = Counter(a), Counter(b)
>>> c = [n for n in d1.keys() & d2.keys() for _ in range(min(d1[n], d2[n]))]
>>> print(c)
[1,3,5]