Create a UNIQUE 5 character alphanumeric string

Question

We are looking at creating promotional codes to send to customers, we have been told that each code sent HAS TO BE UNIQUE - 5 Characters - Alphanumeric.

I thought of doing a hash of a concatenated string and taking the first 5 characters of the hash, but there is a good chance that the same 5 characters will come up again and again.

Can anyone give me any pointers on creating this unique 5 character alpha numeric string that is unique EVERY TIME?

Answer 1

As I mentioned in the comments of my other answer, it may not be sufficient for your purposes. I worked up some more code which generates a string of random alpha-numeric characters. This time, they aren't limited to 0-9 and A-F -- i.e. the hexadecimal equivalents of randomly-generated nibbles. Instead, they are comprised of the full range of alpha-numeric characters, at least with upper-case letters. This should sufficiently increase the potential for uniqueness given we're going from 16 possible characters with hex to 36 possible characters with the full alphabet and 0-9.

Still, when I ran it over 10,000,000 tries, there were plenty of dups. It's just the nature of the beast: the likelihood that you'll get dups with such a short string is fairly high. At any rate, here it is. You can play around with it. If your client doesn't mind lowercase letters -- e.g. if "RORYAP" is different from "RoryAp" -- then that would even further increase the likelihood of uniqueness.

/// <summary>
/// Instances of this class are used to geneate alpha-numeric strings.
/// </summary>
public sealed class AlphaNumericStringGenerator
{
    /// <summary>
    /// The synchronization lock.
    /// </summary>
    private object _lock = new object();

    /// <summary>
    /// The cryptographically-strong random number generator.
    /// </summary>
    private RNGCryptoServiceProvider _crypto = new RNGCryptoServiceProvider();

    /// <summary>
    /// Construct a new instance of this class.
    /// </summary>
    public AlphaNumericStringGenerator()
    {
        //Nothing to do here.
    }

    /// <summary>
    /// Return a string of the provided length comprised of only uppercase alpha-numeric characters each of which are
    /// selected randomly.
    /// </summary>
    /// <param name="ofLength">The length of the string which will be returned.</param>
    /// <returns>Return a string of the provided length comprised of only uppercase alpha-numeric characters each of which are
    /// selected randomly.</returns>
    public string GetRandomUppercaseAlphaNumericValue(int ofLength)
    {
        lock (_lock)
        {
            var builder = new StringBuilder();

            for (int i = 1; i <= ofLength; i++)
            {
                builder.Append(GetRandomUppercaseAphanumericCharacter());
            }

            return builder.ToString();
        }
    }

    /// <summary>
    /// Return a randomly-generated uppercase alpha-numeric character (A-Z or 0-9).
    /// </summary>
    /// <returns>Return a randomly-generated uppercase alpha-numeric character (A-Z or 0-9).</returns>
    private char GetRandomUppercaseAphanumericCharacter()
    {
            var possibleAlphaNumericValues =
                new char[]{'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','0','1','2','3','4','5','6','7','8','9'};

            return possibleAlphaNumericValues[GetRandomInteger(0, possibleAlphaNumericValues.Length - 1)];
    }

    /// <summary>
    /// Return a random integer between a lower bound and an upper bound.
    /// </summary>
    /// <param name="lowerBound">The lower-bound of the random integer that will be returned.</param>
    /// <param name="upperBound">The upper-bound of the random integer that will be returned.</param>
    /// <returns> Return a random integer between a lower bound and an upper bound.</returns>
    private int GetRandomInteger(int lowerBound, int upperBound)
    {
        uint scale = uint.MaxValue;

        // we never want the value to exceed the maximum for a uint, 
        // so loop this until something less than max is found.
        while (scale == uint.MaxValue)
        {
            byte[] fourBytes = new byte[4];
            _crypto.GetBytes(fourBytes); // Get four random bytes.
            scale = BitConverter.ToUInt32(fourBytes, 0); // Convert that into an uint.
        }

        var scaledPercentageOfMax = (scale / (double) uint.MaxValue); // get a value which is the percentage value where scale lies between a uint's min (0) and max value.
        var range = upperBound - lowerBound;
        var scaledRange = range * scaledPercentageOfMax; // scale the range based on the percentage value
        return (int) (lowerBound + scaledRange);
    }
}

Answer 2

I came up with this a while back which might serve what you're looking for.

/// <summary>
/// Return a string of random hexadecimal values which is 6 characters long and relatively unique.
/// </summary>
/// <returns></returns>
/// <remarks>In testing, result was unique for at least 10,000,000 values obtained in a loop.</remarks>
public static string GetShortID()
{
    var crypto = new System.Security.Cryptography.RNGCryptoServiceProvider();
    var bytes = new byte[5];
    crypto.GetBytes(bytes); // get an array of random bytes.      
    return BitConverter.ToString(bytes).Replace("-", string.Empty); // convert array to hex values.
}

I understand your requirement is that it "must" be unique, but remember, uniqueness is at best a relative concept. Even our old friend the GUID is not truly unique:

...the probability of the same number being generated randomly twice is negligible

If I recall correctly, I found my code wasn't 100% unique with 5 characters over many, many iterations (hundreds of thousands or possibly low-millions -- I don't recall exactly), but in testing with 6, the result was unique for at least 10,000,000 values obtained in a loop.

You can test it yourself at length 5 and determine if it's unique enough for your purposes. Just switch the 6 to a 5 if you want.

Addendum: Some of the others have reminded me that you might need to consider thread safety. Here's a modified approach:

private static object _lock = new object();

/// <summary>
/// Return a string of random hexadecimal values which is 6 characters long and relatively unique.
/// </summary>
/// <returns></returns>
/// <remarks>In testing, result was unique for at least 10,000,000 values obtained in a loop.</remarks>
public static string GetShortID()
{
    lock(_lock)
    {
        var crypto = new System.Security.Cryptography.RNGCryptoServiceProvider();
        var bytes = new byte[5];
        crypto.GetBytes(bytes); // get an array of random bytes.      
        return BitConverter.ToString(bytes).Replace("-", string.Empty); // convert array to hex values.
    }
}

Answer 3

I would create a table (PromoCode) with all possible 5 digit strings. Then create another table CampaignPromoCode with two fields:

Code varchar(5), CampaignId uniqueidentifier

This way you can keep track of used ones for each campaign. To get a random unused promocode use this statement:

select top 1 Code 
from PromoCode pc
    left join CampaignPromoCode cpc on cpc.Code = pc.Code
where cpc.CampaignId = 'campaign-id-goes-here'
  and cpc.Code is null
order by newid()

Answer 4

Bottom line here is that you should probably go back to management and tell them that the requirement to force 100% absolute unique is a very cost prohibitive request and that you can get a 99.9999% unique for a fraction of the cost. Then use roryap's code to generate a random, mostly unique code.