Oh boy what a beautiful regex. I'm sure it does something logical and easy to understand.

The answer given in the spoiler tag is not quite correct!

I upvoted this because I hate it.
- Whatever you do, don't get in a time machine back to 1998 and become a Unix sysadmin.
  (Though we didn't have CL-PPCRE then. It's really the best thing that ever happened to regex.)
- I upvoted you because I consider Perl write only (used to know it, now it inspires readable code as a high priority)
Thanks, I now have insight into my own personal hell for when I die.
- Regex is good for a few very specific things, and sysadmins used to use it for goddamn everything. If all your server logs are in lightly-structured text files on a small number of servers, being able to improvise regex is damn useful for tracking down server problems. Just write a shell loop that spawns an ssh logging into each server and running grep over the log files, to look for that weird error.
  These days, if you need to crunch production server logs you probably need to improvise in SQL and jq and protobufs or systemd assmonkery or something.
  But if you actually need a parser, for goodness sake use a parser combinator toolkit, don't roll your own, especially not with regex. Describing your input language in plain Haskell is much nicer than kludging it.
  (This is the "totally serious software engineering advice" forum, right?)
Average Matt Parker code
- I seem to remember he wrote something in Python that took hours to run, and his community got it down to milliseconds in C.
“abbabba”
“abbabba” doesn't match the original regex but “abbaabba” does
- Good catch! Typo. Fixed.
The answer says "any character" not "any characters", so it is still correct.

Relevant xkcd:

no

that is correct!
- nononono

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

looks at <ansewer>

Yeah see?

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.
- 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.
- Yeah backreferences in general are not "regular" in the mathematical sense.

Syntactically valid Perl

Something like
!"A line with exactly 0 or 1 characters, or a line with a sequence of 1 or 3 or more characters, repeated at least twice"!<
- You're misreading the ..+? part. That means 2 or more characters, non greedy.
- It's a line with a sequence of two or more characters repeated at least twice.

Just waiting for the oppertunity to hide this in prod.

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

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.

This is brilliantly disgusting. ::: spoiler 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". ::: ::: spoiler Hint for the special thing it matches For a line with a single character repeated n times, what does matching (or not matching) this regex say about the number n? :::

You forgot empty line. Since first part is ^.?$ it's one or zero of any character.

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.

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

I could be wrong but I think the (..+?) portion will either remove a dud or replenish the allowance.

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

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

Looks like APL to me.

It matches “yo momma”.

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.

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

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

I'm I the only one who pronounces regex with a soft g? Hard g feels so clunky

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

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
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.

Hot take: You're shit at coding if you can't do regex.

Ah yes, spoken like a true elitist asshole
- It takes a couple of hours to learn the basics.
Regular expressions in general, and automata theory, sure you should know about that. But a specific extended regex language like here? That's like saying you're shit at coding if you can't do
<insert arbitrary programming language here>
.
Regex should generally be avoided wherever possible.
- Yeah but it's just so tempting... It validates so many inputs so easily...