CODEWITHSUNDEEP
java
Steve Andrews
Steve Andrews

Reputation: 111

making a 13 digit random number generator in Java

a friend of mine at Uni, was wanting to generate a bunch of 13 digit numbers so he can test his sorting algorithms on, but was doing it a very long way around, so i've tried to use the following code to generate a settable number of 13 digit numbers.

public class random {

public static void main(String[] args) {

    long intArray[] = new long[20]; // to generate more than 20 random numbers increase this and the 'i < 20' to the same number ie. 75 

    for(int i = 0; i < 20; i++) { // here
        intArray[i] = numbGen();            
    }

    for(int j = 0; j < intArray.length; j++) {
        System.out.println(intArray[j]);
    }

}

public static long numbGen() {

    long numb = (long)(Math.random() * 10000000 * 1000000); // had to use this as int's are to small for a 13 digit number.

    return numb;
}
}

my issue is now sometimes it will generate a couple of 12 digit numbers in the group of 20 and i want to find a way not to add the number to the array if it is not 13 digits. I've tried if statement but getting stuck on not being able to determine the length (individual characters) of the Long.

Thanks in Advance.

Upvotes: 3

Views: 14807

Answers (8)

Atul Agrawal
Atul Agrawal

Reputation: 1520

Why not we try with Unix timestamp in milliseconds.Because that will work for next 200 years and after that we need to only eliminate the trailing digit from the number.

Calendar.getInstance().get(Calendar.MILLISECOND);

and by using this method we don't need any loop or any condition and it will give me a unique number every time.

Upvotes: 0

Maarten Bodewes
Maarten Bodewes

Reputation: 93968

A generic integer based implementation would be:

public static long randomDigits(int digits) {
    if (digits <= 0 || digits > 18) {
        throw new IllegalArgumentException("A long can store the random of 18 full digits, you required: " + digits);
    }

    // use SecureRandom instead for truly random values
    final Random r = new Random();
    long randomNumber = r.nextInt(9) + 1;
    for (int i = 1; i < digits; i++) {
        randomNumber = randomNumber * 10L + (long) r.nextInt(10);
    }
    return randomNumber;
}

or use a shorter version for 13 digits that does not tax the RNG as much:

public static long thirteenRandomDigits() {
    final Random r = new Random();
    return 1_000_000_000L * (r.nextInt(9_000) + 1_000)
            + r.nextInt(1_000_000_000);
}

These solutions are better to using Math.random() because they don't rely on multiplication with a large number to generate the random values. A double only has 15-17 digits precision, which is very close to the 13 digits number it is multiplied with. This leads to unequal distributions of random numbers. Solutions based on Math.random() won't scale past 13 digits either.

Upvotes: 2

claj
claj

Reputation: 5402

ThreadLocalRandom is a good thing, introduced in Java 1.7

java.util.concurrent.ThreadLocalRandom
    .current()
    .nextLong(1000000000000L, 10000000000000L);

Upvotes: 1

Arash Saidi
Arash Saidi

Reputation: 2238

A simple solution:

    while(test < 10000) {
        long num = (long) (Math.random() * 100000000 * 1000000);
        if(Long.toString(num).length() == 13) {
            return num;
        }
        test++;
    }

However, a better solution is this:

long number = (long) Math.floor(Math.random() * 9000000000000L) + 1000000000000L;

This will only generate random 13 digit numbers, and you don't need to check if there are more or less digits.

Note that this solution may not scale to a higher number of digits and may not return a perfect distribution of random numbers.

Upvotes: 6

Erwin Bolwidt
Erwin Bolwidt

Reputation: 31269

The simple solution for the problem that you described:

public static long numbGen() {
    while (true) {
        long numb = (long)(Math.random() * 100000000 * 1000000); // had to use this as int's are to small for a 13 digit number.
        if (String.valueOf(numb).length() == 13)
            return numb;
    }
}

This is not the most efficient or most random implementation of generating a 13-digit number but it answers your specific question.

Upvotes: 1

Scott Hunter
Scott Hunter

Reputation: 49803

First off, a Long doesn't have characters.

If you want to see if it has 13 digits, compare it to 999999999999L.

If you want to insure you have a value w/ 13 digits, get a random number between 0 and 8999999999999L (inclusive) (using the technique you already have to generate a random number in a range) and add it to 1000000000000L.

Upvotes: 0

Mustafa Gen&#231;
Mustafa Gen&#231;

Reputation: 2579

long randomNumber = 0;
long power = 1;

for(int i = 0; i < 12; i++) { // up to 12 not 13
    Random r = new Random();
    int randomInt = r.nextInt(10);

    randomNumber += (power * randomInt);
    power *= 10;
}

// here, the most stupid way to provide last digit to be not zero
Random r = new Random();
int randomInt = r.nextInt(9);
randomInt++;

randomNumber += (power * randomInt);
power *= 10;

Upvotes: 0

NimChimpsky
NimChimpsky

Reputation: 47290

long min = 1000000000000L; //13 digits inclusive
long max = 10000000000000L; //14 digits exclusive
Random random = new Random()
long number = min+((long)(random.nextDouble()*(max-min)));

Upvotes: 4

Related Questions