限制重复的随机数

Question

我只想知道如何限制随机数出现的次数。我已经生成了 1 到 10 的随机数，并且想限制每个数字出现 4 次。

myArray[i][j] = rand.nextInt(11);

for (int i=0; i < myArray.length; i++) {
   for (int j=0; j < myArray[i].length; j++) {
       myArray[i][j] = rand.nextInt(11);
       System.out.print(" " + myArray[i][j]);

上面的代码创建了随机数。只是想限制他们。

Answer 1

由于您被限制为 10 * 4 = 40 个数字，您可以使用列表并随机化索引：

List<Integer> numbers = new ArrayList<Integer>();
for (int i = 1; i < 11; ++i) {
   for (int j = 0; j < 4; ++j) 
      numbers.add(i);
}

然后当你分配一个随机数时：

int i = rand.nextInt(numbers.size());
myArray[i][j] = numbers.get(i);
numbers.remove(i);

这假设您的二维不会包含超过 40 个数字

Answer 2

将生成的 int 的计数存储在数组、Map 或任何东西中怎么样？

Map<Integer, Integer> randomCounts = new HashMap<Integer, Integer>(); 
... your for loops
myArray[i][j] = rand.nextInt(11);
if (randomCounts.containsKey(myArray[i][j])) { 
   randomCounts.put(myArray[i][j],randomCounts.get(myArray[i][j])+1);
} else {
   randomCounts.put(myArray[i][j],1);
}

如果您想检查它们，只需遍历您的地图，然后瞧。 :)

Answer 3

我的解决方案将结果存储在 arrayList 中：

public class Example {

/**
 * @param args the command line arguments
 */
public static void main(String[] args) {
    final int range = 10;
    int[] numbers = new int[range + 1];
    int sum = 0;
    final int noOfOccurances = 4;
    final int size = range * noOfOccurances;
    Arrays.fill(numbers, 0);
    Random generator = new Random();
    List<Integer> numbersArray = new ArrayList<>();
    while (sum != size) {
        int randomNumber = generator.nextInt(range) + 1;
        if (numbers[randomNumber] != noOfOccurances) {
            numbers[randomNumber]++;
            sum++;
            numbersArray.add(randomNumber);
        }
    }
    System.out.println(numbersArray);
}
}

Answer 4

您可以创建一个方法来检查生成的数字在数组中是否存在超过 4 次，如果存在则创建一个新的随机数。它应该是这样的：

import java.util.Random;

public class rndNumberGenerator {

    public static void main (String[] args) {

        int[][] myArray = new int[2][5];
        Random rand = new Random();
        int randomNumber;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                do {
                    randomNumber = rand.nextInt(11);
                } while(overMax(myArray, randomNumber) == true);

                myArray[i][j] = randomNumber;

                System.out.print(" " + myArray[i][j]);

            }
        }

    }

    public static boolean overMax(int[][] array, int number) {

        int max = 4;
        int count = 0;

        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 5; j++) {

                if (array[i][j] == number) {
                    count++;
                }

            }
        }

        if (count >= max)
            return true;
        else
            return false;

    }
}

希望对您有所帮助，如果您有任何其他问题，请随时提出。

Answer 5

我接受 pshemek 的建议（投赞成票）：我使用 ArrayList 而不是 Set，因为它不能包含重复的数字，而且您不必进行控制。

一个实现：copy{right, left} 属于 pshemek，我只是扩展了这个想法：)

public class Example {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int[] numbers = new int[11];
        int sum = 0;
        final int range = 10;
        final int noOfOccurances = 4;
        Arrays.fill(numbers, 0);
        Random generator = new Random();
        Set<Integer> numbersArray = new TreeSet<Integer>();
        while (sum != range * noOfOccurances) {
            int randomNumber = generator.nextInt(range) + 1;
            sum++;//correction for first comment
            numbersArray.add(randomNumber); // randomNumber will never be twice: a Set cointains ever one and only one instance of an determinated element
        }
        System.out.println(numbersArray);
    }

  }//end class

Answer 6

你可以自己写：

public static class CountedRandom {
    // My rng.
    Random rand = new Random();
    // Keeps track of the counts so far.
    Map<Integer, Integer> counts = new HashMap<Integer, Integer>();
    // The limit I must apply.
    final int limit;

    public CountedRandom(int limit) {
        this.limit = limit;
    }

    public int nextInt(int l) {
        int r;
        do {
            // Keep getting a new number until we hit one that has'n been overused.
            r = rand.nextInt(l);
        } while (count(r) >= limit);
        return r;
    }

    private int count(int r) {
        // How many times have we seen this one so far.
        Integer counted = counts.get(r);
        if ( counted == null ) {
            // Never!
            counted = new Integer(0);
        }
        // Remember the new value.
        counts.put(r, counted + 1);
        // Returns 0 first time around.
        return counted;
    }
}

public void test() {
    CountedRandom cr = new CountedRandom(4);
    for ( int i = 0; i < 50; i++ ) {
        System.out.print(cr.nextInt(4)+",");
    }
    System.out.println();
}

请注意，如果您要求的数字太小，这个会挂起（就像我在测试中所做的那样）。

打印

2,0,1,2,1,1,3,3,0,3,0,2,2,0,1,3,

然后挂起。