﻿ Generate an N-Digit Random Number - ITCodar

# Generate an N-Digit Random Number

## How do I generate a random n digit integer in Java using the BigInteger class?

``private static Random rnd = new Random();public static String getRandomNumber(int digCount) {    StringBuilder sb = new StringBuilder(digCount);    for(int i=0; i < digCount; i++)        sb.append((char)('0' + rnd.nextInt(10)));    return sb.toString();}``

And then you can use it:

``new BigInteger(getRandomNumber(10000))``

## Generate 6 digit random number

Its as simple as that, you can use your code and just do one thing extra here

``String.format("%06d", number);``

this will return your number in string format, so the "0" will be "000000".

Here is the code.

``public static String getRandomNumberString() {    // It will generate 6 digit random Number.    // from 0 to 999999    Random rnd = new Random();    int number = rnd.nextInt(999999);    // this will convert any number sequence into 6 character.    return String.format("%06d", number);}``

## Generate random number of n digits or more

You can use the constructor `BigInteger(int numBits, Random rnd)` to generate positive random numbers with N bits.

As you want to have a minimum, you can add that as an offset to the generated numbers:

``Random random = ThreadLocalRandom.current();BigInteger base = BigInteger.valueOf(10000000); // minint randomBits = 50; // set as many bits as you fancyBigInteger rnd = base.add(new BigInteger(randomBits, random));``

## How to Generate a random number of fixed length using JavaScript?

``console.log(Math.floor(100000 + Math.random() * 900000));``

## How to generate a random number with a specific amount of digits?

You can use either of `random.randint` or `random.randrange`. So to get a random 3-digit number:

``from random import randint, randrangerandint(100, 999)     # randint is inclusive at both endsrandrange(100, 1000)  # randrange is exclusive at the stop``

* Assuming you really meant three digits, rather than "up to three digits".

To use an arbitrary number of digits:

``from random import randintdef random_with_N_digits(n):    range_start = 10**(n-1)    range_end = (10**n)-1    return randint(range_start, range_end)    print random_with_N_digits(2)print random_with_N_digits(3)print random_with_N_digits(4)``

Output:

``331245127``

## Generating random number of N-digits using gmpy2 library in Python

You should specify the minimum, and maximum number of random numbers given N as follows:

Code:

``# conda install -c conda-forge gmpy2def get_ranged_random_integer(rand_min, rand_max):    import gmpy2    rs = gmpy2.random_state(hash(gmpy2.random_state()))    return rand_min + gmpy2.mpz_random(rs, rand_max - rand_min + 1)def get_random_intger_of_N_digits(n):    rand_min = 10**(n-1)    rand_max = (10**n)-1    return get_ranged_random_integer(rand_min, rand_max)if __name__ == '__main__':    n = 100    p = get_random_intger_of_N_digits(n)    print(f"[main] length: {len(str(p))}, random: {p}")``

Result:

``[main] length: 100, random: 2822384188052405746651605684545963323038180536388629939634656717599213762102793104021248192535427134``

## Generate a random integer with a specified number of digits Java

``private long generateRandomNumber(int n) {    long min = (long) Math.pow(10, n - 1);    return ThreadLocalRandom.current().nextLong(min, min * 10);}``

`nextLong` produces random numbers between lower bound inclusive and upper bound exclusive so calling it with parameters `(1_000, 10_000)` for example results in numbers 1000 to 9999.
Old `Random` did not get those nice new features unfortunately. But there is basically no reason to continue to use it anyways.