...either an empty string, a single character, or the same sequence of characters repeated more than once?

**328 points**(98.0% liked)

# Programmer Humor

Post funny things about programming here! (Or just rant about your favourite programming language.)

# Rules:

- Posts must be relevant to programming, programmers, or computer science.
- No NSFW content.
- Jokes must be in good taste. No hate speech, bigotry, etc.

It matches for non-primes and doesn't match for primes.

I could be wrong but I think the `(..+?)`

portion will either remove a dud or replenish the allowance.

For a second I thought I was still in the thread about monkeys face-rolling typewriters until the heat death of the universe not eventually producing Hamlet

So, here's my attempt

The first portion (`^.?$`

) matches all lines of 0 or 1 characters.

The second portion (`^(..+?)\1+$`

) is more complicated:

`(..+?)`

is a capture group that matches the first character in any line, followed by a smallest possible non-zero number of characters such that (2) still matches (**note**that the minimum length of this match is 2)`\1+`

matches as many as possible (and**more than 0**) repeats of the (1) group

I *think* what this does is match any line consisting of a single character with the length

- divisible by some number (due to the
**more than 0**condition in (2), so that there have to be repeats in the string), that's not`1`

(due to the**note**in (1), so that the repeating portion has to be at least 2 characters long), or- the length itself (due to the
**more than 0**condition in the (2), so that there is at least one repetition)

Therefore, combined with the first portion, it matches all lines of the same character whose lengths are composite (non-prime) numbers? (it will also match any line of length 1, and all lines consisting of the same string repeated more than one time)

So this is a definite example of "regex" that's not regular, then. I really don't think there's any finite state machine that can track every possible number of string repeats separately.

Yeah backreferences in general are not "regular" in the mathematical sense.

You got downvoted here but you're absolutely right. It's easy to prove that the set of strings with prime length is not a regular language using the pumping lemma for regular languages. And in typical StackExchange fashion, someone's already done it.

Here's their proof.

Claim 1: The language consisting of the character `1`

repeated a prime number of times is not regular.

A further argument to justify your claim—

Claim 2: If the language described in Claim 1 is not regular, then the language consisting of the character `1`

repeated a composite number of times is not regular.

Proof: Suppose the language described in Claim 2 is regular if the language described in Claim 1 is not. Then there must exist a finite-state automaton *A* that recognises it. If we create a new finite-state automaton B which (1) checks whether the string has length 1 and rejects it, and (2) then passes the string to automaton A and rejects when automaton A accepts and accepts when automaton A rejects, then we can see that automaton B accepts the set of all strings of non-composite length that are not of length 1, i.e. the set of all strings of prime length. But since the language consisting of all strings of prime length is non-regular, there cannot exist such an automaton. Therefore, the assumption that the language described in Claim 2 being regular is false.

By now, I have just one, so thanks for the assist. There's always that one (sometimes puzzling) downvote on anything factual.

The pumping lemma, for anyone unfamiliar. It's a consequence of the fact an FSM is finite, so you can construct a repeatable y just by exhausting the FSM's ability to "remember" how much it's seen.

You can have states point to each other in a loop, no?

Yeah, but in an FSM *all* you have are states. To do it the obvious way, you need a loop with separate branches for every number greater than 2, or at the very least every prime number, and that's not going to be finite.

If the set of all strings of composite length is a regular language, you can use that to prove the set of all strings of prime length are also a regular language.

But it's also easy to prove that the set of language of strings of prime length is *not* regular, and thus the language of strings of composite length also can't be regular.

Thank you for this. I'll review this when I can.

knowing Matt Parker it only matches prime numbers or multiples of e or something.

*looks at <ansewer>*

Yeah see?

The pipe is throwing me off because usually I have to do parentheses for that to work...

Is there a reason to use `(..+?)`

instead of `(.+)`

?

Yes, the first one matches only 2 more characters while the second matches 1 or more. Also the +? is a lazy quantifier so it will consume as little as possible.

Ah, didn't know +? was lazy, thanks

I thought, the +? was going to be a syntax error. 🙃

I was like, why specify "one or more" and then make it optional? Isn't that just .*?

This is brilliantly disgusting.

## Literal interpretation of the regex

The regex matches either a line with a single character or a line with a sequence of two or more characters that's repeated two or more times. For some examples: the regex matches "a", "b", "abab", "ababab", "aaaa", and "bbbbbb", but does not match "aa", "bb", "aaa", "ab", "aba", or "ababa".## Hint for the special thing it matches

For a line with a single character repeated*times, what does matching (or not matching) this regex say about the number*

*n**?*

*n*You forgot empty line. Since first part is `^.?$`

it's one or zero of any character.

A non prime number of times... It looks like the string of characters could repeat number of times because the whole capture group repeats. I don't see a prime constraint.

The capture group must be the same each time it repeats, so the number of characters stays the same. So X groups of Y characters = string of length X*Y. X and Y can be anything so any string length that can be made by multiplying two numbers-- which is every non-prime string length-- is matched. 0 and 1 are handled specially at the start.

All my homies hate regexs. That's actually the best use case I found for LLMs so far : I just tell it what I want it to match or not match, and it usually spits out a decent one

That sounds…

Easier to get *almost right* than actually learning the subject.

Much, much harder to get *completely right* than actually learning the subject.

So yes, basically the archetypal use case for LLMs.

Oooof. I feel like trying to figure out what's wrong with some regex I didn't write is much harder than writing it myself personally.

I've never had to use it for important stuff tbh. But alongside a regex tester and a sample of the stuff I intend to use it on, I've had good results with an incremental approach where I tell the LLM what I want to change with the expression until I'm satisfied

I'm going to assume the answer is a magic square attempt that just isn't very good

No cookie for me I just tried it in Notepad++ and VS code and it matches lines of one characer (first group I think) or the starting of a line that is an at least 2 characters string repeated twice (second group it seems)

so the second group matches
abab

abcabc
abcdeabce
abcdefabcdef

Nothing about prime numbers really only first repetition gets a match. Very interesting Honestly I used regex from years and never had to retort to something like this ever. I can only imagine it useful to check for a password complexity to not be repeated strings like I do for sites that I just want in and use a yopmail.com mail to register a fake user.

"at least 2 characters repeated [at least] twice" implies the string's length is divisible by a number greater than 1.

Yes but the match goes for the first repetition the rest of the string isn't matched no matter the length, again don't find anything about prime numbers unless I checked something wrong. There is another guy who got it right it seems.

Empty input
Or input of exactly 1 character
Or input of at least 2 characters, followed by at least 1 *something* (idk what \1 matches)

Did I get it (almost)?

\1 is group 1 which is inside `()`

, so second part is repeated 2 or more times of 2 or more char.

Interesting.

So that means match any string that is made entirely of a single repeating sequence, where repititon is possible.