Question

我有一个2D数组，其中一些索引为null，一些索引具有值。我想选择一个包含null的随机索引。

例如

5,0,0,5,0
4,0,0,4,7
9,0,4,8,9
0,8,4,0,1

我想从这些中选择随机索引

Answer 1

或者你可以试试这个：把＆＃39; 0＆＃39;的索引作为地图上的键/值，然后：

   Random   random = new Random();
   Map x= new HashMap();
    x.put(0,1);

...

List keys      = new ArrayList<Integer>(x.keySet());
Integer randomX = keys.get( random.nextInt(keys.size()) );
Integer value  = x.get(randomX );

Answer 2

你可以使用简单的技巧 - 只需将零值映射到数组。或者更好的解决方案只计算零值的数量，因此，您应该遍历2D数组并比较值 - 如果您想要找到零，那么它应该是：

int count = 0;
for(int i=0;i< array.length;i++)
  for(int j=0;j< array[i].length;j++)
    if(array[i][j] == 0)
      count++;

之后，您可以从间隔1计数中获取随机数，然后迭代2D数组并选择随机位置的零数。

int randomPosition = (int )(Math.random() * (count-1));
int now=0;
if(randomPosition > -1)
  for(int i=0;i< array.length;i++)
    for(int j=0;j< array[i].length;j++)
      if(array[i][j]==0){
         now++;
         if(now == randomPosition){
         rowPosition = i;
         columnPosition = j;
        }
      }

这实际上并不是正确的方法，如果可以，你不应该在设计中使用空值 - 或零作为空值，更好地考虑另一种在2D数组中保存值的解决方案。你真的需要空值或零值吗？为什么你需要返回随机空位？

Answer 3

//Init array
int array[][] = { { 5, 0, 0, 5, 0 }, { 4, 0, 0, 4, 7 },
                  { 9, 0, 4, 8, 9 }, { 0, 8, 4, 0, 1 } };

//Init vector for indices of elements with 0 value
ArrayList<int[]> indices = new ArrayList<int[]>();

//Find indices of element with 0 value
for (int i = 0; i < array.length; i++)
{
    for (int j = 0; j < array[i].length; j++)
    {
        if (array[i][j] == 0)
        {
            indices.add(new int[] { i, j });
        }
    }
}

//Just print the possible candidates
for (int[] index : indices)
{
   System.out.println("Index = (" + index[0] + ", " + index[1] + ")");
}
System.out.println();

//Select a random index and print the result
Random rand = new Random();
int ri = rand.nextInt(indices.size());
int[] index = indices.get(ri);

System.out.println("Selected index = (" + index[0] + ", " + index[1] + ")");

解决方案基于在1D阵列中轻松选择随机值。因此，作为第一步，所有索引属于值为0的元素都收集在ArrayList对象中，然后选择此ArrayList对象中的随机元素将产生搜索到的索引。

Answer 4

根据您的问题，我了解您要在Java中的二维数组中选择一个随机元素（包含0）。首先，您应该了解，因为大多数数字都是基于价值的，0 != null。这有助于使您的问题更加清晰。

现在，您首先必须遍历数组以确定哪些元素为0，记录每个0元素所在的位置。然后，生成一个随机数以确定应该选择哪个0元素：

//determines amt of 0s in array
ArrayList<ArrayList<int>> keys = new ArrayList<>();
for (int i = 0; i < array.length; i++) {
    ArrayList<int> inner = new ArrayList<int>();
    for (int j = 0; j < array[i].length; j++) {
        if (i == 0) { inner.add(j); }
    }
    keys.add(inner);
}

Random r = new Random();
//TODO: generate random number, determine which element to pick

希望这有帮助。

Answer 5

这个解决方案可能有点长，但有效。我试图用java流解决这个问题：

首先，您需要将2D数组转换为简单的IntStream。最简单的方法可能是：

Arrays.stream(arr).flatMapToInt(intArr -> Arrays.stream(intArr));

我们的流现在看起来像这样：

{5,0,0,0,5,0,4,0,0,4,7,9...}

接下来，您需要使用键值（在本例中为index-value）获取流。这对于流来说非常困难，并且可能有一个更简单的解决方案，但我创建了一个带有索引自动递增的KeyValue类：

class KeyValue {
    int index;
    int value;
    static int nextIndex;

    public KeyValue(int v) {
        this.index = nextIndex;
        nextIndex++;
        this.value = v;
    }
    public static void restart() {
        nextIndex = 0;
    }
}

现在很容易将我们的流转换为索引值项。拨打：

.mapToObj(KeyValue::new)

现在我们的流看起来像这样：

{KeyValue[i=0 v=5], KeyValue[i=1 v=0], KeyValue[i=2 v=0], KeyValue[i=3 v=0]...}

现在过滤零并将流收集到数组：

.filter(kv -> kv.value == 0).toArray(KeyValue[]::new);

创建数组的整个代码是：

KeyValue[] zeros = Arrays
                .stream(arr)
                .flatMapToInt(intArr -> Arrays.stream(intArr))
                .mapToObj(KeyValue::new)
                .filter(k -> k.value == 0)
                .toArray(KeyValue[]::new);

现在从阵列中获取随机值非常容易：

int ourResult = zeros[random.nextInt(zeros.length)].index;

整个代码如下所示：

int[][] arr = new int[][]
            {
                    {5, 0, 0, 5, 0},
                    {4, 0, 0, 4, 7},
                    {9, 0, 4, 8, 9},
                    {0, 8, 4, 0, 1}
            };
    Random random = new Random();
    KeyValue.restart();
    KeyValue[] zeros = Arrays
            .stream(arr)
            .flatMapToInt(intArr -> Arrays.stream(intArr))
            .mapToObj(KeyValue::new)
            .filter(k -> k.value == 0)
            .toArray(KeyValue[]::new);
    int ourResult = zeros[random.nextInt(zeros.length)].index;

快乐编码：）

Answer 6

我一直在寻找这个答案，并在处理过程中提出这个问题：

// object to hold some info
class Point {
    // public fields fine for Point object
    public int i, j, count;
    // constructor
    public Point (int i, int j) {
        this.i = i;
        this.j = j;
        this.count = 0;
    }

    public String toString() {
        return i + " , " + j;
    }
}
int[][] grid;

// processing needs to init grid in setup
void setup() {
    // init grid
    grid = new int[][] {
    {5,1,2},
    {3,4,4},
    {4,0,1}
    };
println(getRandomZero(new Point(0,0)));
}

// recursion try for 300 random samples
Point getRandomZero(Point e) {
    // base case
    Point p = e;
    if (grid[p.i][p.j] != 0 && p.i < grid.length && p.j < grid[p.i].length) {
        p.i = randomInt(0,grid.length);
        p.j = randomInt(0,grid[p.i].length);
        p.count++;
// if can't find it in 300 tries return null (probably not any empties)
        if (p.count > 300) return null;
        p = getRandomZero(p);
    }
    return p;
}
// use Random obj = new Random() for Java
int randomInt(int low, int high) {
    float random = random(1);
    return (int) ((high-low)*random)+low;
}

明天我会专门为Java编辑。

java - 2D数组查找随机空值

6 个答案: