Как построить алгоритм, где мне нужно «хранить» несколько индексов

Question

Я не знаю, как технически объяснить проблему (только в этой игре 3 месяца), но я ее подставлю и надеюсь, что вы, ребята, сможете решить ее, потому что у меня нет идей для этого

Итак, я хочу начать с list0, а затем проверить, есть ли какой-либо элемент в list1. Если это так, то мы «отслеживаем» этот элемент через списки, чтобы увидеть окончательные «преобразования (ий)»

Правило1: элементы в списке list1 «превращаются» в элемент list2, имеющий тот же индекс в list

Правило 2: один элемент может преобразовываться в несколько элементов, поэтому он может появляться более одного раза в списке list1

Пример: «1» в индексах 0 и 4, поэтому он преобразуется в «1a» и «1bb», то «1a» находится в индексах 1 и 8, поэтому оно преобразуется в «2b» и «7a» и т. д. c.

Таким образом, в основном отслеживание «1» дает нам информацию о том, что «1 «превращается в пять конечных элементов (« 1bb »,« 4d »,« 7a »,« 91 »,« 92 »), а отслеживание« 2z »дает нам просто« 3z »(путь 2z-2zz-3z)

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

Не знаю, правильный ли это способ решить это

list0 = ['1', '2z', 'etc']
list1 = ['1', '1a', '2b', '3c', "1", "1bb","2z", "2zz","1a",'2b',"100","100"]
list2 = ['1a', '2b', '3c', '4d', "1bb", "8", "2zz", "3z", "7a","100", "91","92" ]


for item in list0:
if item in list1:
    alpha_key = item
    indexes = [i for i, k in enumerate(list1) if k == alpha_key]
    for i in indexes:
        alpha_key = list1[i]
        keep_going = True
        while alpha_key in list1 and keep_going:
            alpha_key = list2[i]
            if alpha_key in list1:
                print("INDEXES IS ", indexes)
                keep_going = True
                i += 1
            if alpha_key not in list1:
                print("this is resulting ", alpha_key, "of this ", item)
                keep_going = False

Answer 1

Я бы предложил сделать шаг назад. В list1 и list2 есть входные данные и соответствующие им выходные данные, поэтому давайте сгруппируем их вместе в один список, чтобы нам не пришлось так сильно беспокоиться об индексах. Затем мы можем создать функцию, которая будет принимать одиночный ввод и просто находить соответствующий вывод. Затем у вас есть list0, который представляет собой список входов для преобразования в их выходы. Список пониманий сделает это проще.

list0 = ['1', '2z', 'etc']
list1 = ['1', '1a', '2b', '3c', "1", "1bb","2z", "2zz","1a",'2b',"100","100"]
list2 = ['1a', '2b', '3c', '4d', "1bb", "8", "2zz", "3z", "7a","100", "91","92" ]

transforms = list(zip(list1, list2))

def transform(value):
    return [v[1] for v in transforms if v[0] == value]

result = [transform(x) for x in list0]

result заканчивается значением [['1a', '1bb'], ['2zz'], []].

Функция zip была используется для создания корреспонденции (списка пар) между list1 и list2. Затем функция transform проходит через эти пары и находит их все, где первый элемент (полученный из list1) соответствует входу, и выбирает второй элемент (который является соответствующим элементом из list2. Возвращает все такие элементы, как список, в порядке их появления. Поэтому, если мы передадим его '1', он вернет ['1a', '1bb'], или, если мы передадим его '2b', он вернет ['3c']. Если он будет передан значение, которое отсутствует в list1, вернет пустой список.

Окончательное понимание списка применяет эту функцию к каждому элементу list0.

Answer 2

Вы можете использовать рекурсию, чтобы решить эту проблему. То, что вы делаете, это рекурсивно проверяет, находится ли значение в list1 (начиная со значения в list0). Если вы найдете его, то вы можете рекурсивно проверить, находится ли значение в списке list2 с тем же индексом в списке list1. Если это не так, вы знаете, что это последнее значение.

list0 = ['1', '2z', 'etc']
list1 = ['1', '1a', '2b', '3c', "1", "1bb","2z", "2zz","1a",'2b',"100","100"]
list2 = ['1a', '2b', '3c', '4d', "1bb", "8", "2zz", "3z", "7a","100", "91","92" ]

def findPath(val):
    path = {val}
    for i in range(len(list1)):
        if list1[i] == val:
            morePath = findPath(list2[i])
            for elem in morePath:
                path.add(elem)
            if list1[i] in path:
                path.remove(list1[i])

    return path

for i in list0:
    print(findPath(i))

Следует отметить, что вам нужно удалить текущий проверяемый индекс, поскольку вы знаете, что это не конечный индекс. Это хорошо работает, если в списках нет циклов, например, EG 1 -> 1a -> 1a, что приведет к бесконечному l oop. Другая проблема может быть, если у вас длинная цепочка преобразований, которая может вызвать рекурсивное переполнение стека.

Вот еще одно решение, которое я считаю более правильным. Он использует Очередь, чтобы знать, какое будет следующее значение для проверки. Кроме того, он проверяет одно и то же значение только один раз, проверяя, есть ли оно в наборе.

В одном я не уверен, что это правильный путь для трансформации. Кажется, что list1 содержит «1bb», который, как вы сказали, является последним элементом. Это правильно, или вместо этого должно быть «8»?

from queue import Queue

list0 = ['1', '2z', 'etc']
list1 = ['1', '1a', '2b', '3c', "1", "1bb","2z", "2zz","1a",'2b',"100","100"]
list2 = ['1a', '2b', '3c', '4d', "1bb", "8", "2zz", "3z", "7a","100", "91","92" ]

checked = set()
checkQueue = Queue()

def findPath(val):
    path = set()
    checkQueue.put(val)
    while checkQueue.qsize() > 0:
        curVal = checkQueue.get()
        if curVal in checked:
            continue
        checked.add(curVal)
        path.add(curVal)
        for i in range(len(list1)):
            if list1[i] == curVal:
                if list1[i] in path:
                    path.remove(curVal)
                checkQueue.put(list2[i])

    return path

for i in list0:
    print(findPath(i))

То, что второе решение решает, это обе проблемы зацикливания (так что программа не обрабатывает sh), которая выдаст нет значений в l oop и рекурсивная проблема, так как он делает это итеративно.