Question

例如，假设我想生成两个值的所有排列，每个值可以是0或1，我会得到：

[11,10,01,00]

请注意，第一个变量变化最慢，因此它保持固定而其余变量变化。

在三个变量的情况下，我会得到

[111,110,101,100,011,010,001,000]

我看到它应该有一个递归的定义，但是我的头脑中还不够明确，所以我可以表达它。

Answer 1

这不是关于排列，而是关于组合，你可以在Haskell中轻松生成它们：

replicateM 3 "01"
= ["000","001","010","011","100","101","110","111"]

如果你需要实际的整数：

replicateM 3 [0, 1]
= [[0,0,0],[0,0,1],[0,1,0],[0,1,1],
   [1,0,0],[1,0,1],[1,1,0],[1,1,1]]

最后，如果各个位置的值不同：

sequence [".x", ".X", "-+"]
= ["..-","..+",".X-",".X+","x.-","x.+","xX-","xX+"]

这当然也适用于整数：

sequence [[0,1], [0,2], [0,4]]
= [[0,0,0],[0,0,4],[0,2,0],[0,2,4],
   [1,0,0],[1,0,4],[1,2,0],[1,2,4]]

Answer 2

如果您想要排列，就像在列表列表中一样，这是使用列表monad的解决方案。

\n -> mapM (const [0, 1]) [1..n]

Answer 3

（根据反馈编辑）

最小的n位二进制整数是000..0（n次），为0。

最大的n位二进制整数是111 ... 1（n次），即2 ^ n - 1。

生成从0到1<<n - 1的整数，并打印出您拥有的值。

对于＆lt; = 28二进制变量，Haskell的Int应该是安全的。

希望有所帮助。

Answer 4

ghci> :m +Data.List
ghci> permutations [0,1]
[[0,1],[1,0]]

Answer 5

我不知道哈克尔，但这里有一段关于我如何进行排列的伪代码。

var positions = [0,0,0];
var max = 1;

done:
while(true){
    positions[0]++; //Increment by one
    for (var i = 0; i < positions.length; i++) {
        if(positions[i] > max){ //If the current position is at max carry over
            positions[i] = 0;
            if(i+1 >= positions.length){ //no more positions left
                break done; 
            }
            positions[i+1]++;
        }
    }
}

如何生成n个变量的所有排列，每个变量取1或0？

5 个答案: