Question

我正在创建一个应用程序，它会生成随机数。所以每次它会产生三个数字num1，num2和num3。这些数字不应重复。例如，如果num1 = 1而不是num2且num3不能等于1.我尝试过这段代码，它会显示三个不同的数字，范围从0到2。它的工作。但是我想生成1-3,2-4,3-5等随机数。那么我怎么能通过使用下面的代码来实现这一点。因为我是新手，所以请帮助我。谢谢。

for(int i=0; i<images.length; i++)
{
        num[i] = (int)(Math.random()*3);

        if (i == 0)
        {
        if(num[i]== 0)
            images[i].setImageResource(R.drawable.zero);
        else if(num[i]==1)
            images[i].setImageResource(R.drawable.one);
        else
            images[i].setImageResource(R.drawable.two);
        }

        else
        {
            while (num[i] ==  num[i-1] || num[i] == num[0] )
                num[i] = (int)(Math.random()*3);


        if(num[i]==0)
            images[i].setImageResource(R.drawable.zero);
        else if(num[i]==1)
            images[i].setImageResource(R.drawable.one);
        else
            images[i].setImageResource(R.drawable.two);

        }
    }

Answer 1

如果范围内的所有数字都创建一个列表，然后随机播放列表：

List<Integer> numbers = new ArrayList<>();
// eg for range 3-5
for (int i = 3; i <= 5; i++)
    numbers.add(i);
Collections.shuffle(numbers);

现在以新的（随机）顺序使用它们。

除非您的范围非常大（数百万），否则这样可以正常工作。

Java8版本：

List<Integer> numbers = IntStream.rangeClosed(3, 5).boxed().collect(Collectors.toList());
Collections.shuffle(numbers);

Answer 2

好吧，你可以将你的号码存储为ArrayList<>。每次生成随机数时，请查看ArrayList<>是否包含该数字。如果是，则生成另一个数字并重复该过程。

更好的是，使用Set <>。

Answer 3

要获得1-3,2-4,3-5等数字，请更改此

num[i] = (int)(Math.random()*3);

到这个

num[i] = rand.nextInt(2) + 1 + i;

在使用之前，您需要导入Random并添加Random rand = new Random();。

Answer 4

在该范围内生成随机数的公式为：

    Random rn = new Random();
    int range = maximum - minimum + 1;
    int randomNum =  rn.nextInt(range) + minimum;

所以在一行中你可以像这样生成

    int num1 = new Random().nextInt(3-1+1) + 1;
    int num2 = new Random().nextInt(4-2+1) + 1;
    int num3 = new Random().nextInt(5-2+1) + 1;

或

    num[i] = new Random.nextInt(range[i]) + 1 + i;

然后你可以用你的逻辑来设置资源。快乐编码：）

Answer 5

生成和存储唯一数字的最佳可能和最有效的方法是创建一个保存数据的HashSet。生成数字，然后尝试将其添加到HashSet。如果add方法返回false，则表示该数字已存在于该集合中，因此重新生成一个数字。使用此方法优于ArrayList的优点是，它具有O（1）的时间复杂度，而使用contains（）方法（来自ArrayList）会导致O（n）的时间复杂度 - 效率随着大小的增加而降低。

Answer 6

int base = (int)Math.random(); System.out.print(base);

int change = ((int)Math.random()) % 3;

if(change == 0) { change++; System.out.print(base + 1); System.out.println(base + 2); }

else { System.out.print(base + 2); System.out.println(base + 1); }

Answer 7

您还可以使用随机数生成来填充固定范围的哈希值。

Answer 8

Integer[] a = new Integer[3];
Random r = new Random();
for (int i = 0; i < a.length; i++) { 
        a[i] = r.nextInt(3-1) + 1;  
}
Collections.shuffle(Arrays.asList(a), r);

Answer 9

我知道它已经很晚了，但可能有助于将来参考。您可以创建自己的自定义Random类：

//Generates random integers without repetition between two given numbers both inclusive
public class Random {
    private int start;
    private int end;
    private Stack<Integer> numbers = new Stack<>();
    public Random(int start, int end){
        this.start = start;
        this.end = end;
    }
    private void loadNumbers(){
         for (int i=start;i<=end;i++){
                numbers.push(i);
            }
         Collections.shuffle(numbers);
    }
    public int nextInt(){
        if (numbers.empty()) loadNumbers();
        return numbers.pop();
    }
}

并使用它：

Random rand = new Random(1,20);
for(int i=0; i<100;i++){
    System.out.print(rand.nextInt()+ " ");
}

Answer 10

减少每次运行的总量，并适当增加结果。

static int[] randomRange(Random random, int cap, int count) {
    assert count < cap && count > 0 && cap > 0;
    int[] output = new int[count];
    // initial placeholder. use 0x7FFFFFFF for convenience is also OK.
    Arrays.fill(output, -1);
    for(int i = 0; i < count; i++) {
        // you only have (cap - i) options left
        int r = random.nextInt(cap - i);
        // iterate through a sorted array
        for(int got : output) {
            // ignore placeholders
            if(got != -1 && got <= r) {
                // the generated random int counts number of not-yet-picked ints
                r++;
            }
        }
        // add to array in a sorted manner
        addToArray(output, r);
    }
    return output;
}

static void addToArray(int[] array, int value) {
    for(int i = 1; i <= array.length; i++) {
        if(i == array.length || array[i] >= value) {
            // shift smaller values one place left
            // this includes -1. If you use 0x7FFFFFFF,
            // you may have to sort the array the other way round.
            System.arraycopy(array, 1, array, 0, i - 1);
            array[i - 1] = value;
            return;
        }
    }
}

此算法的缺点是其输出已排序。当然，也可以跟踪两个数组，一个是排序的（用于增量），另一个是未排序的（用于返回）。

上述代码段分别通过cap = 20, count = 10和cap = 20, count = 20两次进行了测试。

在一定范围内生成无重复的随机数

10 个答案: