生成范围内的随机整数以满足java中的百分位数

Question

I am trying to generate random integers within a range to sample a percentile of that range. For example: for range 1 to 100 I would like to select a random sample of 20%. This would result in 20 integers randomly selected for 100.

This is to solve an extremely complex issue and I will post solutions once I get this and a few bugs worked out. I have not used many math packages in java so I appreciate your assistance.

Thanks!

Answer 1

Put all numbers in a arraylist, then shuffle it. Take only the 20 first element of the arraylist:

ArrayList<Integer> randomNumbers = new ArrayList<Integer>();

for(int i = 0; i < 100; i++){
    randomNumbers.add((int)(Math.random() * 100 + 1));
}

Collections.shuffle(randomNumbers);

//Then the first 20 elements are your sample

Answer 2

If you want 20 random integers between 1 and one hundred, use Math.random() to generate a value between 0 and 0.999... Then, manipulate this value to fit your range.

int[] random = new int[20];
for(int i =0; i< random.length;i++)
{
   random[i] = (int)(Math.random()*100+1); 
}

When you multiply Math.random() by 100, you get a value between 0 and 99.999... To this number you add 1, yielding a value between 1.0 and 100.0. Then, I typecasted the number to an integer by using the (int) typecast. This gives a number between 1 and 100 inclusive. Then, store the values into an array.

Answer 3

If you are willing to go with Java 8, you could use some features of lambdas. Presuming that you aren't keeping 20% of petabytes of data, you could do something like this (number is the number of integers in the range to get) it isn't efficient in the slightest, but it works, and is fun if you'd like to do some Java 8. But if this is performance critical, I wouldn't recommend it:

public ArrayList<Integer> sampler(int min, int max, int number){
    Random random = new Random();
    ArrayList<Integer> generated = new ArrayList<Integer>();
    IntStream ints = random.ints(min,max);
    Iterator<Integer> it = ints.iterator();
    for(int i = 0; i < number; i++){
       int k = it.next();
       while(generated.contains(k)){
           k = it.next();
       }
       generated.add(k);
    }
    ints.close();
    return generated;
}

Answer 4

If you really need to scale to petabytes of data, you're going to need a solution that doesn't require keeping all your numbers in memory. Even a bit-set, which would compress your numbers to 1 byte per 8 integers, wouldn't fit in memory.

Since you didn't mention the numbers had to be shuffled (just random), you can start counting and randomly decide whether to keep each number or not. Then stream your result to a file or wherever you need it.

Start with this:

    long range = 100;
    float percentile = 0.20f;
    Random rnd = new Random();
    for (long i=1; i < range; i++) {
        if (rnd.nextFloat() < percentile) {
            System.out.println(i);
        }
    }

You will get about 20 percent of the numbers from 1 to 100, with no duplicates.

As the range goes up, the accuracy will too, so you really wouldn't need any special logic for large data sets.

If an exact number is needed, you would need special logic for smaller data sets, but that's pretty easy to solve using other methods posted here (although I'd still recommend a bit set).