带有数组的 Java Math.random

Question

我正在尝试使用二维数组中随机坐标中的字符（例如 A）填充 5 x 5 的二维数组。当我使用我的嵌套 for 循环时，我想制作 2d 数组的坐标，其中我的 char 将是随机的。所以假设我要求 40% 的 A，在 5 x 5 中我应该得到 10 个 A，但我得到 8 个。当我运行它时，它有时不会显示我想要的 A 的百分比。它只会像 6 一样打印出来。这是因为当 if 语句中的 row 和 col 是随机的，for 循环中的 row 和 col 也是随机的吗？这就是为什么 char 有时填充的数量少于要求的数量，因为如果数字随机化 2d 数组的长度为 5，for 循环就会停止？

此外，当它打印出 10 个字符时，有时它们会超过 5 乘 5。例如，第 2 行中的 2 As 和第 3 行中的 7 和第 3 行中的 1。这是为什么呢？

public static void grid(char[][] arr, int percentofchar)
{

  double charx = 0.0;

  double totalpercentchar = 0;
  totalpercentchar = (double) percentofchar / 100;

  cellx = totalpercentchar * (arr.length * arr.length);

  for (int row = 0; row < arr.length; row++)
  {
    for (int col = 0; col < arr[row].length; col++)
    {
      if (charx > 0)
      {
        row = (int) (Math.random() * arr.length);
        col = (int) (Math.random() * arr.length);
        charx--;
        arr[row][col] = 'A';
        System.out.print(arr[row][col] + "  ");
      }
    }
    System.out.println();
  }
}

Answer 1

你的代码应该是这样的

public static void grid(char[][] array, int percentOfChar)
  {
    int charsToPlace = (int) (percentOfChar * array.length * array.length / 100.0);
    while (charsToPlace > 0)
    {
        int row = (int) (Math.random() * array.length);
        int column = (int) (Math.random() * array.length);
        if (array[row][column] != 'A');
        {
            array[row][column] = 'A';
            charsToPlace--;
            System.out.print(array[row][column] + "  ");
        }          
    }
    System.out.println();
  }

如果您只是想在随机位置插入一个字符，则无需遍历数组并使用嵌套循环。

还有

这是因为当if语句中的row和col是 随机化，那么 for 循环中的 row 和 col 是吗？这就是为什么 char 有时会填充的原因 少于要求，因为如果数字，for循环停止 随机化二维数组的长度为 5？此外，当它打印出 10 个字符时， 有时他们会超过 5 乘 5。一个例子是 2 如 第 2 行和第 7 行，第 3 行第 1 行。这是为什么呢？

或多或少。您将行和列随机化，但这样做可能会导致通过数组的迭代过早结束。作为最坏的情况，请考虑如果您第一次输入if 语句时随机函数将这4 个值分配给row 和col 会发生什么情况。一般来说，你确定grid方法结束时charx总是等于0吗？

---

注意事项

正如马特在下面的 cmets 中指出的，这个方法没有检查数组；因此，它假设数组始终是一个正方形（即行 X 列 = n X n）。 如果您想强制使用方形数组，您可能需要创建一个包装类，例如

class IntegerSquareArray
{
    public final int length;
    int[][] array;
    IntegerSquareArray(int length)
    {
        this.length = length;
        this.array = new int[length][length];
    }

    public int getValue(int row, int column)
    {
        if (row < length && column < length)
            return array[row][column];
        throw new IllegalArgumentException();
    }

    public void setValue(int row, int column, int value)
    {
        if (row < length && column < length)
            array[row][column] = value;
        else throw new IllegalArgumentException();
    }
}

然后，您可以简单地将grid 代码更改为

public static void grid3(IntegerSquareArray integerSquareArray,
    int percentOfChar)
{
    int charsToPlace = (int) (percentOfChar * integerSquareArray.length
        * integerSquareArray.length / 100.0);
    while (charsToPlace > 0)
    {
        int row = (int) (Math.random() * integerSquareArray.length);
        int column = (int) (Math.random() * integerSquareArray.length);
        if (integerSquareArray.getValue(row, column) != 'A')
        {
            integerSquareArray.setValue(row, column, 'A');
            charsToPlace--;
            System.out.print(integerSquareArray.getValue(row, column) + "  ");
        }
    }
    System.out.println();
}

Answer 2

为了完整起见，这是我在 tigerjack's 解决方案下的 cmets 中提到的内容。根据 cmets，我会为网格使用包装器，而不是原始多维数组。

我的随机放置解决方案稍微复杂一些，但对于更高的放置百分比（即，如果您尝试填充超过 90% 的单元格）会更有效，并且始终会填充精确指定的位置字符的百分比。

如果需要，您可以在percentOfCellsToSet 较低时使用tigerjack 的方法进行随机放置，而当percentOfCellsToSet 较高时使用if 方法中的if 语句使用此方法。

这是我使用随机列表方法的完整可编译示例：

import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyGrid
{
    private int width;
    private int height;
    private char[][] grid;

    public MyGrid(int width, int height, char defaultCell)
    {
        this.width = width;
        this.height = height;        
        grid = new char[height][width];

        // populate grid with defaultCells:
        for(int x=0; x < width; ++x)
        {
            for(int y=0; y < height; ++y)
            {
                grid[y][x] = defaultCell;
            }
        }
    }

    public int getWidth() { return width; }

    public int getHeight() { return height; }

    public char getCell(int x, int y) { return grid[y][x]; }

    public void setCell(int x, int y, char cellValue) { grid[y][x] = cellValue; }

    public void setRandomCells(char cellValue, float percentOfCellsToSet)
    {
        // determine the number of cells to set (rounding to nearest int):
        int numCellsToSet = (int)(Math.round((width * height * percentOfCellsToSet) / 100.0));

        // create a list containing all possible cell positions:
        List<Point> listAllCellLocations = new ArrayList<>();
        for(int x=0; x < width; ++x)
        {
            for(int y=0; y < height; ++y)
            {
                listAllCellLocations.add(new Point(x,y));
            }
        }

        // shuffle it
        Collections.shuffle(listAllCellLocations);

        // now set the cells
        for(int i=0; i < numCellsToSet; ++i)
        {
            Point pt = listAllCellLocations.get(i);
            setCell(pt.x, pt.y, cellValue);
        }
    }

    public void debugPrintGrid()
    {
        for(int y=0; y < height; ++y)
        {
            for(int x=0; x < width; ++x)
            {
                System.out.print(getCell(x,y));
            }
            System.out.println();
        }
    }

    public static void main(String[] args) 
    {
        MyGrid myGrid = new MyGrid(10, 10, '0');
        myGrid.setRandomCells('A', 68);
        myGrid.debugPrintGrid();
    }

}

这是main() 方法中代码的示例输出：

AAAA0A0AAA
0AAAAAAAA0
A00A00AA0A
AAAAA0AAA0
AA0A0AAAA0
0A0AAAA0AA
A0AAA0A0AA
A0A00AAAAA
AAA000A0A0
0AA0AAA0A0

希望有人觉得这很有帮助。

Answer 3

您为循环变量分配随机值...现在这可能是不确定的...

基本上，如果第一个 Math.random() 结果为 arr.length - 1 而第二个结果为 arr[arr.length - 1].length -1，则您的嵌套循环将结束。

我严重怀疑这是你想要的。

要控制将多少随机As 放入数组，只需为此使用循环，但不要将随机值分配给循环变量：

int max = arr.length * arr.length * percentofchar / 100;
for (int i = 0; i < max; i++) {
    // Put `A` at a random location
    int row = (int) (Math.random() * arr.length);
    int col = (int) (Math.random() * arr.length);
    arr[row][col] = 'A';
    System.out.print(arr[row][col] + "  ");
}

另请注意，这仍然可能导致A 比百分比表示的要少，因为可能会多次生成相同的随机位置，因此可能会多次将相同的数组元素设置为A。

如果要生成As 的精确计数，如果随机位置已经是A，则必须重试：

int max = arr.length * arr.length * percentofchar / 100;
for (int i = 0; i < max; i++) {
    // Put `A` at a random location
    int row, col;
    do {
        row = (int) (Math.random() * arr.length);
        col = (int) (Math.random() * arr.length);
    } while (arr[row][col] == 'A');
    arr[row][col] = 'A';
    System.out.print(arr[row][col] + "  ");
}

Answer 4

您的代码会随机放置“A”，因此某些“A”可能会放置在同一个位置。

让我们计算看到 10 个“A”作为结果的可能性。

第一个“A”总是空的，所以你会在 100% 处看到 1 个“A” 对于放置第二个“A”，有 1 个位置被“A”占据，24 个空位，因此在放置第二个“A”后您会看到 2 个“A”，占 96%。 （第二个 A 可以放置在第一个“A”放置在 25 (4%) 中的可能性 1 中。 第三，可能性是 (24/25) * (23/25)。 ...在第 4 到第 9 中省略。 对于 10 日，您会在 (24/25)(23/25)(22/25)(21/25)(20/) 中看到 10 个“A” 25)(19/25)(18/25)(17/25)(16/25)。 （数值约为12.4%）

这个计算表明你的代码可能会在结果中显示 10 个“A”，大约每 8 个。