La tua sfida è creare una regex che corrisponda a ogni permutazione di stringa di se stessa e nient'altro. La corrispondenza deve anche essere sensibile al maiuscolo / minuscolo.

Quindi, ad esempio, se la tua regex è:

ABC

Dovrebbe corrispondere (e corrispondere solo) a queste stringhe:

ABC
ACB
BAC
BCA
CAB
CBA

Non dovrebbe corrispondere a cose come:

AABC (contains an extra A)
ABCD (contains an extra D)
AC   (no B)
AAA  (no B and C, extra 2 A's)
abc  (case-sensitive)

Regole:

• Puoi usare qualsiasi tipo di regex che ti piace.
• Si applicano scappatoie standard.
• Devi avere almeno due caratteri diversi nel tuo codice. Ciò significa che soluzioni come 1non sono valide.
• Il regex dovrebbe contenere solo ASCII stampabile e nient'altro.

JavaScript, 64 57 byte

4 byte rimossi grazie a Martin Ender.

^(?!.*([^])(.*\1){3}]?)[$$[-^?!!.'''-*11{33}5577\\-]{57}$

Provalo qui.

Spiegazioni (obsolete)

^                                  # Beginning of the string.
(?!.*                              # Match only the strings that don't contain...
  (.)(.*\1){4}                     #     5 occurrences of the same character.
  [^1]?[^1]?                       #     Something that doesn't matter.
)
[]zzz^(?!!!.**[)\\1{{44}}666]{64}  # 64 occurrences of these 16 characters.
                                   # Some are duplicated to make sure the regex
                                   # contains 4 occurrences of each character.
\z                                 # End of the string.

Perl e PCRE regex, 280 byte

^(?=(.*z){2})(?=(.*\(){43})(?=(.*\)){43})(?=(.*\*){22})(?=(.*\.){23})(?=(.*0){2})(?=(.*1){6})(?=(.*2){16})(?=(.*3){7})(?=(.*4){4})(?=(.*5){1})(?=(.*6){3})(?=(.*7){2})(?=(.*8){2})(?=(.*9){1})(?=(.*=){22})(?=(.*\?){22})(?=(.*\\){11})(?=(.*\^){2})(?=(.*\{){23})(?=(.*\}){23}).{280}\z

(Leggermente) più leggibile:

^
(?=(.*z){2})
(?=(.*\(){43})
(?=(.*\)){43})
(?=(.*\*){22})
(?=(.*\.){23})
(?=(.*0){2})
(?=(.*1){6})
(?=(.*2){16})
(?=(.*3){7})
(?=(.*4){4})
(?=(.*5){1})
(?=(.*6){3})
(?=(.*7){2})
(?=(.*8){2})
(?=(.*9){1})
(?=(.*=){22})
(?=(.*\?){22})
(?=(.*\\){11})
(?=(.*\^){2})
(?=(.*\{){23})
(?=(.*\}){23})
.{280}\z

Funziona in O (2 ^ n) tempo come scritto, quindi è incredibilmente inefficiente. Il modo più semplice per testarlo è sostituire ogni occorrenza di .*con .*?, il che fa sì che il caso in cui corrisponda venga prima verificato (il che significa che corrisponde in tempo lineare, ma impiega comunque tempo esponenziale se non riesce a corrispondere).

L'idea di base è che imponiamo che la lunghezza della regex sia uguale a 280 e utilizziamo le asserzioni lookahead per forzare ogni personaggio nella regex ad apparire almeno un certo numero di volte, ad esempio (?=(.*z){2})forzando il zpersonaggio ad apparire almeno due volte. 2+43+43+22+23+2+6+16+7+4+1+3+2+2+1+22+22+11+2+23+23è 280, quindi non possiamo avere occorrenze "extra" di nessun personaggio.

Questo è un esempio di programmazione di un autogramma , una frase che si descrive elencando il numero di ciascun carattere che contiene (e, in questo caso, anche la lunghezza totale). Sono stato abbastanza fortunato nel costruirlo (normalmente devi usare la forza bruta ma mi sono imbattuto in questa soluzione mentre testavo il mio programma di forza bruta prima che avessi finito di scriverlo).

Perl e PCRE regex, 253 byte, in collaborazione con Martin Ender

Ho ipotizzato che potrebbero esserci soluzioni più brevi che omettono alcune cifre (molto probabilmente 9, 8 o 7). Martin Ender ne ha trovato uno, mostrato di seguito:

^(?=(.*z){2})(?=(.*\(){39})(?=(.*\)){39})(?=(.*\*){20})(?=(.*\.){21})(?=(.*0){4})(?=(.*1){6})(?=(.*2){11})(?=(.*3){6})(?=(.*4){3})(?=(.*5){2})(?=(.*6){3})(?=(.*9){4})(?=(.*=){20})(?=(.*\?){20})(?=(.*\\){9})(?=(.*\^){2})(?=(.*{){21})(?=(.*}){21}).{253}\z

Versione leggibile:

^
(? = (. * Z) {2})
(? = (. * \ () {39})
(? = (. * \)) {39})
(? = (. * \ *) {20})
(? = (. * \.) {21})
(? = (. * 0) {} 4)
(? = (. * 1) {} 6)
(? = (. * 2) {11})
(? = (. * 3) {} 6)
(? = (. * 4) {3})
(? = (. * 5) {2})
(? = (. * 6) {3})
(? = (. * 9) {} 4)
(? = (. * =) {20})
(? = (. * \?) {20})
(? = (. * \\) {9})
(? = (. * \ ^) {2})
(? = (. * {) {21})
(? = (. *}) {21})
. {253} \ z