相关疑难解决方法(0)

我一直在玩这个,但是看不出明显的解决方案.我想从XinY_Go函数中删除递归.

def XinY_Go(x,y,index,slots):
   if (y - index) == 1:
      slots[index] = x
      print slots
      slots[index] = 0
      return
   for i in range(x+1):
      slots[index] = x-i
      XinY_Go(x-(x-i), y, index + 1, slots)

def XinY(x,y):
   return XinY_Go(x,y,0,[0] * y)

该函数正在计算将X弹珠放入Y槽的方法数.这是一些示例输出:

 >>> xy.XinY(1,2)
 [1, 0]
 [0, 1]
 >>> xy.XinY(2,3)
 [2, 0, 0]
 [1, 1, 0]
 [1, 0, 1]
 [0, 2, 0]
 [0, 1, 1]
 [0, 0, 2]

所以我正在创建一个单词生成器,它接受几个输入的字母,将它们放在所有可能的位置,并将它们与文档匹配以查找单词.如果我接近这个错误请告诉我!如果不是我怎么能这样做？谢谢

在Python 2.7中,我想获得列表元素的自我笛卡尔积,但没有元素与自身配对.

 In[]: foo = ['a', 'b', 'c']
 In[]: [x for x in itertools.something(foo)]
Out[]: 
       [('a', 'b'), ('a', 'c'), ('b', 'a'), ('b', 'c'), ('c', 'a'), ('c', 'b')]

目前我这样做:

[x for x in itertools.product(foo, repeat=2) if x[0] != x[1]]

但我怀疑有一个内置的方法.它是什么？

注意:itertools.combinations 不会给我 ('a', 'b')和('b', 'a')

我需要一个代码来运行 4 个数字的可能组合，例如 1234 将产生 1234、1243、1324 ... 等的 24 种组合。但不做 ['1', '12', '123', ect] 我希望它只有 4 个数字长度组合，（只是改变顺序）
一个长的选择是

    import random

随机化 4 个数字中的一个，随机化另一个、另一个和另一个，检查该组合是否已被打印或添加到保存可能组合的数组中，然后最终打印出所有这些组合。

array = ['1234', '1243', '1342', '1324' ect]

但这会花费很长时间，而且效率极低。对编码很陌生:)谢谢

我有一个函数get_appendable_values(sequence)，它接受一个序列（甚至是空的）并返回可附加到该序列（作为最后一个元素）的所有值的列表。我需要根据此函数中定义的规则并从空序列开始，生成 4 个元素的所有可能序列。

例子 ：

假设 的实现get_appendable_values是：

def get_appendable_values(sequence):
    '''Dummy rules'''
    if len(sequence) == 2:
        return [4, 12]
    if sequence[-1] == 4:
        return [7]
    return [0, 9]

预期输出：

[[0, 0, 4, 7],
[0, 0, 12, 0],
[0, 0, 12, 9],
[0, 9, 4, 7],
[0, 9, 12, 0],
[0, 9, 12, 9],
[9, 0, 4, 7],
[9, 0, 12, 0],
[9, 0, 12, 9],
[9, 9, 4, 7],
[9, 9, 12, 0],
[9, 9, 12, 9]] …

给定一个数组a=['a','b','c'],如何在没有重复的情况下返回数组的笛卡尔积.例:

[['a', 'a' , 'a' ,'a']
['a', 'a' , 'a' ,'b']
['a', 'a' , 'a' ,'c']
['a', 'a' , 'b' ,'b']
['a', 'a' , 'b' ,'c']
['a', 'a' , 'c' ,'c']
...etc..]

下面如何在Python中生成列表的所有排列,我试过:

print list(itertools.permutations(['a', 'b' , 'c'], 4))
[]

print list(itertools.product(['a', 'b' , 'c'], repeat=4)

但是我得到了重复的笛卡尔积.例如,列表将包含两者['a','a','b','b'],['a','b','b','a']哪些明显相等.

注意:我的'a','b','c'是存储数字的变量,例如1,2,3.在获得字母组合列表后,我需要:说,

['a','b','c','c'] ----> a*b*c*c = 1*2*3*3 = 18

在python中执行此操作的最快方法是什么？用numpy做它会有可能/更快吗？谢谢!

我有一组6个项目，我们称它们为“ 1”至“ 6”。我想做的是创建另一个列表，其中包含这些项目的所有可能组合（顺序？）。在每种可能的组合中，均必须包括所有6个项目，并且不能重复。它可能是向后的组合，因为它具有一组不同的数字。

这是我的主意：

import random

items = [1,2,3,4,5,6]
ListOfCombinations = []
while True:
    random.shuffle(items)
    print(items)
    string = " ".join(str(e) for e in items)
    if string not in ListOfCombinations:
        ListOfCombinations.append(string)

我在这里尝试做的是创建一个随机订单，并将其添加到第二个列表（如果尚不在其中）。但是我觉得必须采取不同的方式，而且我可能做错了。我是python的菜鸟，所以将不胜感激！

我一直在尝试创建一个脚本，其中将打印列表的每个可能组合[其中 (1,2) 和 (2,1) 将被视为不同的条目]。例如：

c = [1,2]
# do something magical
print(c with magical stuff) 
>>>[(1), (2), (1, 1), (1, 2), (2, 1), (2, 2)]

我试过 itertools.permutations。它显示输出为 >>> () (1,) (​​2,) (1, 2) (2, 1)。但是，它不包括 (1, 1) 和 (2,2)

任何帮助将不胜感激。我是编码新手（我非常流利地打印“Hello World！”虽然：3）

我试图用list = [0,1,2,3,4,5,6]计算所有排列,遵守一些约束.

• 位置0必须> 3
• 位置3 +位置5 <位置4

使用我当前的代码,我确定了每个的所有排列和迭代,应用约束.

import itertools

Used_permutations = []    
numbers = [0,1,2,3,4,5,6]
all_permutations = list(itertools.permutations(numbers)) #Determine all permutations

for permutation in all_permutations:
    if permutation[0] > 3 and permutation[3] + permutation[5] < permutation[4]: #Constraints applied to permutations
        Used_permutations.append(permutation)  
        ####################################################
        ###   Apply calculations to current permutation ###
        ####################################################

这段代码的问题在于我浪费时间找到所有可能的排列,只是为了再次过滤它们.有人可以协助一种方法来应用约束,同时确定排列,所以不是所有的N!确定了？

所以我有一个这样的字符串：

"abc"

我会需要：

"abc"
"acb"
"bca"
"bac"
"cab"
"cba"

我试过：

string = "abc"

combinations = []
for i in range(len(string)):
    acc = string[i]
    for ii in range(i+1,i+len(string)):
            acc += string[ii%len(string)]
             
    combinations.append(acc)
    combinations.append(acc[::-1])
            
print(combinations)

如果适用于大小为 3 的字符串，但我认为它非常低效并且也不适用于"abcd". 有没有更好的方法？

更新：我想通过提供算法来解决。实际上目前正在以递归方式解决它。更喜欢不是python函数的解决方案为我解决问题