Thread: Psuedocode

In my opinion, regex is not the best solution anyways and it's also going to be slower than regular string manipulation.

Code:

public static bool ValidID(string id)
{
  int letters, digits;
  int visible = letters = digits = 0;
  foreach (char ch in id)
  {
    if (char.IsWhiteSpace(ch)) continue;

    ++visible;
    if (letters != 2)
    {
      if (char.IsLetter(ch)) ++letters;
      else return false;
    }
    else
    {
      if (char.IsDigit(ch)) ++digits;
      else return false;
    }
  }

  return visible == 6
         && letters == 2
         && digits == 4;
}

I wrote that assuming spaces were possible, otherwise you can just check the Length property of the id.

edit: Btw, if you use regex, this:

Code:

\d\d\d\d

Can be replaced with:

Code:

\d{4}

And same with the beginning... i.e.

Code:

[A-Za-z]{2}

Originally Posted by artistunknown

also I thought this

Code:

[A-Za-z]{2}\d{4}

] {2}\d {4}

wouldn't work but it does, Do I not put a space between maybe that's why it wouldn't work before because I put spaces between that

Did you not actually read the multiple replies on the first page of this thread telling you not to put the space in? How are you still confused about this?

Originally Posted by cstryx

They are useful for pattern matching, but the overhead of using regex in this case is going to be significantly slower. It may only be faster if you are using compiled regex on a much larger piece of string data.

I wouldn't say "significantly" slower, since either of them is fast enough to be effectively instantaneous to human perception.

Personally, as long as I'm not using a wildly inappropriate algorithm (like an O(N^3) linked list removal or something) my focus is always on readable, maintainable code. If there are actually performance concerns, then I'll rewrite if necessary, but in a lot of cases, the actual processing takes tiny fractions of a second and then idles waiting for user input. Whether it takes 100 nanoseconds or 10,000 nanoseconds, it's still effectively instantaneous to human perception, which finds anything less than about 100 microseconds to be "immediate".

The printing to the console is going to take orders of magnitude longer than either the regular expression or the character-based pattern matching.

Originally Posted by Cat

I wouldn't say "significantly" slower, since either of them is fast enough to be effectively instantaneous to human perception.

Personally, as long as I'm not using a wildly inappropriate algorithm (like an O(N^3) linked list removal or something) my focus is always on readable, maintainable code. If there are actually performance concerns, then I'll rewrite if necessary, but in a lot of cases, the actual processing takes tiny fractions of a second and then idles waiting for user input. Whether it takes 100 nanoseconds or 10,000 nanoseconds, it's still effectively instantaneous to human perception, which finds anything less than about 100 microseconds to be "immediate".

The printing to the console is going to take orders of magnitude longer than either the regular expression or the character-based pattern matching.

Significantly slower was a measurement of performance in context with my comparison between simple string manipulation and regex itself, which has nothing to do with human perception. Also, it's not clarified as to whether he needs to validate a bunch of ID's or just a single one, so performance may or may not be accumulative here. Still, regex is not the proper choice IMHO; it wouldn't be mine.

It's a string of 6 characters in length. You wouldn't turn the barbecue back on to heat up leftover chicken the day after, you would probably just use the microwave. Same principle applies here.

Code:

public static bool ValidID(string id)
{
  return id.Length == 6
        && char.IsLetter(id[0]) && char.IsLetter(id[1])
        && id.Skip(2).All(char.IsDigit);
}

You could parse the last 4 chars as an int and see if it was successful, and index[0] and [1] to check them for letters. Many ways to get the job done and still be faster but just as readable as regex.

Spacing does absolutely matter.

If you have

Code:

"[a-z] {2}"

It will parse this as:

Code:

"[a-z]"

This matches one lowercase letter

Code:

" "

This matches a space

Code:

"{2}"

This means the previous match must match twice.

So overall, the expression

Code:

"[a-z] {2}"

doesn't match two lowercase letters. It matches one lowercase letter followed by two spaces, because the repetition count applies to the token immediately preceding it, which in this case happens to be the space character.