Question

我必须创建一个Java程序，它创建一个包含5到55之间随机值的五个元素的数组，这些值必须与数组中的前一个不同。我试过这种方式，但实际上似乎没有工作

import java.util.Random;

public class RandomArray {
    public static void main(String args[]) {
        Random x = new Random(System.nanoTime());
        int i, y, c = 0;
        int v[] = new int[5];
        for (i = 0; i < 5; i++) {
            c++;
            v[i] = x.nextInt(56);
            for (y = 0; y < c; y++) {
                while (v[y] == v[i]||v[i] == 0) v[i] = x.nextInt(56);
            }
        }
        for (int z : v) System.out.println(z);
    }
}

Answer 1

我试图了解你的代码是做什么或不做什么，因为我不认为这是向Java中的集合添加5个唯一数字的最佳方法。你需要独特的价值就能很好地融入一套。

这里的一个选项是使用一个集来存储您的随机数，并继续添加数字，直到该集的大小达到5：

Random x = new Random(System.nanoTime());
Set<Integer> rNum = new HashSet<>();

while (rNum.size() < 5) {
    rNum.add(x.nextInt(56));
}

int v[] = new int[5];
int c = 0;
for (int num : rNum) {
    v[c] = num;
    ++c;
}

Demo

Answer 2

您的代码的问题在于您将当前值与自身进行比较，因此无限循环。这更好地表达了你的意图：

    Random x = new Random(System.nanoTime());
    int v[] = new int[5];
    for (int i = 0; i < 5; i++) {
        v[i] = 1 + x.nextInt(55);
        for (int y = 0; y < i; y++) {
            while (v[y] == v[i])
                v[i] = 1 + x.nextInt(55);
        }
    }
    for (int z : v)
        System.out.println(z);

Answer 3

我们可以使用Fisher-Yates shuffle生成长度为n <= 55的序列，保证成对不同。为此，我们只需要从混洗数组中返回最后的n个元素。但这会浪费大量资源：如果我们只需要五个随机值，为什么要整个阵列洗牌呢？只是改变了最后五个职位！

import java.util.Arrays;
import java.util.Random;

public class RandomArray {
    private static final int[] range = new int[55];
    private static final Random rng = new Random();

    static {
        for (int i = 0; i < range.length; ++i) {
            range[i] = i + 1;
        }
    }

    public static void main(String args[]) {
        for (int i = 0; i < 10; ++i) {
            System.out.println(Arrays.toString(getNRandom(5)));
        }
    }

    /* partial Fisher-Yates shuffle for the last n elements */
    public static int[] getNRandom(final int n) {
        int limit = range.length - n;
        for (int i = range.length - 1; i >= limit && i > 0; --i) {
            int swapIdx = rng.nextInt(i);
            int tmp = range[swapIdx];
            range[swapIdx] = range[i];
            range[i] = tmp;
        }
        return Arrays.copyOfRange(range, limit, range.length);
    }
}

Demo (rextester.com)

我们继续使用相同的源数组range，即使它已经混合了一点点。这并没有改变这种可能性，因为Fisher-Yates shuffle保证了一个均匀分布的数组（即，在一次洗牌之后每个数字位于i位置的概率是1/n，其中n是数组大小。

此算法具有以下属性：

它可以证明终止。 forty-two和Tim Biegelstein的答案都不能保证终止¹。
它使用所需的最小随机性，即当生成长度为n的随机序列时，它始终仅对rng.nextInt(...)使用n次调用。如果需要长度为range.length的随机序列，则只需range.length - 1个随机调用。

_{¹尽管两种算法很可能终止。}

Answer 4

您可以使用此

Random x = new Random(System.nanoTime());
int i, y, c = 0;
int v[] = new int[5];
 for (i = 0; i < 5; i++) {
  c++;
  v[i] = x.nextInt(56);
  for (y = 0; y < c; y++) {
   //SOLUTION
   int aux = v[i];
   while (aux == v[y]||v[y] == 0) v[y] = x.nextInt(56);
   //
  }
}
for (int z : v) System.out.println(z);

在oter case中你有一个无限循环，因为你一直在比较，因为v [0] == v [0]一直是真的

随机数组生成器具有不同的值

4 个答案:

Demo