How to get an 11 alphanumeric UNIQUE ID from a digit-only string?

Question

• I have an original string which can be either a 12-digit string OR a 19-digit customer ID which also includes digits only. Both cases are unique.
• For the sake of the question, let's assume that we're dealing with a 12-digit string and if you suggest a solution then it must fit also to the 19-digit case.
• Our client wants us to create a SECOND unique string which its length needs to be 11 chars, (whether the original string is the 12-digit one OR the 19-digit one); this unique string/ID should include alpha-numeric chars, where 'alpha' means that all letters can be a part of it; i.e. a solution in which the "participating" chars are digits only + lower case letters from 'a' to 'e' is not enough as it gives us less options then when using all lower & upper letters.
• Note that I don't need encryption, but a UNIQUE capability.
• I would appreciate any help, preferred with an example or a link to an example.
• If someones knows of a third party package that address such case, then please leave a link for it. Thanks in advance!

Answer 1

The original answer proposed to use BigInteger with a radix of 36, but that will not be enough for 19 digits.

I don't know if there are libraries to convert to/from base 62, but the contrived example below gives you an idea of how you could do it. The output is:

originalId = 999999999999999999
newId = bUI6zOLZTrh
retrieveOriginalId = 999999999999999999

The rationale of using base 62 is as follows:

• if the original number is unique, the new one will be unique too because they are the same number really (i.e. there is a one-to-one relationship)
• you can represent N ^ 11 11-char numbers in base N (for example, in base 10, an 11-digit number can be between 0 and 10 ^ 11 or 100 billion)
• the largest 19 digit number (in base 10) is 10 ^ 19 - 1
• with N = 62, you have 62 ^ 11 = 5 * 10 ^ 19 possibilities, which is larger than 10 ^ 19 and can therefore represent any 19-digit numbers. Actually using base 54 would be enough.

Sample code (algorithms inspired from BigInteger and Long classes - exception handling to be added):

class Base62 {

    private static final BigInteger RADIX = BigInteger.valueOf(62);
    private static final char[] DIGITS = {
        '0', '1', '2', '3', '4', '5',
        '6', '7', '8', '9', 'a', 'b',
        'c', 'd', 'e', 'f', 'g', 'h',
        'i', 'j', 'k', 'l', 'm', 'n',
        'o', 'p', 'q', 'r', 's', 't',
        'u', 'v', 'w', 'x', 'y', 'z',
        'A', 'B', 'C', 'D', 'E', 'F',
        'G', 'H', 'I', 'J', 'K', 'L',
        'M', 'N', 'O', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X',
        'Y', 'Z'
    };

    public static void main(String[] args) throws IOException {
        String originalId = "999999999999999999";
        System.out.println("originalId = " + originalId);

        String newId = getBase62From10(originalId);
        System.out.println("newId = " + newId);

        String retrieveOriginalId = getBase10From62(newId);
        System.out.println("retrieveOriginalId = " + retrieveOriginalId);
    }

    /**
     *
     * @param number a positive number in base 10
     *
     * @return the same number, in base 62
     */
    public static String getBase62From10(String number) {
        char[] buf = new char[number.length()];
        int charPos = number.length() - 1;

        BigInteger i = new BigInteger(number);
        BigInteger radix = BigInteger.valueOf(62);

        while (i.compareTo(radix) >= 0) {
            buf[charPos--] = DIGITS[i.mod(radix).intValue()];
            i = i.divide(radix);
        }
        buf[charPos] = DIGITS[i.intValue()];

        return new String(buf, charPos, (number.length() - charPos));
    }

    /**
     *
     * @param number a positive number in base 62
     *
     * @return the same number, in base 10
     */
    public static String getBase10From62(String number) {
        BigInteger value = BigInteger.ZERO;
        for (char c : number.toCharArray()) {
            value = value.multiply(RADIX);
            if ('0' <= c && c <= '9') {
                value = value.add(BigInteger.valueOf(c - '0'));
            }
            if ('a' <= c && c <= 'z') {
                value = value.add(BigInteger.valueOf(c - 'a' + 10));
            }
            if ('A' <= c && c <= 'Z') {
                value = value.add(BigInteger.valueOf(c - 'A' + 36));
            }
        }
        return value.toString();
    }
}

Answer 2

One way you can try.

Make your 12-digit to binary presentation, which should be able to represented by 5-bytes. Use base64 to encode it and it should be able to be represented by 9 alpha-numeric character. (ok... base64 did contains several non-alpha-numeric char... :P )

(If you have difficulties making it a 5-byte representation, breaking that 12 digits to 3 groups of 4 digits, each represent by 2 bytes should work too)

Search for base64 and get some understanding about it, then you may implement your own encoding method in similar manner.

---

Adding some code: (not tested, just give u an idea on it looks like)

String originalId= "123456789012";

String resultString = new String(Base64.encodeBase64(new BigInteger(originalId).toByteArray());