Question

我随机填充二维数组，但我希望每行和每列中生成的数字都是唯一的。这是我用过的代码

int[][] values = new int[3][3];

    Random randomGenerator = new Random();
    for (int i = 0; i < values.length; i++) {

        int[] sub = values[i];
        for (int x = 0; x < sub.length; x++) {
            sub[x]= randomGenerator.nextInt(4);;
        System.out.print(sub[x] + " ");
        }
        System.out.println();
    }

我当前的输出是，这可能会随着生成的数字是随机的而改变

2 2 2 
3 2 0 
0 2 1

但我期待这样的事情

1 2 3 
3 1 2 
2 3 1

Answer 1

在我看来，你正在尝试创建一个类似于数独棋盘的矩阵，除非你没有要求检查每个3x3子矩阵。

如果您计划使用9x9矩阵。所有81个元素都不可能随机使用。（你可以，但可能需要比生成电路板所需的时间长得多）。

这是你可以做的：

创建2个数组，以跟踪当前行/列是否已有1-9
创建一组要从中挑选的数字（数字范围遵循矩阵大小）
随机填充第一行1-9。
通过检查是否可以填充数字来递归填充空框。
在填写数字时，请将其从数字集中删除
如果存在冲突，请回溯到最后已知的好位置并继续

Answer 2

这是一种方法。

您可以跟踪已生成的数字，如果再次生成这些数字，则忽略它们。

我使用Set因为它不允许重复的值。但我相信任何其他收藏都应该做到这一点。

int[][] values = new int[3][3];

Random randomGenerator = new Random();
for (int i = 0; i < values.length; i++) {
    Set<Integer> set= new HashSet<Integer>();
    int[] sub = values[i];
    for (int x = 0; x < sub.length;) {
        int next= randomGenerator.nextInt(4) + 1;// +1 ensure a number in {1,2,3}

        if(!set.contains){
          sub[x]= next;
          set.add(next);
          x++;  //note we only add the variable if non-duplicate values were generated.
          System.out.print(sub[x] + " ");
        }

    }
    System.out.println();
}

注意，

如果您尝试更改阵列的大小，则最好更改

int next= randomGenerator.nextInt(4) + 1;

到

int next= randomGenerator.nextInt(values[i].length) + 1;

因此，它可以确保您始终有足够的distinct个数字来生成

Answer 3

我用蛮力方法尝试了这个问题并且它有效。生成一个独特的9 x 9电路板需要不到 1秒。

<强>输出：

1 2 3 4 5 6 7 8 9 
2 6 8 9 7 4 1 3 5 
6 3 5 7 9 1 2 4 8 
9 5 4 8 6 2 3 1 7 
5 4 7 1 2 8 9 6 3 
8 1 9 6 3 7 5 2 4 
4 9 2 3 8 5 6 7 1 
7 8 6 5 1 3 4 9 2 
3 7 1 2 4 9 8 5 6

以下是我的代码：

public static void main(String[] args){
    int size = 9;

    int[][] board= new int[size][size];
    board[0] = Util.createOrderedArray(size, 1);

    for(int x=1; x<size; x++){          
        board[x] = Util.createOrderedArray(size, 1);
        do{
            Util.shuffle(board[x]);
        }while(!Util.compare2DArray(board[x], board, 0, x));        
    }       
    Util.print(board);  
}

我在自定义的Util类中编写了所有帮助器方法。

final class Util
{
    public static void shuffle(int[] num){
        Random rnd = new Random();
        for(int x=0; x<num.length; x++)
            swap(num, x, rnd.nextInt(num.length));
    }

    public static void swap(int[] num, int a, int b){
        int temp = num[a];
        num[a] = num[b];
        num[b] = temp;
    }

    public static int[] createOrderedArray(int size, int startValue){
        int[] num = new int[size];
        for(int x=0; x<num.length; x++)
            num[x] = x+startValue;      
        return num;
    }

    //Return TRUE if array vs arrays is COMPLETELY different
    public static boolean compare2DArray(int[] num1, int[][] num2, int start, int end){
        for(int x=start; x<end; x++)
            if(!compareArray(num1, num2[x]))
                return false;
        return true;        
    }

    //Return TRUE if arrays are COMPLETELY different 
    public static boolean compareArray(int[] num1, int[] num2){
        if(num1.length != num2.length)
            return false;
        for(int x=0; x<num1.length; x++)
            if(num1[x] == num2[x])
                return false;
        return true;        
    }

    public static void print(int[][] num){
        for(int x=0; x<num.length; x++){
            for(int y=0; y<num[0].length; y++)
                System.out.print(num[x][y] + " ");
            System.out.println(""); 
        }                           
    }
}

这是通过蛮力方法完成的。如果你想优雅地做到这一点，那么如果我们递归地执行它会更有效，所以没有浪费不必要的循环。

在二维数组中生成唯一的行和列

3 个答案: