如何使用mod运算符在输入范围之间生成随机数？

Question

I'm trying to figure out how to generate a number between a range predefined by the user using the mod operator.

What I do not want

int min = input.nextInt();
int max = input.nextInt();

Random r = new Random();
int X = r.nextInt(max - min + 1) + min;

What I want, something akin to a traditional int X = gen.nextInt() % 100 + 1; but instead using values for Max and Min.

Here is what I have so far

import java.util.*;

public class Modulus
{// begin class
    public static void main(String[] args)
    {// begin  main
    Scanner input;
    int max, min, range;
    Random gen;

    gen = new Random();


    input = new Scanner(System.in);

    System.out.println("Please enter a max value: ");
    max = input.nextInt();
    // Ask user to input max value

    System.out.println(" Please enter a minimum value: ");
    min = input.nextInt();
    // Ask user to input min value

     range = gen.nextInt() % (Unknown) 
    // Get random integer between min and max values using %


    System.out.println(" Your generated number is: " + range );






    } 
//end main
}
//end class

Can anyone explain how I might be able to accomplish this using the mod operator?

Answer 1

You can use the Math.abs() function.

ie

public static int genRandom(int mod){
  Random r = new Random();
  return Math.abs(r.nextInt()) % mod + 1;
}

and plug your high number as a parameter. The caveat to this is it works only with non-negative values.

Answer 2

This

 range = Math.abs(gen.nextInt() % (max - min + 1)) + min 

will get what you want. The % operator returns a value from 0 to max-min if nextInt returns a positive number or 0, or from 0 to -(max-min) if nextInt returns a negative. So abs will return a number in the range 0 to max-min , and adding min gets you a number in the range min to max .

I don't recommend doing it this way, though. When you generate a random integer from a set of M integers, and then use % to reduce it to a set of N integers, the resulting distribution will not be uniform if M is not divisible by N. Some results will show up more often than others. I'm not sure why you don't want to use gen.nextInt(max - min + 1) , but it's the right tool for the job.

The right way to do something like this would be: if you have a way to generate a random number in the range 0 to M-1 inclusive, and you need one in the range 0 to N-1 inclusive, then you need to pick only numbers in the range 0 to N*(M/N)-1 [where M/N is an integer division that truncates], and if the generator picks a number in the range N*(M/N) to M-1, loop back and try again. Then when you use the % N operator on the result you will get a uniform distribution. (This algorithm has to be adjusted if the generator can generate negative values.) The code for Random.nextInt(int n) does exactly this; here's a comment from the JRE source:

 * The algorithm is slightly tricky. It rejects values that would result * in an uneven distribution (due to the fact that 2^31 is not divisible * by n). The probability of a value being rejected depends on n. The * worst case is n=2^30+1, for which the probability of a reject is 1/2, * and the expected number of iterations before the loop terminates is 2. 

So since nextInt(n) does the necessary work, the only reason not to use it would be if it's homework and you're not allowed to.