Create random String of numbers with specific requirements

Question

I want to create a random String of numbers.

• From 0-9.
• 10 digits long.
• First digit cannot be a 0.
• One of the digits has to be in the String 2 times and one has to not be there at all.
• Or one digit has to be there 3 times, and 2 other digits can not be there at all.

To make this a little bit clearer here are some examples:

1223456789 - 10 digits, no starting zero, one digit (2) is there 2 times and one digit (0) is not there at all

1000345678 - 10 digits, no starting zero, one digit (0) is there 3 times and two digits (2,9) are not there at all

The starting zero is pretty easy caught with startsWith - method, but I have not found a way to check for the rest and I am not particularly good at regex while I am also not entirely sure you can even do this using regex.

For generating the random String itself, I have worked with the Random class as well as RandomStringUtils, both of which don't have restrictions on creating numbers.

Has anyone of you an idea how to achieve this?

Answer 1

What about trying to make what you want first using the rules then construct the rest.

Here is a possible idea

Using the first rule

One of the digits has to be in the String 2 times and one has to not be there at all.

1. Create a LinkedList then add the numbers 1 to 9 to it.

2. Generate a random number between 0-8 (range of the indexes of the list), use the index to retrieve a value out of the list (as in delete it) then add that to the String so the first number isn't 0.

3. Add 0 back to the list so it can be used somewhere else.

4. There are now 9 numbers left in the LinkedList with the first number being non zero and already in the String variable as per step 2. From here, generate another random number in the range of the LinkedList indexes. Whatever this number is, remove it from the LinkedList add it twice to the ArrayList.

5. There are now 8 numbers left in the LinkedList, 1 non zero number in the String. and 3 numbers in the ArrayList for a total of 4 numbers in your sequence that are confirmed to be correct. You have to get another 6 numbers to complete it. So far it would look something like this.

String sequence => "4"

ArrayList beingBuilt => [2, 6, 6]

LinkedList available => [1, 3, 4, 5, 7, 8, 9, 0]

6. Seems you only can have 10 numbers, loop 6 more times through the LinkedList using a random number to pluck at a random index, delete it from LinkedList add it to ArrayList.

After this the ArrayList should have 9 numbers, you could shuffle it to make it more random then convert it to a String and append to on the end of the sequence. Your rule should be satisfied now.

To make it more random you could manipulate how you pluck out numbers from the LinkedList and also the last rule you had you could change it for that too fairly simply. I used a LinkedList due to faster deletes, I did think about using a set but perhaps more work to handle the random number index being mapped to a number that actually exists in the set.

Just an idea though

Answer 2

The idea is: first generate a random string with 0-9 each once and not starts with 0, then: 1. replace one of the digital will another or 2.replace two digitals with another.

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        System.out.println(generateRandomString());
        System.out.println(generateRandomString());
    }


    public static String generateRandomString() {
        String alphabet = "0123456789";
        String result = "";
        Random random = new Random();
        // build a random string construct will 0-9 and each digital appear once
        for (int i = 0; i < 10; i++) {
            int index = random.nextInt(alphabet.length());
            if (i == 0) { // first cannot be 0
                index = random.nextInt(alphabet.length() - 1) + 1;
            }
            String c = alphabet.substring(index, index + 1);
            result += c;
            alphabet = alphabet.replace(c, "");
        }
        return random.nextInt(2) == 0 ? shuffle1(random, result) : shuffle2(random, result);
    }

    // One of the digits has to be in the String 2 times and one has to not be there at all.
    private static String shuffle1(Random random, String result) {
        int from = random.nextInt(10);
        int to = random.nextInt(9) + 1;
        while (from == to) {
            to = random.nextInt(9) + 1;
        }
        result = result.replace(result.substring(to, to + 1), result.substring(from, from + 1));
        return result;
    }

    // One digit has to be there 3 times, and 2 other digits can not be there at all
    private static String shuffle2(Random random, String result) {
        int from = random.nextInt(10);
        int to1 = random.nextInt(9) + 1;
        int to2 = random.nextInt(9) + 1;
        while (from == to1) {
            to1 = random.nextInt(9) + 1;
        }
        while (from == to2 || to2 == to1) {
            to2 = random.nextInt(9) + 1;
        }
        result = result.replace(result.substring(to1, to1 + 1), result.substring(from, from + 1));
        result = result.replace(result.substring(to2, to2 + 1), result.substring(from, from + 1));
        return result;
    }

}

Answer 3

Imagine you have 10 sacks, each one of them has its corresponding number embroided on it, from 0 to 9, like this:

   .---.._                  
  {------'; 
   }====={    
 .´       '.   
/    .´|    \       inside there are
|      |    |  <--- stones with '1' engraved
\:    _|_   /
  -__    =.´

You also have a coin to flip heads or tails on your hand.

       .------..-                  
     ´  . /___  `.`.
   ;   / /    ´}  ; ;     ______________________________ 
  :    "|'__'  //  : :   /                              |
  '    .|/__\. } \ ' '  /_    HEAD! You shall pick 3    |
  '     /"../      ' '    |  stones from the 1st sack!  |
   ;   /  \/  ͷ   ; ;     \____________________________/
    `_/          ´ ´ 
      " -------´-´  

First, we will decide if we will have 3 repeating numbers or 2 repeating numbers. Flip the coin to decide! Tail is 3, Head is 2. We will call this result ͷ.

Remove the sack embroided with 0 (Zero) for a moment.

Now pick ͷ (2 or 3) stones from a random sack of the 9 sacks you have in front of you. Remember, you cannot start with 0, that is why we removed it for a moment! Remove the sack you just picked from the line of sacks, forever. You cannot pick from this one anymore. Put back the 0 (Zero) sack on the line.

Place one of the stones you just picked in front of yourself. Hold ͷ-1 in your hand.

Now repeat this until you have 9 stones in your hand:

Select a random sack, pick ONE stone from it and hold it in your hand. Remove the sack from the line.

By the end of this process, you will have 9 stones in your hand, one in front of yourself. Shuffle up the ones in your hand. Place them in a straight line in front of yourself, next to the stone that was already in front of you.

You will end with 10 numbers, ͷ repetitions of the same number, won't start with zero, and the remaining sack(s) in front of you are just a side-effect of removing the sacks along the way.

Answer 4

If you're not too concerned about performance then the simplest thing would be to just generate random lists of numbers and check them against your conditions until you get one that works. Best to do the filtering as numbers and then convert to a string at the end rather than using regular expressions.

public String getRandomInts() {
    Random random = new Random();
    int[] ints;
    do {
        ints = random.ints(10, 0, 10).toArray();
    } while (!meetsCriteria(ints));
    return Arrays.stream(ints).mapToObj(String::valueOf).collect(Collectors.joining(""));
}

private boolean meetsCriteria(int[] ints) {
    if (ints[0] == 0) {
        return false;
    }
    if (frequency(ints, 0) == 1 
            && frequency(ints, 1) == 8
            && frequency(ints, 2) == 1) {
        return true;
    }
    if (frequency(ints, 0) == 2 
            && frequency(ints, 1) == 7
            && frequency(ints, 3) == 1) {
        return true;
    }
    return false;
}

private int frequency(int[] ints, int count) {
    return (int) IntStream.range(0, 10)
            .filter(n1 -> Arrays.stream(ints).filter(n2 -> n1 == n2).count() == count)
            .count();
}