Ok! On to more regex crosswords.

Didn’t get around to converting the crossword to use CSS grid. But did sort a thing or two. Still way too much in-line CSS. But, I will find some time to work on that.

Experienced #2

Puzzle link. Maybe give it a try before reading my solution.

Basics

Nothing new in the way of regex elements/patterns than what we have already seen. Only real change is just a bigger crossword.

Solve the Puzzle

Looking at the first row, the first character is just the intersection of two character classes. Which results in a r. For the second character, the first pattern in the column’s regex doesn’t by itself tell us much. It is simply a capture group for any possible character. But if we look at that column’s pattern a little more closely, the third and last characters have to be the same as the first (\1 for both). And if we take the intersection of the first and third row patterns, we have a choice of e or r. And looking at the pattern for the last row, the only possible pattern that could match is ed. So, the three spots get an e. And, because we have a literal n in that column’s regex we know the fourth character is an n.

We also now know that the second and third characters of the last row are ed. For the third character in the first row, only the column pattern of ge provides a match for the row’s pattern. So the first two characters in the third column are ge. The row’s character class and the fourth column’s character class only match for an u. Similarly the only possible match for the last column is an l.

Also because the first two characters of the third column are ge, we can see that the only pattern that will match the last 3 characters is sod.

So far we have the following characters sorted.

Goodly number of es. The title for this one is Regular Workout. See where it’s going. Let’s see if we can sort the second row.

The first character is rather straightforward. Once again the intersection of two character classes; leaving us with an a. We have the literal rex in the row pattern for the 2nd to 4th characters. So the two character classes have to supply only 1 character each. And the last letter is again just the intersection of two character classes; in this case, the p.

Looking at the first column, we know that at some point in the column we will have an o followed by zero or more characters. There are no os in the patterns for the third and fifth rows. So, that o must have to be in the fourth row. That means the character in the third row has to be determined by the intersection of the two character classes: for the column [ark]* and for the row [sires]*. That gives us a r. For the fifth character in the column, we already know that the second and third characters in the row are ed. The only single character in the regex for the row is h. So our column is raroh.

Carrying on with the third row, we have the intersection of the row and column patterns determining the characters. Specifically si.

For the fourth row, the fourth letter could be an l, o or f. But there is no l or o in the character class for that column. So f it is. Which also means the last character has to be a t matching the alternative oft in the regex for that row.

And, the last two characters of the fifth row have to be either ay or ed. No e in the regex for the fourth column, nor a d in that of the fifth column’s regex. So ay it is. And the result, regular expression of the day, would seem to fit with the puzzle’s title, Regular Workout.

Sure takes a bit of typing/writing to explain how I get where I’m going.

I suggest you give Experienced #3 a try. Only because it uses capture groups in one of the regexes.

Experienced #5

Puzzle link. Maybe give it a try before reading my solution. Though you may want to read the next subsection first.

Basics

Am showing this one because it introduces another form of quantifier, {min,max}. It says, repeat the preceding pattern (a literal or group) a min number of times up to a max number of times. If only min and no comma is provided, then it must repeat exactly min times. {,max} means 0 to max times. {min,} means min to infinitely many times.

Solve the Puzzle

Did you try it yourself?

Other than the new quantifier type, nothing you shouldn’t already understand in this puzzle.

Starting with the first row, the intersection of character classes gives us a t for the first character. For the second character we can have an o, a b or an a. But we can’t repeat the be or ad twice, because there is no e or d for the character class for the first character of the last column. That means the second and consequently the fifth characters are an o. And, for the third character, there is no way to match an a with the alernation for the the first two characters of the column. So, the third and fourth characters must be be.

And, if we quickly look at the regex for the second row, the last two characters must be ts. As specified by t{2}; i.e. a literal t 2 times.

And since we have an o for the first character of the second column, the second character must be n. Similarly for the third column, the second letter must be an o. And, third letter in the last column has to be r.

May as well finish that second row. The first character, an intersection of character classes, must be r.

Also, we have a g (literal character) for the last letter in the fourth column.

Getting an idea where this might be going.

Looking at the first column, we know that we need to eventually match and oe or eo. If we look at the regexes for the fourth and fifth rows, there is no o in the pattern for those rows first character. So no oe or eo for the last two characters of the column. Which means the third and fourth characters must be oe. Which also tells us that the first two letters of row four are eg. And that the third and fourth letters of the second column must be bg. And the first three of the third row are obe

Since there is now only one space left, we move on to the last character class in the column’s regex. Since there has been no (gp) yet, we are still using the row’s first character class, [req]+. That gives us the r.

Looking at the third column, the fourth letter has to be an e or u. The fourth row’s regex says the 3rd and 4th characters must be eg or ul. But, the 4th column’s regex does not allow a g. So, ul it must be. Which also means that the 3rd and 4th characters of column 4 must be al.

Now for the last letter in the third column, it has to be an e or u. But still no match for (gp). So the letter must still be in the character class [req]+. So, e it is.

And for the fourth row, the character class [alf]* now takes effect as we have made the two required matches for the first group. The only pattern in the last column’s regex that can make this match is ax. And, that finishes the puzzle.

And, given this is a regex puzzle, that does sort of go with the puzzle title, Hamlet.

Done

I do plan to continue with this for a while longer. But, I think that’s enough for this one. I don’t generally play games or do puzzles either on-line or on paper. But, regex puzzles are just nerdy enough to catch my interest. And, it seems I find explaining my thought process a rather pleasant experience.

Though, I must admit, I have started doing canuckle, wordle, and digits every morning.

Should your fingers or mind be unhappy, do leave the keyboard for a bit. Perhaps step out for some “fresh” air.