如何在 Java 中返回 3x6 矩阵的所有可能结果？

Question

第一步：我想返回 3x6 矩阵的所有可能结果，其中可能的值为 0 或 1。

例如： 可能性一：

0 0 0
0 0 0
0 0 0 
0 0 0
0 0 0
0 0 0

可能性二：

0 0 1
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0

等等...

第二步：我想给每个位置一个结果为 1 或 0 的概率，因此能够计算整个矩阵结果的概率。

我已经尝试了以下代码作为开始，但它尚未工作，我无法正确理解它是如何工作的：

int counter = 0;
String [][] actualOutcome = {{"0","0","0"}, {"0","0","0"}, {"0","0","0"}, {"0","0","0"}, {"0","0","0"}, {"0","0","0"}, {"0","0","0"}, {"0","0","0"}};
String[] possibleOutcomes = {"0","1"};
for(int rowOne = 0; rowOne < 6; rowOne++) {
    for(int rowTwo = 0; rowTwo < 3; rowTwo++) {
        for (int possibilitiesCounter = 0; possibilitiesCounter < possibleOutcomes.length; possibilitiesCounter++) {
            actualOutcome[rowOne][rowTwo] = possibleOutcomes[possibilitiesCounter];
            System.out.println("Possibility " + counter + ": \n" + actualOutcome[0][2] +  actualOutcome[0][1] +  actualOutcome[0][0] + "\n" +
                                                                   actualOutcome[1][2] +  actualOutcome[1][1] +  actualOutcome[1][0] + "\n" +
                                                                   actualOutcome[2][2] +  actualOutcome[2][1] +  actualOutcome[2][0]);
            counter++;
        }
    }
}
    

先感谢您！

Answer 1

最简单的方法是让计数器从0开始一直到511 ，即二进制系统中的111111111 ，而不是使用矩阵进行放置和操作，只需使用数字即可。

    for (int i = 0; i < 512; i++) {
        System.out.println("Possibility " + (i + 1) + ": ");
        for (int j = 0; j < 9; j++) {
            System.out.print((i & (1 << j)) >> j);
            if (j % 3 == 2) 
                System.out.println();
            else 
                System.out.print(" ");
        }
    }

Answer 2

您的矩阵可以显示为一行元素：

矩阵

[a] [b] [c]
[f] [e] [d]
[g] [h] [i]

线表示

[a] [b] [c] [d] [e] [f] [g] [h] [i]

这条线表示，当每个值介于 [0...1] 之间时，将类似于具有 9 位数字的二进制数，从 0 到 2^9（即 512）。

如果你想知道 0..512 中的所有数字，那么 COUNT 从 0 到 512 并将该数字转换回矩阵

实施说明

for(int i = 0; i < 512; i++){
    String asBinary = Integer.toBinaryString(i);
    int elementA = Integer.parseInt(asBiniary.charAt(0));
    int elementB = Integer.parseInt(asBiniary.charAt(1));
    ...
    int elementG = Integer.parseInt(asBiniary.charAt(8));
}

Answer 3

这是另一个解决方案：

        int limit = (int)Math.pow(2, 3*3);
        System.out.println(limit);
        for (int counter = 0; counter < limit; ++counter) {
            int x = counter;
            for(int rowOne = 0; rowOne < 3; rowOne++) {
                for(int rowTwo = 0; rowTwo < 3; rowTwo++) {
                    actualOutcome[rowOne][rowTwo] = possibleOutcomes[x%2];
                    x /= 2;
                }
            }
            System.out.println("Possibility " + counter + ": \n" + actualOutcome[0][2] +  actualOutcome[0][1] +  actualOutcome[0][0] + "\n" +
                                                                   actualOutcome[1][2] +  actualOutcome[1][1] +  actualOutcome[1][0] + "\n" +
                                                                   actualOutcome[2][2] +  actualOutcome[2][1] +  actualOutcome[2][0]);
        }

Answer 4

这相当简洁，至少对于 Java 而言是这样。 最大的努力是将生成的字符串格式化为矩形矩阵。 我们使用迭代比我们需要的 2 的幂的数字的技巧——这确保toBinaryString()返回一个m*n+1的String ——然后我们去除高位。

就 1 在给定位置出现的概率而言 - 在所有模式中，1 将在每个位置出现2^(m*n-1)次，所以我不知道这有帮助。

static void printMatrix(int m, int n)
{
    for(int i = 1<<(m*n); i < 1<<(m*n+1); i++)
        splitPrint(Integer.toBinaryString(i).substring(1), m, n);
}

static void splitPrint(String s, int m, int n)
{
    for(int j=0; j<m; j++) 
        System.out.println(String.join(" ", s.substring(j*n, (j+1)*n).split("")));
    System.out.println();       
}

通过printMatrix(6, 3);调用printMatrix(6, 3);

输出：

0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0

<snip>

1 1 1
1 1 1
1 1 1
1 1 1
1 1 1
1 1 1

Answer 5

关于要求的第一部分，您可以尝试以下操作：

import java.util.Arrays;

class Scratch {

    public static void main(String[] args) {
        double counter = Math.pow(2, 9) - 1;
        for (int i = 0; i <= counter; i++) {
            int[][] matrix = {
                    {(i & (1 << 2)) >> 2, (i & (1 << 1)) >> 1, i & 1},
                    {(i & (1 << 5)) >> 5, (i & (1 << 4)) >> 4, (i & (1 << 3)) >> 3},
                    {(i & (1 << 8)) >> 8, (i & (1 << 7)) >> 7, (i & (1 << 6)) >> 6},
            };
            printArray(matrix);
        }
    }

    private static void printArray(int[][] matrix) {
        System.out.println("==================");
        for (int[] row : matrix) {
            System.out.println(Arrays.toString(row));
        }
    }
}

这将给出如下输出：

==================
[0, 0, 0]
[0, 0, 0]
[0, 0, 0]
==================
[0, 0, 1]
[0, 0, 0]
[0, 0, 0]
==================
[0, 1, 0]
[0, 0, 0]
[0, 0, 0]
==================
[0, 1, 1]
[0, 0, 0]
[0, 0, 0]