如何在列表中找到所有等于 N 的对

Question

I have a problem with this algorithm- I have to find pairs in list:

[4, 8, 9, 0, 12, 1, 4, 2, 12, 12, 4, 4, 8, 11, 12, 0]

which are equal to 12 . The thing is that after making a pair those numbers (elements) can not be used again.

For now, I have code which you can find below. I have tried to delete numbers from the list after matching, but I feel that there is an issue with indexing after this.

It looks very easy but still not working. ;/

class Pairs():

    def __init__(self, sum, n, arr ):

        self.sum = sum
        self.n = n
        self.arr = arr

    def find_pairs(self):

        self.n = len(self.arr)

        for i in range(0, self.n):
            for j in range(i+1, self.n):
                if (self.arr[i] + self.arr[j] == self.sum):
                    print("[", self.arr[i], ",", " ", self.arr[j], "]", sep = "")
                    self.arr.pop(i)
                    self.arr.pop(j-1)
                    self.n = len(self.arr)
                    i+=1


def Main():
    sum = 12
    arr = [4, 8, 9, 0, 12, 1, 4, 2, 12, 12, 4, 4, 8, 11, 12, 0]
    n = len(arr)
    obj_Pairs = Pairs(sum, n, arr)
    obj_Pairs.find_pairs()

if __name__ == "__main__":
    Main()

update:

Thank you guys for the fast answers!

I've tried your solutions, and unfortunately, it is still not exactly what I'm looking for. I know that the expected output should look like this: [4, 8], [0, 12], [1, 11], [4, 8], [12, 0]. So in your first solution, there is still an issue with duplicated elements, and in the second one [4, 8] and [12, 0] are missing. Sorry for not giving output at the beginning.

Answer 1

With this problem you need to keep track of what numbers have already been tried. Python has a Counter class that will hold the count of each of the elements present in a given list.

The algorithm I would use is:

• create counter of elements in list
• iterate list
  • for each element, check if (target - element) exists in counter and count of that item > 0
    • decrement count of element and (target - element)

---

from collections import Counter

class Pairs():
    def __init__(self, target, arr):
        self.target = target
        self.arr = arr

    def find_pairs(self):
        count_dict = Counter(self.arr)
        result = []
        for num in self.arr:
            if count_dict[num] > 0:
                difference = self.target - num
                if difference in count_dict and count_dict[difference] > 0:
                    result.append([num, difference])
                    count_dict[num] -= 1
                    count_dict[difference] -= 1
        return result

if __name__ == "__main__":
    arr = [4, 8, 9, 0, 12, 1, 4, 2, 12, 12, 4, 4, 8, 11, 12, 0]
    obj_Pairs = Pairs(12, arr)
    result = obj_Pairs.find_pairs()
    print(result)

Output:

[[4, 8], [8, 4], [0, 12], [12, 0], [1, 11]]

Demo

Answer 2

To fix your code - few remarks:

1. If you iterate over array in for loop you shouldn't be changing it - use while loop if you want to modify the underlying list (you can rewrite this solution to use while loop)

2. Because you're iterating only once the elements in the outer loop - you only need to ensure you "popped" elements in the inner loop.

So the code:

class Pairs():

    def __init__(self, sum, arr ):
        self.sum = sum
        self.arr = arr
        self.n = len(arr)
    
    def find_pairs(self):
        j_pop = []
        for i in range(0, self.n):
            for j in range(i+1, self.n):
                if (self.arr[i] + self.arr[j] == self.sum) and (j not in j_pop):
                    print("[", self.arr[i], ",", " ", self.arr[j], "]", sep = "")
                    j_pop.append(j)
                                    
def Main():
    sum = 12
    arr = [4, 8, 9, 0, 12, 1, 4, 2, 12, 12, 4, 4, 8, 11, 12, 0]
    obj_Pairs = Pairs(sum, arr)
    obj_Pairs.find_pairs()

if __name__ == "__main__":
    Main()

Answer 3

Brief

If you have learned about hashmaps and linked lists/deques, you can consider using auxiliary space to map values to their indices.

Pro:

• It does make the time complexity linear.
• Doesn't modify the input

Cons:

• Uses extra space
• Uses a different strategy from the original. If this is for a class and you haven't learned about the data structures applied then don't use this.

Code

from collections import deque # two-ended linked list

class Pairs():

    def __init__(self, sum, n, arr ):

        self.sum = sum
        self.n = n
        self.arr = arr

    def find_pairs(self):
        mp = {}  # take advantage of a map of values to their indices
        res = [] # resultant pair list
        for idx, elm in enumerate(self.arr):
            if mp.get(elm, None) is None:
                mp[elm] = deque() # index list is actually a two-ended linked list

            mp[elm].append(idx) # insert this element
            comp_elm = self.sum - elm # value that matches
            if mp.get(comp_elm, None) is not None and mp[comp_elm]: # there is no match
                # match left->right
                res.append((comp_elm, elm))
                mp[comp_elm].popleft()
                mp[elm].pop()

        for pair in res: # Display
            print("[", pair[0], ",", " ", pair[1], "]", sep = "")

        # in case you want to do further processing
        return res

def Main():
    sum = 12
    arr = [4, 8, 9, 0, 12, 1, 4, 2, 12, 12, 4, 4, 8, 11, 12, 0]
    n = len(arr)
    obj_Pairs = Pairs(sum, n, arr)
    obj_Pairs.find_pairs()

if __name__ == "__main__":
    Main()

Output

$ python source.py
[4, 8]
[0, 12]
[4, 8]
[1, 11]
[12, 0]