Как определить итерационную функцию, включающую цикл for, где итераторы i, j, l .. также используются в определенной итерационной функции

Question

Я пытаюсь использовать рекурсивную функцию, чтобы упростить приведенные ниже «for-loop» для любого числа циклов, которые мне могут понадобиться для запуска программы в соответствии с требованиями. Я могу определить рекурсивную функцию без использования i, j, k, l .... в функции, но я понятия не имею, или у меня возникают трудности с определением итерационной функции с использованием i, j k .. , Я был бы рад, если бы кто-то мог немного помочь моему воображению.

adjcent_spin_product_matrix = []
z_partial = 0
spin = [-1, 1]
for i in spin:
    for j in spin:
        for k in spin:
            for l in spin:
               for m in spin:
                   for o in spin:
                       for p in spin:
                           adjcent_spin_product_matrix = adjcent_spin_product_matrix + [i*j+ j*k+ k*l+ l*n+ m*o+ o*p]

Answer 1

Мой предыдущий ответ был против вашего неотредактированного поста, поэтому вот обновление:

Из предоставленного вами кода ясно, что у вас должно быть как минимум циклы для i и j.

Оценка этого цикла сама по себе дает следующий список: [1, -1, -1, 1]

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

Циклы i, j и k дают [1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1, 1, 1, -1, -1, 1] = [2, 0, -2, 0, 0, -2, 0, 2]

Циклы i, j, k и l дают [1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1] + [1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1] + [1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1] = [3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]

И так далее ...

Следовательно, вы можете просто попробовать что-то вроде следующего:

adjacent_spin_product_matrix = []
ij_result = [1, -1, -1, 1]

def calc_product(adjacent_spin_product_matrix, number_of_indices):
    if number_of_indices == 2:
        return ij_result
    else:
        number_of_duplicates = 2 ** (number_of_indices - 2)
        curr_array = []
        for elem in ij_result:
            for dup in range(number_of_duplicates):
                curr_array.append(elem)
        prev_array = calc_product(adjacent_spin_product_matrix, number_of_indices - 1)
        temp_array = []
        temp_array.extend(prev_array)
        temp_array.extend(prev_array)
        result = []
        for i, elem in enumerate(curr_array):
            result.append(elem + temp_array[i])

        return result

Теперь вы должны найти, что:

print(calc_product([], 2))  # equivalent to i and j case
print(calc_product([], 3))  # equivalent to i, j, and k case
print(calc_product([], 4))  # equivalent to i, j, k, and l case
print(calc_product([], 5))  # equivalent to i, j, k, l, and m case
print(calc_product([], 6))  # equivalent to i, j, k, l, m, and o case
print(calc_product([], 7))  # equivalent to i, j, k, l, m, o, and p case

Они дают ожидаемые результаты:

[1, -1, -1, 1]
[2, 0, -2, 0, 0, -2, 0, 2]
[3, 1, -1, 1, -1, -3, -1, 1, 1, -1, -3, -1, 1, -1, 1, 3]
[4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4]
[5, 3, 1, 3, 1, -1, 1, 3, 1, -1, -3, -1, 1, -1, 1, 3, 1, -1, -3, -1, -3, -5, -3, -1, 1, -1, -3, -1, 1, -1, 1, 3, 3, 1, -1, 1, -1, -3, -1, 1, -1, -3, -5, -3, -1, -3, -1, 1, 3, 1, -1, 1, -1, -3, -1, 1, 3, 1, -1, 1, 3, 1, 3, 5]
[6, 4, 2, 4, 2, 0, 2, 4, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 2, 0, -2, 0, -2, -4, -2, 0, -2, -4, -6, -4, -2, -4, -2, 0, 2, 0, -2, 0, -2, -4, -2, 0, 2, 0, -2, 0, 2, 0, 2, 4, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 0, -2, -4, -2, -4, -6, -4, -2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 0, -2, -4, -2, 0, -2, 0, 2, 4, 2, 0, 2, 0, -2, 0, 2, 4, 2, 0, 2, 4, 2, 4, 6]

Answer 2

Нет особой необходимости в рекурсивной функции.

Вы можете использовать один цикл для каждого числа индексов, если вы используете itertools.product; Вы также можете упростить вычисления, используя sum и zip

from itertools import product
...
spin_products = []
n = int(input('how many indices? '))
...
for indices in product([-1, 1], repeat=n):
    spin_products.append(sum(i*j for i, j in zip(indices, indices[1:])))

Answer 3

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

Стек является фундаментальной структурой данных в большинстве языков, так как это очень естественный способ хранения контекстов вызова функций, и именно здесь Stack Overflow получил свое имя.