Question

我有这样的字典（多维？）：

d = { 0: [3, 5], 1: [5, 7], 2: [4, 7], 3: [4, 3] }

我想在字典列表中找到任何重复的匹配位置（0）或（1）值，如果有重复，则反转第二对匹配的数字。

字典将变为：

{ 0: [3, 5], 1: [5, 7], 2: [7, 4], 3: [4, 3] }

只有位置（0）可以与位置（0）重复，并且只有位置（1）可以与位置（1）重复。序列中只能有一个重复项，并且在重复数据删除/翻转过程之后，所有数字都应链接在一起。下面说明：

[0 , 1] [1 , 2] [2 , 3] [3 , 0]

我正在尝试将所有相邻位置（1）与位置（0）匹配，因此这些值基本上是完整的圆（将其视为一系列从一端连接到另一端的线）。我愿意使用诸如numpy等之类的方法，这些方法可能有助于有效解决此问题。这是另一个示例：

{ 'foo': [2, 9], 'bar': [3, 2], 'baz': [3, 9] }

哪个应该结束：

[2, 9], [9, 3], [3, 2]

我尝试了很多类似的事情：

l = list(sorted(d.values()))

for i in range(0, len(l)):
    # now what the heck?

Answer 1

这样的一组成对的链具有以下属性：每个元素在一对的第一个位置恰好出现一次，在第二个位置一次出现。如果您知道对中确实有一个反转，则可以利用此属性：反转对中的第一个元素在第一个位置出现两次，而第二个元素在第一个位置根本不出现。

这里是一个主意：逐对检查对，并按其第一个元素跟踪每个对。当我们看到具有相同第一个元素的第二对时，这两个对中的一个必须是反向的-称这些候选。当我们将一个候选的 second 元素视为另一对的第一个元素时，我们知道该候选不是反向的，因此我们将另一个反向。

此解决方案可以就地工作，这可能是优势，也可能不是优势。转换为返回已更正列表的列表很容易。它还具有的优点是，在最坏的情况下，它仅会通过配对对一次。在大多数情况下，它可以在结束前停止。在我的测试中，它比recnac中的解决方案快了七倍。

def fix_chain(pair_dict):
    first_to_pair = dict()
    this, that = None, None # candidates
    for pair in pair_dict.values():
        if pair[0] in first_to_pair: # found the collision
            this = pair
            that = first_to_pair[pair[0]]
        else:
            first_to_pair[pair[0]] = pair
        if this and this[1] in first_to_pair: # this is not reversed...
            that.reverse() # ... so that must be
            return
        if that and that[1] in first_to_pair: # that is not reversed...
            this.reverse() # ... so this must be
            return

Answer 2

如果您完全不关心键，并确保对值会成一个完整的圆圈。我认为您可以尝试以下方法：

按dict（增强查询性能）存储每个数字的两个邻居，然后从任意数字开始，然后穿过圆环链，直到再次到达自身为止。

def reverse_pairs(input_dict):
    pair_values = list(input_dict.values())
    neighbors = defaultdict(list)

    for num1, num2 in pair_values:
        neighbors[num1].append(num2)
        neighbors[num2].append(num1)

    res = [pair_values[0]]
    while res[0][0] != res[-1][1]:
        a1, b1 = res[-1]
        a2, b2 = neighbors[b1]
        res.append([b1, a2 if a1 != a2 else b2])

    return res

测试案例：

def test():
    dict1 = {0: [3, 5], 1: [5, 7], 2: [7, 4], 3: [4, 3]}
    print(reverse_pairs(dict1))

    dict2 = {'foo': [2, 9], 'bar': [3, 2], 'baz': [3, 9]}
    print(reverse_pairs(dict2))

输出：

[[3, 5], [5, 7], [7, 4], [4, 3]]
[[2, 9], [9, 3], [3, 2]]

希望对您有所帮助，如有其他问题，请发表评论。：）

如何反转多维数组中的重复值

2 个答案: