0

我为宾果游戏创建了这个静态方法。

public static void bingoCard(){

    int [][]card = new int [5][5];
    ArrayList<Integer> alreadyUsed = new ArrayList<Integer>();
    boolean valid = false;

    // First row
    for(int row = 0; row < card.length; row++){
        int tmp = 0;
        while(!valid){
            tmp = (int)(Math.random()*15)+1;
            if(!alreadyUsed.contains(tmp)){
                valid = true;
                alreadyUsed.add(tmp);
            }
        }
        card[row][0] = tmp;
        valid = false;
    }

    // Second row
    for(int row = 0; row < card.length; row++){
        int tmp = 0;
        while(!valid){
            tmp = (int)(Math.random()*15)+1;
            if(!alreadyUsed.contains(tmp)){
                valid = true;
                alreadyUsed.add(tmp);
            }
        }
        card[row][1] = tmp;
        valid = false;
    }

    // Third row
    for(int row = 0; row < card.length; row++){
        int tmp = 0;
        while(!valid){
            tmp = (int)(Math.random()*15)+1;
            if(!alreadyUsed.contains(tmp)){
                valid = true;
                alreadyUsed.add(tmp);
            }
        }
        card[row][2] = tmp;
        valid = false;
    }

    card[2][2] = 0; // The 3rd matrix to the left and right is a 0.

    // Fourth row
    for(int row = 0; row < card.length; row++){
        int tmp = 0;
        while(!valid){
            tmp = (int)(Math.random()*15)+1;
            if(!alreadyUsed.contains(tmp)){
                valid = true;
                alreadyUsed.add(tmp);
            }
        }
        card[row][3] = tmp;
        valid = false;
    }

    // Fifth row
    for(int row = 0; row < card.length; row++){
        int tmp = 0;
        while(!valid){
            tmp = (int)(Math.random()*15)+1;
            if(!alreadyUsed.contains(tmp)){
                valid = true;
                alreadyUsed.add(tmp);
            }
        }
        card[row][4] = tmp;
        valid = false;
    }

    // Creates an array to make title

    String title[] = {"B","I","N","G","O"};
    for(int i = 0; i < title.length;i++){
        System.out.print(title[i] + "\t");
    }

    System.out.println();

    for(int row = 0; row < card.length; row++){
        for(int col = 0; col < card[row].length; col++){
            System.out.print(card[row][col] + "\t");
        }
        System.out.println();
    }
}

在输出中，这段代码输出到这个控制台宾果卡： http: //puu.sh/487mz/939c8d7a59.png

我的主要问题是重复数字。我有兴趣知道如何摆脱 5x5 数组中的重复数字。谢谢！

第二次编辑：我也有兴趣让游戏自己玩。意思是，它会提取随机数并对应数字是否在板上。如果满足 BINGO 条件的条件，则执行某些操作。有人对此有什么建议吗？

4

8 回答 8

3

当我编写 BINGO 板时，我创建了一个包含所有可能唯一值的 ArrayList，然后调用Collections.shuffle( mylist)它会随机重新排序这些值。然后你可以遍历列表来填充你的矩阵。

只要确保为您制作的每个新棋盘重新洗牌

于 2013-08-22T15:27:48.217 回答
1

一种解决方案是使用另一种数据结构来保存所有已生成并添加到表示卡片的二维数组中的随机数。

创建随机数后，您可以检查该数字是否已存在于数据结构中。如果确实如此，则生成一个不同的数字。如果没有，则将其添加到卡和数据结构中。

在这里使用 ArrayList 会很好，因为它已经为您编写了一个不错的 contains 方法。这是一个例子。

import java.util.ArrayList;

int [][]card = new int [5][5];
ArrayList<Integer> alreadyUsed = new ArrayList<Integer>();
boolean valid = false;

for(int row = 0; row < card.length; row++){
    int tmp = 0;
    while(!valid){
        tmp = (int)(Math.random()*15)+1;
        if(!alreadyUsed.contains(tmp)){
            valid = true;
            alreadyUsed.add(tmp);
        }
    }
    card[row][0]= tmp;
    valid = false;
}

此外，在所有嵌套的 for 循环中，您从不使用变量 col。您可以简单地摆脱每个嵌套循环中的内部 for 循环。

for(int row=0; row < card.length; row++){
    for(int col=0; col < card[row].length; col++){
        card[row][0]=(int)(Math.random()*15)+1;
    }
}

可以改为

for(int row=0; row < card.length; row++){
    card[row][0]=(int)(Math.random()*15)+1;
}

也card[2][2]=0;只需要发生一次，在这里你要设置多次。这可以从

for(int row=0;row<card.length;row++){
    for(int col=0;col<card[row].length;col++){
        card[row][2]=(int)(Math.random()*15)+31;
        card[2][2]=0;
    }
}

到

for(int row=0;row<card.length;row++){
    card[row][2]=(int)(Math.random()*15)+31;
}

card[2][2]=0;
于 2013-08-22T15:26:47.117 回答
0

不要使用这样的随机函数 - 相反，用所有潜在的随机数填充一个数组或 ArrayList。然后从中随机删除数字 - 这将确保您无法获得重复的数字，因为每个数字中只有一个存在。

于 2013-08-22T15:25:02.810 回答
0

创建一个代表宾果桌的类。用 0 到 99 的数字填充一个数组。生成新表时，打乱这个数组并按顺序从中提取数字。

public class BingoBoard{
    Integer[] randomNumbers;
    int[][] grid = new int[5][5];
    public BingoBoard(){
        randomNumbers = new Integer[100];
        for(int i=0;i<randomNumbers.length;i++)
            randomNumbers[i] = i;
        populateCard();
    }

    public void set(int x, int y, int value){
        grid[x][y] = value;
    }

    public void populateCard(){
        //randomize the numbers you'll pull from.
        //Array.asList will be backed by randomNumbers, so this works.
        Collections.shuffle(Arrays.asList(randomNumbers));
        for(int x=0;x<5;x++){
            for(int y=0;y<5;y++){
                int num = randomNumbers[x+y*5];
                set(x,y,num);
            }
        }
    }
}

这是用随机值填充网格的一种非常有效的方法。

于 2013-08-22T15:26:51.097 回答
0

您可以保留生成的已访问随机数列表并在将此数字添加到游戏之前进行检查，如下所示

boolean[] visited = new boolean[100];
for(int i = 0; i < 100; i ++) visited[i] = false;

并在每个循环内使用这个

for(int row=0; row < card.length; row++){
int num = (int)(Math.random()*15)+1;
    if visited[num]{
        row --;
        continue;
    }
    visited[num] = true;
    card[row][0] = num;
}
于 2013-08-22T15:28:29.373 回答
0

ArrayList用从1to的数字填充 a N，然后使用 ajava.util.Random选择/删除数字（不需要随机播放）：

ArrayList<Integer> card = new ArrayList<Integer>(N);
for (int i = 0; i < N; i++)
   card.add(i + 1);

Random random = Random();
int pick = card.remove(random.nextInt(card.size()));

您可以轻松地将其包装到一个类中来组织事物。

于 2013-08-22T15:32:05.873 回答
0

这是我实施它的方式。

    int[][] board = new int[5][5];
    ArrayList<Integer> list = new ArrayList<Integer>();
    int number = 0;
    int index = 0;
    int increment = 1;
    int col = 0;

    //Run a loop until you're at your last column.
    while (col < board.length) {

        //Ensure uniqueness of your numbers
        while (list.size() < 5) {
            number = (int) (Math.random() * 15) + increment;
            if (!list.contains(number))
                list.add(number);
        }

        //Add elements to the array.
        for (int i : list)
            board[index++][col] = i;

        //Set values for the next iteration.
        index = 0;
        increment += 15;
        list.clear();
        col++;
    }
    board[2][2] = 0;

    //Print the board.
    System.out.println("B\tI\tN\tG\tO\n");
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
            System.out.print(board[i][j] + "\t");
        System.out.println("");
    }

结果：

B   I   N   G   O

9   29  34  59  62  
8   23  44  52  64  
7   16  0   53  63  
1   19  33  46  71  
15  17  41  58  61
于 2013-08-22T15:59:46.157 回答
0

很简单，就用这个。

    int element = 5;
    List<Integer> numbers = new ArrayList<Integer>(element);

    for (int i = 1; i <= element * element; i++)
        numbers.add(i);

     Collections.shuffle(numbers);

    int[][] numArr = new int[element][element];

    for (int i = 0, counter = 0; i < element; i++)
        for (int j = 0; j < element; j++, counter++)
            numArr[i][j] = numbers.get(counter);
    
    for (int i = 0; i < numArr.length; i++) {
        for (int j = 0; j < numArr[i].length; j++) {
            System.out.printf("%-5d", numArr[i][j]);
        }
        System.out.println();
    }
于 2021-03-27T10:02:14.073 回答