我可以用蛮力做到这一点，但是我希望有聪明的编码，或者是现有的功能，或者我没有意识到的东西...
所以我想要一些数字示例：
00000000001111110000
11111100000000000000
01010101010100000000
10101010101000000000
00100100100100100100
完整排列。除非结果只有六个1。不多。不低于。 64或32位将是理想的。 16位（如果提供答案）。
答案 0 :(得分：4)
我认为您需要的是使用itertools模块。
错误的解决方案
但是您需要小心，例如，使用permutations之类的内容仅适用于非常小的输入。即：
类似下面的内容将为您提供二进制表示形式：
>>> ["".join(v) for v in set(itertools.permutations(["1"]*2+["0"]*3))]
['11000', '01001', '00101', '00011', '10010', '01100', '01010', '10001', '00110', '10100']
然后只获取这些数字的十进制表示形式：
>>> [int("".join(v), 16) for v in set(itertools.permutations(["1"]*2+["0"]*3))]
[69632, 4097, 257, 17, 65552, 4352, 4112, 65537, 272, 65792]
如果您希望32位具有6个1和26个0，请使用：
>>> [int("".join(v), 16) for v in set(itertools.permutations(["1"]*6+["0"]*26))]
但是此计算将需要超级计算机来处理（32！= 263130836933693530167218012160160）
不错的解决方案
因此，更聪明的方法是使用combinations，也许是这样的：
import itertools
num_bits = 32
num_ones = 6
lst = [
f"{sum([2**vv for vv in v]):b}".zfill(num_bits)
for v in list(itertools.combinations(range(num_bits), num_ones))
]
print(len(lst))
这将告诉我们在整个32位数字频谱中有906192个数字和6个数字。
学分：
此答案的信用归@Mark Dickinson所用，他指出使用permutations是不可行的，并建议使用combinations
答案 1 :(得分：1)
我不是Python编码人员，所以我无法为您发布有效的代码。相反，我可以做一个 C ++ ...
如果您查看问题，则设置6个位和多个零...因此，我将通过6个嵌套的for循环来处理此问题，从而计算所有可能的1s位置并设置这些位...
类似的东西：
for (i0= 0;i0<32-5;i0++)
for (i1=i0+1;i1<32-4;i1++)
for (i2=i1+1;i2<32-3;i2++)
for (i3=i2+1;i3<32-2;i3++)
for (i4=i3+1;i4<32-1;i4++)
for (i5=i4+1;i5<32-0;i5++)
// here i0,...,i5 marks the set bits positions
因此O(2^32)小于`〜O（26.25.24.23.22.21 / 16），并且您不能快于此，因为这将意味着您错过了有效的解决方案...
我假设您要打印数字，因此为了加快速度，可以从一开始就将数字计算为二进制数字字符串，以避免字符串和数字之间的转换缓慢...
嵌套的for循环可以编码为数组的增量操作（类似于bignum算法）
放在一起时，我得到了以下 C ++ 代码：
int generate()
{
const int n1=6; // number of set bits
const int n=32; // number of bits
char x[n+2]; // output number string
int i[n1],j,cnt; // nested for loops iterator variables and found solutions count
for (j=0;j<n;j++) x[j]='0'; x[j]='b'; j++; x[j]=0; // x = 0
for (j=0;j<n1;j++){ i[j]=j; x[i[j]]='1'; } // first solution
for (cnt=0;;)
{
// Form1->mm_log->Lines->Add(x); // here x is the valid answer to print
cnt++;
for (j=n1-1;j>=0;j--) // this emulates n1 nested for loops
{
x[i[j]]='0'; i[j]++;
if (i[j]<n-n1+j+1){ x[i[j]]='1'; break; }
}
if (j<0) break;
for (j++;j<n1;j++){ i[j]=i[j-1]+1; x[i[j]]='1'; }
}
return cnt; // found valid answers
};
当我将其与n1=6,n=32一起使用时，我得到了以下输出（不打印数字）：
cnt = 906192
它在4.246 ms上以AMD A8-5500 3.2GHz（win7 x64 32位应用程序无线程）完成，对我来说足够快了……
请注意，一旦开始在某个地方输出数字，速度将急剧下降。尤其是如果您将输出输出到控制台或其他任何方式...最好以某种方式缓冲输出，例如一次输出1024个字符串数字等等。但是正如我之前提到的，我不是Python编码器，所以它可能已经被处理了。环境...
最重要的是，一旦您将使用变量n1,n，您可以对零而不是1进行相同的操作，并使用更快的方法（如果零较少，则使用嵌套循环标记零而不是零）个）
如果将所需的解决方案编号作为数字（而不是字符串），则可以重写它，因此i[]或i0,..i5保留位掩码而不是位位置...而不是inc / dec，您只需向左/向右移动...不再需要x数组，因为数字将是x = i0|...|i5 ...
答案 2 :(得分：1)
您可以为数字中的1s位置创建一个计数器数组，并通过将各个位移位到相应位置来进行组合。我在下面创建了一个示例。它运行非常快（在我的笔记本电脑上，不到32秒就可以运行一秒钟）：
bitCount = 32
oneCount = 6
maxBit = 1<<(bitCount-1)
ones = [1<<b for b in reversed(range(oneCount)) ] # start with bits on low end
ones[0] >>= 1 # shift back 1st one because it will be incremented at start of loop
index = 0
result = []
while index < len(ones):
ones[index] <<= 1 # shift one at current position
if index == 0:
number = sum(ones) # build output number
result.append(number)
if ones[index] == maxBit:
index += 1 # go to next position when bit reaches max
elif index > 0:
index -= 1 # return to previous position
ones[index] = ones[index+1] # and prepare it to move up (relative to next)
64位大约需要一分钟，大致与输出值的数量成正比。 O（n）
在递归生成器函数中可以更简洁地表达相同的方法，这将允许更有效地使用位模式：
def genOneBits(bitcount=32,onecount=6):
for bitPos in range(onecount-1,bitcount):
value = 1<<bitPos
if onecount == 1: yield value; continue
for otherBits in genOneBits(bitPos,onecount-1):
yield value + otherBits
result = [ n for n in genOneBits(32,6) ]
当您获得所有数字时，这并不是很快，但是它允许部分访问列表而无需遍历所有值。
如果您需要直接访问第N个位模式（例如，获得一个随机的一位模式），则可以使用以下功能。它的工作方式类似于为列表建立索引，而不必生成模式列表。
def numOneBits(bitcount=32,onecount=6):
def factorial(X): return 1 if X < 2 else X * factorial(X-1)
return factorial(bitcount)//factorial(onecount)//factorial(bitcount-onecount)
def nthOneBits(N,bitcount=32,onecount=6):
if onecount == 1: return 1<<N
bitPos = 0
while bitPos<=bitcount-onecount:
group = numOneBits(bitcount-bitPos-1,onecount-1)
if N < group: break
N -= group
bitPos += 1
if bitPos>bitcount-onecount: return None
result = 1<<bitPos
result |= nthOneBits(N,bitcount-bitPos-1,onecount-1)<<(bitPos+1)
return result
# bit pattern at position 1000:
nthOneBit(1000) # --> 10485799 (00000000101000000000000000100111)
这使您可以获取无法完全生成的非常大的整数的位模式：
nthOneBits(10000, bitcount=256, onecount=9)
# 77371252457588066994880639
# 100000000000000000000000000000000001000000000000000000000000000000000000000000001111111
值得注意的是，模式顺序不遵循相应数字的数字顺序
尽管nthOneBits（）可以立即生成任何模式，但在批量生成模式时，它比其他函数要慢得多。如果需要顺序操作它们，则应使用生成器函数，而不要在nthOneBits（）上循环。
此外，调整生成器以使其以特定的模式开始应该是相当容易的，这样您就可以充分利用这两种方法。
最后，在已知模式的情况下获得下一个位模式可能是有用的。这是以下功能的作用：
def nextOneBits(N=0,bitcount=32,onecount=6):
if N == 0: return (1<<onecount)-1
bitPositions = []
for pos in range(bitcount):
bit = N%2
N //= 2
if bit==1: bitPositions.insert(0,pos)
index = 0
result = None
while index < onecount:
bitPositions[index] += 1
if bitPositions[index] == bitcount:
index += 1
continue
if index == 0:
result = sum( 1<<bp for bp in bitPositions )
break
if index > 0:
index -= 1
bitPositions[index] = bitPositions[index+1]
return result
nthOneBits(12) #--> 131103 00000000000000100000000000011111
nextOneBits(131103) #--> 262175 00000000000001000000000000011111 5.7ns
nthOneBits(13) #--> 262175 00000000000001000000000000011111 49.2ns
就像nthOneBits（）一样，这个不需要任何设置时间。它可以与nthOneBits（）结合使用，以在给定位置获得初始图案后获得后续图案。 nextOneBits（）比nthOneBits（i + 1）快得多，但仍比生成器函数慢。
对于非常大的整数，使用nthOneBits（）和nextOneBits（）可能是唯一可行的选择。
答案 3 :(得分：0)
您正在处理multisets的排列。有很多方法可以实现这一目标，正如@BPL指出的那样，有效地做到这一点并非易事。这里提到了许多很棒的方法：permutations with unique values。最干净的方法（不确定是否最有效）是使用multiset_permutations模块中的sympy。
import time
from sympy.utilities.iterables import multiset_permutations
t = time.process_time()
## Credit to @BPL for the general setup
multiPerms = ["".join(v) for v in multiset_permutations(["1"]*6+["0"]*26)]
elapsed_time = time.process_time() - t
print(elapsed_time)
在我的计算机上，以上计算仅需8秒即可完成。它也产生了将近一百万个结果：
len(multiPerms)
906192