java

Question

我有一个二维数组，其中一些索引为空，一些索引有值。我想要 select 一个包含 null 的随机索引。

例子

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

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

感谢回复

Answer 1

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

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 计数中获取随机数，然后迭代二维数组并选择具有随机位置的零数。

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;
        }
      }

这并不是真正正确的方法，如果可以的话，您不应在设计中使用空值或零作为空值，最好考虑另一种将值保存在二维数组中的解决方案。你真的需要那里的空值或零值吗？为什么你需要 return 随机空位置？

Answer 2

或者您可以试试这个：将“0”的索引作为 key/value 放在地图上，然后：

   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 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] + ")");

该解决方案基于很容易select一维数组中的随机值。因此，作为第一步，所有属于值为 0 的元素的索引都收集在 ArrayList 对象中，然后此 ArrayList 对象中的随机元素的 select 结果是搜索到的索引。

Answer 4

根据你的问题，我了解到你想 select 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 流解决这个问题：

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

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

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

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

接下来您需要获取具有键值（在本例中为索引值）等值的流。这对于流来说非常困难，也许有一个更简单的解决方案，但我创建了一个 KeyValue class 并自动增加索引：

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 - 二维数组查找随机空值

java - 2D array find random null value

arrays

loops

find