Is it possible to write a regular expression for this type of text?

Question

I need to write a regular expression for an 'option symbol' for my company so we can validate these symbols across our site.

An option symbol is composed of two parts:

Part1         Part2
_ _ _ _ _ _ | _ _ _ _ _ _ _ _ _ 

I can write a regular expression for Part2 as it is fairly simple.

However, Part1 (the first 6 character positions) can be a little complicated.

It boils down to:

• Part1 must be {6} characters in length total.
• There must be between {1,4} alpha characters in the first positions.
• After that, there can optionally be {1} numeric character.
• Finally, the rest of the characters remaining must be spaces, so Part1 totals to 6 characters.

The problem I'm having is that the number of spaces is variable based on the number of characters before it. This makes me think it isn't easily representable by a regular language.

How can I avoid brute-forcing it like so:

([A-Za-z]{1}[0-9]{1}[ ]{4}|
[A-Za-z]{2}[0-9]{1}[ ]{3}|
[A-Za-z]{3}[0-9]{1}[ ]{2}|
[A-Za-z]{4}[0-9]{1}[ ]{1}|
[A-Za-z]{1}[ ]{5}|
[A-Za-z]{2}[ ]{4}|
[A-Za-z]{3}[ ]{3}|
[A-Za-z]{4}[ ]{2}|
[A-Za-z]{5}[ ]{1})

Here are some example option symbols (remember, ignore everything beyond the first 6 characters):

F     123456P12345678
CMG   123456P12345678
AAPL  123456P12345678
GOOG1 123456C12345678
F5    123456C12345678

Answer 1

You can use a lookbehind assertion:

^[A-Za-z]{1,4}\d? +\b(?<=^.{6})

Explanation:

^: Match the start of the line or string (depending on whether you set the option RegexOptions.Multiline or not).

[A-Za-z]{1,4}\d? +: Match 1 to 4 alpha characters and an optional digit, followed by at least one space

\b: Assert that we are now at a word boundary (i.e., that the next character is alphanumeric)

(?<=^.{6}): Assert that the above match is exactly six characters long.

Answer 2

Try the following:

[A-Za-z]{1,4}[0-9]{1}?\s*?

The {1,4} allows a variable number of alphanumeric, the ? allows for it to be optional, and the * is similar to {0,}.

Answer 3

do it as a 2 part check, the first part is the regular expression, the second part is the length of the match against the regular expression.

ie something like this for the regular expression:

[:alpha:]{1,4}[:digit:]?[ ]{1,5}

The check against the length of the matched expression will ensure that it is valid, since the regular expression will not match if an individual section is invalid. So, if each section (alpha, digit, and space) is valid and the length is 6 then you have a valid match.