For 循环二维数组

Question

在这个程序中，我想用三个“O”替换随机位置的三个“N”。我尝试使用 forloop 来实现这一点，但是，我得到的“O”的数量是不一致的。我不确定哪个部分出了问题...

static char grid[][];
public static void Board()
{
    Random rn = new Random();
    grid = new char [3][3];
    for(int row = 0; row<grid.length; row++)
    {
        for(int col = 0; col<grid.length; col++)
        {
        grid[row][col] = 'N';     
            for(int i = 0; i<3; i++)
            {
            grid[rn.nextInt(3)][rn.nextInt(3)] = 'O';  
            }
        System.out.print(grid[row][col]);   
        }
        System.out.println();
    }       
}

Answer 1

你需要分开你的循环。

先用Ns初始化数组，然后替换3个Ns：

for(int row = 0; row<grid.length; row++) {
    for(int col = 0; col<grid[row].length; col++) {
        grid[row][col] = 'N'; 
    }
}
for(int i = 0; i<3; i++) {
    grid[rn.nextInt(3)][rn.nextInt(3)] = 'O';  
}

在内部初始化循环中运行 for(int i = 0; i<3; i++) 会导致 3 个随机单元格被分配 O 3x3 次，这些单元格稍后可以被 N 覆盖，因为您是在初始化完成之前执行此操作。

您还应该注意，grid[rn.nextInt(3)][rn.nextInt(3)] = 'O' 分配的单元格可能不是 3 个唯一的单元格，因此您最终可能仍然少于 3 个 Os。

您可以用 while 循环替换第二个循环，以确保恰好替换了 3 个单元格：

int i = 0;
while(i < 3) {
    int x = rn.nextInt(3);
    int y = rn.nextInt(3);
    if (grid[x][y] != 'O') {
        grid[x][y] = 'O';
        i++;
    }  
}

Answer 2

有时一点点抽象会让事情变得更容易。

为什么在你的循环中随机出现一些东西？你的约束是你希望九个数组索引中的三个是“不同的。因此：不要迭代数组并在那里调用随机函数。

只需在 (0,8) 范围内创建随机数，直到获得三个不同的值；然后更新数组中的相应索引。

你看，棘手的部分大约是正好三个；这可以通过如下代码实现：

Set<Integer> randomIndexesToChange = new HashSet<>();
while (randomIndexesToChange.size() < 3) {
 randomIndexesToChange.put( ... another random number from (0, 8) );
}

或者像 RealSceptic 建议的那样，你创建一个集合对象，它只包含从 0 到 8 的所有索引；然后你使用随机播放；然后选择前三个：

List<Integer> allIndexes = Arrays.asList(0, 1, ...
Collections.shuffle(allIndexes);
// now allIndexes is in random order
// so allIndexes.get(0) gives you the first index that should be O

...

Answer 3

另一种用 3 个随机 Os 填充网格的方法是在初始化时立即执行：

int numOs = 3; 
for(int row = 0; row<grid.length; row++) {
  for(int col = 0; col<grid[row].length; col++) {
    if( numOs > 0 && randomConditionForO() ) {
       grid[row][col] = 'O'; 
       numOs--;
    } else {
       grid[row][col] = 'N';
    }
  }
}

randomConditionForO() 可以是 rn.nextInt() % 2 == 0 等任何东西。如果你想提供设置 O 的概率，比如说 25%，你可以使用类似 rn.nextInt(100) < 25 或 rn.nextFloat() < 0.25f 的东西。

然而，这里的问题是，由于条件的随机性，您可能会得到少于 3 个 Os，因此您可能想要解决这个问题。一种方法可能是同时提供 N 的计数并相应地增加 O 的概率。

例子：

int numOs = 3;
int numNs = gridSize - numOs; //gridSize would be 3x3 = 9 in your example 
for(int row = 0; row<grid.length; row++) {
  for(int col = 0; col<grid[row].length; col++) {
    if( numOs > 0 && rn.nextInt(numNs + 1) < numOs ) {
       grid[row][col] = 'O'; 
       numOs--;
    } else {
       grid[row][col] = 'N';
       numNs--;
    }
  }
}

这里rn.nextInt(numNs + 1) < numOs 意味着选择 O 的概率随着每个选择的 N 增加而随着每个选择的 O 减少。因为 nextInt(bound) 将返回一个介于 0（包括）和 bound（不包括）之间的整数，我们需要传入numNs + 1，这样如果没有更多可用的N，我们使用绑定的1，因为它是独占的，所以我们总是得到0，只要有可用的O，它就会小于numOs（因此得到100 % 概率）。

Answer 4

基于@GhostCats 答案：

static char grid[][];
public static void Board()
{
    int width=3, height=3;

    // create new array filled with 'N'
    grid = new char [width][height];
    for(char[] col: grid)
        Arrays.fill(col, 'N');

    // create list of all possible indexes
    List<Integer> index = IntStream.range(0,width*height).boxed()
                                     .collect(Collectors.asList());
    Collections.shuffle(index);

    // replace first three indexes with 'O'
    for(int i=0; i<3; i++)
        grid[index.get(i)/width][index.get(i)%width] = 'O';    
}

需要 Java 8。