生成一定範圍內沒有重複的隨機數

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

那麼，你可以存儲你的號碼一個ArrayList<>。每次您生成一個隨機數時，請查看ArrayList<>是否包含該數字。如果是，則生成另一個號碼並重復該過程。

更好的是，使用Set <>。

Answer 2

要獲得數爲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 3

以產生範圍內的隨機數的公式是：

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 4

生成和存儲唯一編號的最佳可能和最有效的方法是創建一個包含您的數據的HashSet。生成數字，然後嘗試將其添加到HashSet。如果add方法返回false，則表示該數字已經存在於該集合中，因此會重新生成一個數字。 在ArrayList上使用此方法的優點是，使用contains（）方法（來自ArrayList）的時間複雜度爲O（n），這會導致時間複雜度爲O（n） - 效率隨着大小的增加而降低。

Answer 5

創建一個列表，如果在範圍內的所有號碼，然後改組列表：

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

您也可以使用隨機數生成，以填補HashSet的一個固定的範圍。

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每次測試兩次。