Regex For Account's Office Reference

Question

I'm trying to write a regex for the following rules:

1. Characters 1-3 must be numeric
2. Character 4 must be ‘P’
3. Character 5 must be alpha
4. Characters 6-12 must be numeric
5. Character 13 must be numeric or ‘X’

These make up an account's office reference for accountancy purposes. So far I have the following:

^\d{3}P[A-Z]{1}\d{7}$

To finish the regex, I just need to say "any single number OR letter X", but I am not quite sure how to go about it. I tried \d{1}[X], but it's expecting a digit AND a letter.

Any ideas?

Answer 1

Try this:

^\d{3}P[A-Z]\d{7}[0-9X]$

The character group [0-9X] will match a single numeric character or X (unless an explicit quantifier other than {1} – e.g. {2} – follows it).

Addendum:

As @sln pointed out, it would be best to settle on 0-9 or \d (not mix the two) in a given regexp for consistency – in other words use...

^\d{3}P[A-Z]\d{7}[\dX]$

...or...

^[0-9]{3}P[A-Z]\d{7}[0-9X]$

...in this case.

Performance

Following comments regarding abysmal regexp performance, the concerns are greatly overstated.

Here is a quick sanity check...

void Main()
{
    // Quick sanity check.

    string str = "111PH1234567X";

    Stopwatch stopwatch = Stopwatch.StartNew();

    for (int i = 0; i < 1000000; i++)
    {
        if (str.Substring(0, 3).All(char.IsDigit)           //first 3 are digits
               && str[3] == 'P'                             //4th is P
               && char.IsLetter(str[4])                     //5th is a letter
               && str.Substring(5, 7).All(char.IsDigit)     //6-12 are digits 
               && char.IsDigit(str[12]) || str[12] == 'X')  //13 is a digit or X
       {
           ;
           //Console.WriteLine("good");
       }
    }

    Console.WriteLine(stopwatch.Elapsed);

    stopwatch = Stopwatch.StartNew();

    Regex regex = new Regex(@"^\d{3}P[A-Z]\d{7}[0-9X]$", RegexOptions.Compiled);
    for (int j = 0; j < 1000000; j++)
    {
        regex.IsMatch(str);
    }

    Console.WriteLine(stopwatch.Elapsed + " (regexp)");

    // A bit more rigorous sanity check.

    string[] strs = { "111PH1234567X", "grokfoobarbaz", "really, really, really, really long string that does not match", "345BA7654321Z" };

    Stopwatch stopwatch2 = Stopwatch.StartNew();

    for (int i = 0; i < strs.Length; i++)
    {
        for (int j = 0; j < 1000000; j++)
        {
            if (strs[i].Substring(0, 3).All(char.IsDigit)           //first 3 are digits
                && strs[i][3] == 'P'                                //4th is P
                && char.IsLetter(strs[i][4])                        //5th is a letter
                && strs[i].Substring(5, 7).All(char.IsDigit)        //6-12 are digits 
                && char.IsDigit(strs[i][12]) || strs[i][12] == 'X') //13 is a digit or X
            {
                ;
                //Console.WriteLine("good");
            }
        }
    }

    Console.WriteLine(stopwatch2.Elapsed);

    stopwatch2 = Stopwatch.StartNew();

    Regex regex2 = new Regex(@"^\d{3}P[A-Z]\d{7}[0-9X]$", RegexOptions.Compiled);
    for (int i = 0; i < strs.Length; i++)
    {
        for (int j = 0; j < 1000000; j++)
        {
            regex2.IsMatch(strs[i]);
        }
    }

    Console.WriteLine(stopwatch2.Elapsed + " (regexp)");
}

...that yields the following on my humble machine:

00:00:00.2134404
00:00:00.4527271 (regexp)
00:00:00.4872452
00:00:00.9534147 (regexp)

The regexp approach appears to be ~2x slower. As with anything, one needs to consider what makes sense for their use case, scale etc. Personally, I side with Donald Knuth, start with "premature optimization is the root of all evil", and would make a performance-driven choice only as needed.

Answer 2

I prefer basic methods than Regex when I can.

This is a whitelist approach:

var str = "111PH1234567X";

if (str.Substring(0, 3).All(char.IsDigit)           //first 3 are digits
       && str[3] == 'P'                             //4th is P
       && char.IsLetter(str[4])                     //5th is a letter
       && str.Substring(5, 7).All(char.IsDigit)     //6-12 are digits 
       && char.IsDigit(str[12]) || str[12] == 'X')  //13 is a digit or X
   {
       Console.WriteLine("good");
   }

you may need to add a check for string length, depending on your conditions.

Running this 1 million times vs the regex approach shows it is, at worst (str is valid, every condition is checked), 4x faster. Just throwing that out there.