Python 生成数值置换（迭代与递归）

我想我正在尝试做一些非常基本和简单的事情。出于这个原因，我确信Stack Overflow已经有一篇关于这个任务的帖子了，但我想不是吧？也许这是一个无关紧要的概念？如果已经存在对此的帖子，请道歉。我找不到它

下面是我想要完成的：给定列表长度n和最大元素值m，生成列表的所有排列，每个元素在0到m之间变化

问题：1。有没有一种递归的方法？2.对于这个概念，递归是最优的（在计算资源、O时间等方面），还是迭代更好？3.是否有更好的方法（不太复杂）通过迭代实现这一点（请参阅下面的代码）？

更多信息见下文

我编辑了我的代码和两个示例，以生成并展示完整的解决方案

以下是两个例子：

例1：n=3，m=2 输出：

例1:n=2，m=4 输出：

我的直觉告诉我这可以递归完成，但我想不出怎么做（我是一个初学者程序员）。目前，我有一个迭代实现此目标的解决方案：

def permute(curr_permute,max_num,reset_flgs,reset_ind):
    '''
    Increment Logic Structure
    '''
    perm_ind = 0
    max_val_flgs = [0]*len(curr_permute)
    for c_i in range(len(curr_permute)):
        if ((curr_permute[c_i] == max_num) and (c_i < (len(curr_permute)-1))):
            if ((reset_ind == c_i) and (reset_flgs[c_i] == 1)):
                reset_ind += 1
                reset_flgs[c_i] = 0
                max_val_flgs[c_i] = 1
                continue
            else:
                perm_ind += 1
                max_val_flgs[c_i] = 1
        elif (c_i == (len(curr_permute)-1)):
            if (curr_permute[c_i] == max_num):
                perm_ind = c_i
                max_val_flgs[c_i] = 1
            else:
                perm_ind = c_i
        elif (curr_permute[c_i] < max_num):
            perm_ind += 1
    '''
    Reverse the lists
    '''
    max_val_flgs.reverse()
    curr_permute.reverse()
    reset_flgs.reverse()
    '''
    Reset Logic Structure
    '''
    for n_i in range(len(curr_permute)):
        if (max_val_flgs[n_i] == 0):
            break
        elif ((max_val_flgs[n_i] == 1) and (reset_flgs[n_i] == 1)):
            curr_permute[n_i] = 0
            perm_ind += -1
    '''
    Reverse the lists
    '''
    curr_permute.reverse()
    reset_flgs.reverse()
    '''
    Apply the permutation increment
    '''
    curr_permute[perm_ind] += 1
    return(curr_permute,reset_flgs,reset_ind)

def Permutation_Generation():
    n = 2
    m = 4
   
    curr_permute = [0]*n
    reset_flgs = [1]*n
    reset_ind = 0
    All_Permutations = [list(curr_permute)]
    while (sum(curr_permute) < (n*m)):
        print(curr_permute)
        [curr_permute,reset_flgs,reset_ind] = permute(curr_permute,m,reset_flgs,reset_ind)
        All_Permutations.append(list(curr_permute))
    print(curr_permute)
    return(All_Permutations)

def置换（当前置换、最大置换、重置置换、重置置换）：
'''
增量逻辑结构
'''
perm_ind=0
最大值flgs=[0]*长度（当前排列）
对于范围内的c_i（len（curr_permute））：
如果（（curr_permute[c_i]==max_num）和（c_i<（len（curr_permute）-1））：
如果（（reset_ind==c_i）和（reset_flgs[c_i]==1））：
重置ind+=1
重置\u flgs[c\u i]=0
最大值flgs[c_i]=1
持续
其他：
perm_ind+=1
最大值flgs[c_i]=1
elif（c_i==（len（curr_permute）-1））：
如果（curr_permute[c_i]==max_num）：
perm_ind=c_i
最大值flgs[c_i]=1
其他：
perm_ind=c_i
elif（当前排列[c\u i]

---

为垃圾代码道歉。一旦我想出了一个成功的方法，我就没有花太多的精力去清理它或者提高它的效率。我猜这段代码对于我试图解决的概念来说太复杂了。

3。您想要获得所有排列。给定n和m的置换数为（m+1）^n。 因为您实际上想要打印所有这些文件，所以时间复杂度也是O（（m+1）^n），这是迭代执行时得到的结果

---

1+2。我认为不应该使用递归，O（（m+1）^n）是您可以执行此操作的最佳时间，这是使用迭代时得到的结果。递归的内存堆栈也会占用更多的内存。

这个问题似乎已经得到了回答，但我想为迭代置换提供一个更简单的替代方案。在这里，我使用列表理解、格式化字符串文本（f'string'字符串）和eval内置方法。希望这个观点能对你有所帮助（不知何故？）

---

我认为n和m分别为3和2的输出没有意义。在第六行

[0,2,0]

之后，后面不应该跟

[0,2,1]

而不是

[1,0,0]

？同样的情况也发生在第13排之后

无论如何，这里有一个递归变量：

n = 3
m = 2

def permutation(n, m):
    if n <= 0:
        yield []
    else:
        for i in range(m+1):
            for j in permutation(n-1, m):
                yield [i] + j

# or even shorter
def permutation(n, m):
    return [[i] + j for i in range(m + 1) for j in permutation(n - 1, m)] if n > 0 else []


for i in permutation(n, m):
    print(i)

---

很高兴知道！谢谢大家!@J_Aero_Paul如果回答了你的问题，请接受答案：）这篇文章太新了，我不会接受答案的。哈哈哈哈哈，我想这是itertools组合的最主要的主办方。谢谢你的评论！不幸的是，我很难让你的代码运行。我没有“格式化字符串文字”的经验。我的错误显示在：“output=f”[[{array\u mockup}]{for\u loop}]'.#将所有这些组合在一起”。但是，如果我正确地阅读了您的代码，是否为每个数组/列表元素创建了嵌套for循环？这与我有关，因为我希望解决方案能够处理任意大的n值。我认为python的块堆栈限制是20？这是你代码中的一个限制还是我读错了？嗨！关于这个错误：我对变量名做了一些更改，但忘记了更新其中的一些。现在应该修好了。F strings是格式化文本字符串的名称——只要在google上搜索一下，您就会发现它是python中格式化字符串的一种简单方法。关于我的代码和块堆栈限制，您是正确的。我没有涵盖所有的必需品-我的坏！我有你的密码！谢谢你的更新。此外，您的代码似乎在n>20的情况下确实有效。我不知道这是因为python增加了块堆栈限制，还是您的代码实际上没有嵌套for循环。好奇。在任何情况下，至少您的代码会产生一个完整的解决方案。显然，我的解决方案缺少某些排列，因为我没有

def permute(curr_permute,max_num,reset_flgs,reset_ind):
    '''
    Increment Logic Structure
    '''
    perm_ind = 0
    max_val_flgs = [0]*len(curr_permute)
    for c_i in range(len(curr_permute)):
        if ((curr_permute[c_i] == max_num) and (c_i < (len(curr_permute)-1))):
            if ((reset_ind == c_i) and (reset_flgs[c_i] == 1)):
                reset_ind += 1
                reset_flgs[c_i] = 0
                max_val_flgs[c_i] = 1
                continue
            else:
                perm_ind += 1
                max_val_flgs[c_i] = 1
        elif (c_i == (len(curr_permute)-1)):
            if (curr_permute[c_i] == max_num):
                perm_ind = c_i
                max_val_flgs[c_i] = 1
            else:
                perm_ind = c_i
        elif (curr_permute[c_i] < max_num):
            perm_ind += 1
    '''
    Reverse the lists
    '''
    max_val_flgs.reverse()
    curr_permute.reverse()
    reset_flgs.reverse()
    '''
    Reset Logic Structure
    '''
    for n_i in range(len(curr_permute)):
        if (max_val_flgs[n_i] == 0):
            break
        elif ((max_val_flgs[n_i] == 1) and (reset_flgs[n_i] == 1)):
            curr_permute[n_i] = 0
            perm_ind += -1
    '''
    Reverse the lists
    '''
    curr_permute.reverse()
    reset_flgs.reverse()
    '''
    Apply the permutation increment
    '''
    curr_permute[perm_ind] += 1
    return(curr_permute,reset_flgs,reset_ind)

def Permutation_Generation():
    n = 2
    m = 4
   
    curr_permute = [0]*n
    reset_flgs = [1]*n
    reset_ind = 0
    All_Permutations = [list(curr_permute)]
    while (sum(curr_permute) < (n*m)):
        print(curr_permute)
        [curr_permute,reset_flgs,reset_ind] = permute(curr_permute,m,reset_flgs,reset_ind)
        All_Permutations.append(list(curr_permute))
    print(curr_permute)
    return(All_Permutations)

def get_permutations_list(array_size, max_value):
    '''Returns a list of arrays that represent all permutations between zero
    and max_value'''

    array_member =''
    for_loops=''

    #Does a loop iteration for each member of the permutation list template
    for i in range(array_size):

        #adds a new member in each permutation
        array_member += f'x{i}, '

        #adds a new corresponding for loop
        for_loops+=" for x{i} in range({value})".format(i=i, 
                                                   value=max_value)

    output = f'[[{array_member}] {for_loops}]' #combines it all together
    return eval(output)

a = get_permutations_list(array_size=2, max_value=2)
print(a)
#Result: [[0,0],[0,1],[1,0],[1,1]]

n = 3
m = 2

def permutation(n, m):
    if n <= 0:
        yield []
    else:
        for i in range(m+1):
            for j in permutation(n-1, m):
                yield [i] + j

# or even shorter
def permutation(n, m):
    return [[i] + j for i in range(m + 1) for j in permutation(n - 1, m)] if n > 0 else []


for i in permutation(n, m):
    print(i)

[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 1, 0], [0, 1, 1], ..., [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 2, 0], [2, 2, 1], [2, 2, 2]]