Generate 16-digit unique code (like product serial)

Question

I am not sure what to call this type of code (16-digit alphanumeric code).

Conditions are like this:

1. Digits (or characters) are limited 16
2. Numeric, alphabet mixed
3. No duplication allowed (not yet implemented)

One class with the main method:

public class QuadraDigitCipherGenerator {
    // Step 1. Generate 16 digit wich is not duplicated
    // Step 2. divide by 4 digit

    private static List<Integer> pickRandomIndex (String original, int count) {
        List<Integer> randIndices = new ArrayList<Integer>();
        Set<Integer> noDuplicateIndices = new HashSet<Integer>();
        System.out.println(noDuplicateIndices.size() + "    " + count);
        while (noDuplicateIndices.size() < count){
            System.out.println(noDuplicateIndices.size() + "    " + count);
            int randNumber = (int)(Math.random() * original.length());
            noDuplicateIndices.add(randNumber);
        }
        randIndices.addAll(noDuplicateIndices);
        return randIndices;
    }

    // FROM 97 - 122
    private static char convertDigit2Char(char digit) {
        return (char)(17 + digit);
    }

    private static String generateCode(int digit, int charCnt) {
        long nano = System.nanoTime();
        StringBuilder util = new StringBuilder(String.valueOf(nano));
        util = util.reverse();
        List<Integer> convertIndices = pickRandomIndex(util.toString(), charCnt);
        System.out.println("Below indices will be casting to Alphabet " + convertIndices);

        for(Integer i : convertIndices){
            char target = util.charAt(i);
            util.setCharAt(i, convertDigit2Char(target));
        }
        return util.toString();
    }

    private static String beautifyDigits(String original, int term){
        System.out.println("original " + original);
        return original.substring(0, term) + "-" + original.substring(term, 2*term)
                + "-" + original.substring(2*term, 3*term) + "-" + original.substring(3*term, 4*term);
    }


    public static void main(String argv[]) throws Exception {
        int digit = 16;
        System.out.println(digit + " digits random code > " + beautifyDigits(generateCode(16, 4), 4));
    }
}

The output looks like D33J-H872-3545-71A1, a product serial key.

Anyway, I think this code is not satisfied with the third condition (no duplication). Do you have any advice with regards to that aspect of the requirements?

Answer 1

Okay first off, let's make your random character choosing better.

The simplest way to get random symbols is to simply define the alphabet and then index into it.

So here's how you'd typically do it:

static final private String ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
final private Random rng = new SecureRandom();    

char randomChar(){
    return ALPHABET.charAt(rng.nextInt(ALPHABET.length()));
}

String randomUUID(int length, int spacing, char spacerChar){
    StringBuilder sb = new StringBuilder();
    int spacer = 0;
    while(length > 0){
        if(spacer == spacing){
            sb.append(spacerChar);
            spacer = 0;
        }
        length--;
        spacer++;
        sb.append(randomChar());
    }
    return sb.toString();
}

The likelihood of generating two keys that are duplicates is \$\frac{1}{36^{16}} \approx 8\cdot 10^{-24}\$. So if you generate 10000 (ten thousand) bulk keys, the likelyhood of not having any duplicates is: $$(1-\frac{1}{36^{16}})^{10000}=99.99999999999999999987\%$$.

In other words, you are not very likely to get duplicates as long as your random function is good (hence the use of SecureRandom instead of Math.random(). To be certain you have to always check against your database anyway as a last step so I would just not bother with duplicate checking on the client side as the likelihood of finding duplicates is so very low.

Answer 2

Ok, recognizing that what you are trying to do is generate a series of base 36 numbers, we can do this simpler and functionally.

 public static void main(String[] args) {
        String result = new SecureRandom().ints(0,36)
            .mapToObj(i -> Integer.toString(i, 36))
            .map(String::toUpperCase).distinct().limit(16).collect(Collectors.joining())
            .replaceAll("([A-Z0-9]{4})", "$1-").substring(0,19);

        System.out.println(result);
    }

produces: 51QZ-RJ30-JZW3-97L7

16 alphanums, all unique.

There are several improvements with this implementation.

1. It's shorter. Less code is generally a win.
2. It doesn't define its own alphabet and takes advantage of a detail of the problem by using the built in Integer libraries to output base 36 numbers
3. It's purely functional and has no external variables to manage. The previous implementation has 4 variables - 2 in function. Those variables are incremented and decremented leaving room for bugs.
4. This code makes a clear delineation between the generation of the number set and its format. Separation of concerns is generally considered best practice.
5. Uses native libraries to perform the format and eliminates any logic which can also introduce bugs.

In general, it's a library driven approach which will naturally reduce the chance for bugs as it relies on well vetted existing code.

Answer 3

In manufacturing a lot of times the serial number encodes information about the product, such as the date of manufacture and part or model numbers and other options. They also include serial numbers for batches and for individual pieces. This leads to them being unique, as they are literally serial numbers. You can use some other type of encoding like base 16 or 32 to obfuscate the serial 001 type of numbers or the dates.

For the type of serial number you are using, you might also consider a checksum for the last digit. See the luhn algorithm for example, which is especially useful if people are transcribing your serial number.