为什么这个修改后的 Python 笛卡尔乘积函数不起作用？

Question

理想情况下，输入为 [1,2]，输出是所有组合 [[1,1]， [2,2

]， [1,2]， [2,1]]。基本上，打印所有可能的组合并进行替换。

def cart(lst):
   if lst == []:
      return [[]]
   return [x[i:] + [lst[0]] + x[:i] for x in cart(lst[1:]) for i in range(len(x)) ]
l = [1,2,3] 
print cart(l)

返回

[]

在更人类可读的形式中，代码基本上说：

for x in cart(lst[1:]):
   for i in range(len(x)):
      return x[i:] + [lst[0]] + x[:i]

如果我们假设带有输入[1,2,3]的递归情况，则 cart([2,3])应该产生[[2,3], [3,2], [2,2], [3,3]]，因此对于递归步骤，我们希望在每个可能的位置插入1。(此代码可能缺少111情况。

代码看起来逻辑正确，但输出一个空字符串。

是否缺少某些内容或我错误地处理了问题？

编辑

实际上，我意识到代码会稍微复杂一些：

def cart(lst):
    if len(lst) <= 1:
        return lst
    else:
        return [x[i:] + [lst[j]] + x[:i] for x in cart(lst[1:]) for j in range(len(lst)) for i in range(len(x))]

尽管这仍然奇怪地返回一个空列表。我的预感是我错过了一个基本案例。

编辑

这与我的基本情况有关。修订后的代码：

def cart(lst):
    if len(lst) <= 1:
        return [lst]
    else:
        return [x[i:] + [lst[j]] + x[:i] for x in cart(lst[1:]) for j in range(len(lst)) for i in range(len(x))]
l = [1,2,3]
print cart(l)

但现在回来了

[[3， 2， 1]， [2， 1， 3]， [3， 2， 2]， [2， 2， 3]， [3， 2， 3]， [2， 3， 3

]， [3， 3， 1 ]

， [3， 1， 3]， [3， 3， 2]， [3， 2， 3]， [3， 3， 3]， [3， 3， 3]]

现在更好了，尽管输出缺少集。似乎又是一个基本案例问题。

Answer 1

在这里找到答案python中用于替换排列的递归函数算法

def permutations_with_replacement(k,n):
         # special case (not part of recursion)
         if k == 0:
            return []
         if k == 1:
            return [[n[i]] for i in range(len(n))]
         else:
            # Make the list by sticking the k-1 permutations onto each number 
            # we can select here at level k    
            result = []
            # Only call the k-1 case once, though we need it's output n times.
            k_take_one_permutations = permutations_with_replacement(k-1,n)  
            for i in range(len(n)):
                for permutation in k_take_one_permutations:
                    result.append([n[i]]+permutation)   
            return result
         print permutations_with_replacement(3,2)
print permutations_with_replacement(3, [1,2,3])

看来我试图采用列表本身的递归情况，而不是组合的大小。

我想知道解决方案是否可以通过在列表中重复出现而不是组合的大小来实现。