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

Question

我对这个算法有疑问-我必须在列表中找到对：

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

等于12 。 问题是，在配对之后，这些数字（元素）不能再次使用。

现在，我有你可以在下面找到的代码。 我尝试在匹配后从列表中删除数字，但我觉得在此之后索引存在问题。

它看起来很容易，但仍然无法正常工作。 ;/

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()

更新：

谢谢你们的快速回答！

我已经尝试了您的解决方案，不幸的是，它仍然不是我想要的。 我知道预期的 output 应该是这样的：[4, 8], [0, 12], [1, 11], [4, 8], [12, 0]。 因此，在您的第一个解决方案中，重复元素仍然存在问题，而在第二个解决方案中，缺少 [4, 8] 和 [12, 0]。 很抱歉一开始没有给 output。

Answer 1

对于这个问题，您需要跟踪已经尝试过的数字。 Python 有一个计数器class 将保存给定列表中存在的每个元素的计数。

我会使用的算法是：

• 在列表中创建元素计数器
• 迭代列表
  • 对于每个元素，检查 (target - element) 是否存在于计数器中，并且该项目的计数 > 0
    • 减少元素的计数和（目标 - 元素）

---

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]]

演示

Answer 2

要修复您的代码 - 几句话：

1. 如果您在for循环中迭代数组，则不应更改它 - 如果您想修改底层列表，请使用while循环（您可以重写此解决方案以使用while循环）

2. 因为您只迭代外循环中的元素一次 - 您只需要确保您“弹出”内循环中的元素。

所以代码：

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

简短的

如果您了解哈希图和链表/双端队列，您可以考虑使用辅助空间将 map 值添加到它们的索引中。

临：

• 它确实使时间复杂度线性化。
• 不修改输入

缺点：

• 使用额外空间
• 使用与原始策略不同的策略。 如果这是针对 class 并且您还没有了解应用的数据结构，请不要使用它。

代码

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]