Как изменить повторяющееся значение в многомерном массиве

Если вы совершенно не заботитесь о ключе и гарантируете, что парные значения сделают полный круг. Я думаю, вы можете попробовать это:

Сохраните двух соседей каждого числа с помощью 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]]

Надеюсь, это поможет вам, и прокомментируйте, если у вас есть дополнительные вопросы. :)

Такой набор пар, образующий цепочку, обладает тем свойством, что каждый элемент появляется ровно один раз в первой позиции пары и один раз во второй позиции. Если вы знаете, что среди ваших пар есть ровно один переворот, вы можете воспользоваться этим свойством: первый элемент в перевернутой паре появляется дважды в первой позиции, а второй элемент вообще не появляется в первой позиции.

Вот идея: исследовать пары одну за другой и отслеживать каждую пару по ее первому элементу. Когда мы видим вторую пару с таким же первым элементом, одна из этих двух пар должна быть перевернутой - назовите этих кандидатов. Когда мы видим элемент второй одного из кандидатов в качестве первого элемента другой пары, мы знаем, что этот кандидат не является обратным, поэтому мы меняем другой.

Это решение работает на месте, что может быть преимуществом, а может и не быть. Было бы легко преобразовать его в тот, который возвращает исправленный список. У него также есть то преимущество, что он проходит по списку пар только один раз - в худшем случае. В большинстве случаев он может остановиться до конца. Это примерно в семь раз быстрее, чем решение от разведка в моем тестировании.

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