Un diverso tipo di Meta Regex Golf


42

Avviso: a seguito della richiesta popolare ho leggermente allentato le regole:

  • La dimensione massima di regex aumenta di 1 byte ogni 5 risposte . La risposta N può usare fino a 29 + ⌈N / 5⌉ byte.
  • Il punteggio di ciascuna risposta sarà (M / (30 + N / 5)) N

Nel golf regex, ti vengono dati due set di stringhe e ti viene chiesto di creare il regex più corto che corrisponde a tutte le stringhe del primo set, ma fallisce su tutte le stringhe del secondo set.

Questo è ciò che faremo, ma ogni volta che qualcuno risponde, la sua regex stessa verrà aggiunta a una delle due serie di stringhe (di propria scelta). Pertanto, esiste un ordine rigoroso per rispondere a questa sfida.

Facciamo un esempio:

  • Di 'che inizio con abc(che non lo farò) e lo inserisco nel set di match .
  • Quindi una seconda risposta valida sarebbe a, poiché corrisponde a quanto sopra (e non ci sono ancora stringhe che devono ancora fallire). Di 'che questa risposta va nel set fallito .
  • Ora la terza risposta deve corrispondere abcma fallire a. Una possibile terza risposta è quindi b. Mettiamolo nel set di partite .
  • La quarta risposta ora deve corrispondere abce b, ma fallire a. Non consentiremo risposte duplicate, quindi sarebbe una regex valida c|b.

L'importante è che la tua risposta sia la più breve possibile. Questo può essere banale per le prime risposte, ma una volta ottenute alcune risposte, dovrebbe essere sempre più difficile ottenere la corrispondenza desiderata nel minor numero di caratteri possibile.

Per la vera sfida, inizialmente il set di match contiene PPCGe il set di fallimenti contiene [PPCG]e ho già fornito la prima risposta.

Rispondere

La cosa chiave da capire su questa sfida è che solo una persona può rispondere alla volta e ogni risposta dipende da quella precedente .

Non dovrebbero mai esserci due risposte con lo stesso N. Se due persone rispondono contemporaneamente per alcuni N, quello che ha risposto in seguito (anche se è una differenza di pochi secondi) dovrebbe eliminare gentilmente la propria risposta.

Per rendere questo processo un po 'più fluido, prova a seguire i seguenti passaggi quando pubblichi la tua risposta:

  • Assicurati che qualcuno abbia verificato in modo indipendente la correttezza della risposta precedente (e lasciato un commento corrispondente).
  • Prendi i due set di test trovati nella risposta precedente e scrivi una regex che corrisponde a tutte le stringhe in un set e nessuna nell'altro.
  • Pubblica la tua risposta nel seguente formato:

    # N. [regex flavour] - [regex size in bytes]
    
        [regex]
    
    [link to online regex tester]
    
    [notes, explanation, observations, whatever]
    
    ### The next answer has to match the following strings:
    
        [match set]
    
    ### And fail on these strings:
    
        [fail set]
    

    dov'è Nil numero della tua risposta. Copia [match set]e [fail set]dalla risposta precedente e aggiungi la tua regex a una di esse.

    Questo è assolutamente vitale per la sfida! Ho fornito uno strumento di dashboard per la sfida per aiutare con la contabilità e si basa sul modello sopra. (Vedi in fondo al post.)

  • Un altro utente dovrebbe ora rivedere la tua richiesta e lasciare un commento "Verifica della correttezza" se la tua risposta segue tutte le regole (vedi sotto). In caso contrario, dovrebbero lasciare un commento sottolineando eventuali difetti. Hai quindi 15 minuti per risolvere questi problemi. In caso contrario, la risposta verrà considerata non valida, dovrebbe essere eliminata e qualcun altro potrebbe pubblicare una risposta di follow-up alla precedente. (In questo caso, sei libero di inviare una nuova risposta in qualsiasi momento.)

Queste normative possono sembrare piuttosto rigide, ma sono necessarie per evitare risposte non valide da qualche parte nella catena.

Regole

  • Un utente può inviare una sola risposta ogni 4 ore. (Questo per impedire agli utenti di osservare costantemente la domanda e di rispondere il più possibile.)
  • Un utente non può inviare due risposte di seguito. (ad es. da quando ho inviato la risposta 1 non posso fare la risposta 2, ma potrei fare 3.)
  • Non modificare le risposte che sono state verificate. (Anche se trovi un modo per accorciarlo!)
  • Se un errore viene scoperto in precedenza nella catena (ovvero dopo che sono state pubblicate le risposte di follow-up), la risposta offensiva deve essere eliminata e rimossa dall'insieme di stringhe su cui i nuovi invii dovrebbero fallire. Tuttavia , tutte le risposte che sono state pubblicate da allora non devono essere modificate per riflettere.
  • Indica chiaramente un sapore in cui il regex è valido. Puoi scegliere qualsiasi sapore liberamente testabile online. C'è un buon elenco di tester online su StackOverflow . In particolare, Regex101 e RegexPlanet dovrebbero essere utili, poiché supportano un'ampia varietà di sapori. Includi un link al tester che hai scelto nella tua risposta. Con l'accensione delle global e mmodificatori ultiline nel tester, è possibile verificare tutte le stringhe in una sola volta, una su ogni riga (questi modificatori non sono conteggiati verso la dimensione regex, perché non sono necessari su qualsiasi stringa individuale).
  • La tua regex non deve essere vuota.
  • Il regex per la risposta N non deve essere più lungo di 29 + ⌈N / 5⌉ byte. Vale a dire le risposte da 1 a 5 possono utilizzare fino a 30 byte (incluso), le risposte da 6 a 10 possono utilizzare fino a 31 byte ... le risposte da 31 a 35 possono utilizzare fino a 36 byte. Controlla la dashboard per vedere quanti caratteri può usare la risposta successiva.
  • Il tuo regex non deve essere identico a nessuna stringa in nessuno dei set di test.
  • Non includere delimitatori nell'invio o nel conteggio dei byte, anche se la lingua host pertinente li utilizza. Se il tuo regex utilizza modificatori, aggiungi un byte per modificatore alla dimensione del regex. Ad esempio /foo/isarebbe 4 byte.

punteggio

Il punteggio di ogni risposta è calcolato come (M / (30 + N / 5)) N , dove M è la dimensione della regex in byte e N è il suo numero. Il punteggio di ogni utente è il prodotto di tutte le risposte. Vince l'utente con il punteggio complessivo più basso. Nel caso improbabile di un pareggio, vince l'utente con l' ultimo invio. Accetterò l'ultima risposta di quell'utente.

Se si preferiscono i punteggi sommatori, è possibile calcolare il punteggio di ciascuna risposta come N * (log (M) - log (30)) e sommarli su tutte le risposte. Ciò darà lo stesso ordine di classifica.

Non v'è alcuna necessità di includere il punteggio di una risposta nella risposta, solo segnalare M . La dashboard della sfida nella parte inferiore della domanda calcolerà i punteggi e, nel caso di due punteggi molto vicini, ricontrollerò i risultati usando tipi di precisione arbitraria.

Tieni presente che il punteggio di ciascuna risposta è inferiore a 1, quindi puoi migliorare il tuo punteggio complessivo fornendo una nuova risposta. Tuttavia, più breve è ogni tuo invio, più efficacemente puoi abbassare il tuo punteggio. Inoltre, le risposte successive possono ottenere un punteggio più basso sebbene siano più lunghe, a causa del crescente esponente.

Cruscotto

Ho scritto un piccolo strumento Dashboard, usando Stack Snippet, basato sul lavoro di Optimizer qui . Spero che ciò ci aiuti a ottenere un certo ordine in queste sfide dipendenti dalla risposta.

Questo mostrerà lo stato attuale della sfida - in particolare, se ci sono risposte contrastanti, se una risposta deve essere verificata o se la risposta successiva può essere pubblicata.

Produce anche un elenco di tutte le risposte con punteggi, nonché una classifica di tutti gli utenti. Attenersi al formato della sfida sopra riportato, in modo che la dashboard possa leggere le stringhe pertinenti dalle risposte. Altrimenti potresti non essere incluso nella classifica.

Per favore fatemi sapere ( idealmente in chat ) se individuate qualche bug o avete idee su come migliorare l'utilità dello strumento.


Le regole si sono rivelate un po 'più rigide di quanto pensassi. Dopo qualche discussione in chat sto pensando di allentare le regole un po 'dopo che la taglia è finita. Pubblicherò 3 commenti per le opzioni che posso pensare di seguito. Indica la tua preferenza votando i commenti.
Martin Ender,

2
Le regole sono regole. Non cambiarli. Potrebbe essere un peccato che sia praticamente impossibile pubblicare un'altra risposta, ma ciò non giustifica la modifica delle regole.
Martin Ender,

2
Consenti un byte aggiuntivo ogni 10 risposte. Corrispondentemente, cambiare il punteggio risposta (M / (30 + N / 10)) ^ N . Questo verrebbe applicato retroattivamente, quindi la risposta successiva potrebbe usare fino a 32 byte. La modifica del punteggio non influirebbe sui primi due posti della classifica, ma gli altri utenti verrebbero mescolati in qualche modo.
Martin Ender,

8
Consenti un byte aggiuntivo ogni 5 risposte. Di conseguenza, cambiare il punteggio risposta a (M / (30 + N / 5)) ^ N . Questo verrebbe applicato retroattivamente, quindi la risposta successiva potrebbe usare fino a 35 byte. La modifica del punteggio non influirebbe sui primi due posti della classifica, ma gli altri utenti verrebbero mescolati in qualche modo.
Martin Ender,

4
Siete strani e contorti. Perché dovresti fare questo a te stesso? (È divertente da leggere: P)
Joe,

Risposte:


5

42. Sapore di pitone - 38

\?[^w$]*\$$|^P|\w.\)|w.?\+|w\^|[^?P]P$

Testato su Regex101

La mancanza di entropia nelle ultime risposte mi stava arrivando ... (avrebbe dovuto farlo prima)

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)
\w.\)|\?[^-$]*\$$|[]^C]\w$|w[+^]
[]^C]\w$|\w.\)|-\$|w[+^]|\?[^w$]*\$$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)
\$..\\|\?[^w$]*\$$|w\^|[]^C]\w$
[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$
\?[^w$]*\$$|^P|\w.\)|w.?\+|w\^|[^?P]P$

Corretta verifica.
Martin Ender,

Il mio programma fa fatica a trovare una risposta lunga meno di 45 caratteri ...
Vi.

@Vi. Bene, posso dire che esiste almeno una soluzione 38, ma ovviamente sarebbe interessante se qualcuno
riuscisse

11

28. Sapore di pitone - 29

\.\)|P[.$?]|w\^|^[^|C\\]*$|^P

Testato su Regex101

Sono stati fatti molti scherzi - il numero 4 nel set di passaggi è probabilmente il più grande dolore, poiché è una sottostringa di una regex nel set di errori e condivide anche un suffisso con un'altra regex nel set di errori.

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\

Corretta verifica.
Martin Ender,

9

24 - Python flavour - 29

^(..[^^].{4,22}\$|[^?]+\w)$|2

Testato qui

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2

1
Corretta verifica.
febbraio

8

10. Sapore di pitone - 19

^[\w^]*$|!|]P|G]\$$

Testato su Regex101 .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Corretta verifica.
FryAmTheEggman,

8

8. Sapore ECMAScript - 14 byte

[^?][PG]$|<|PG

dimostrazione

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG

Corretta verifica.
FryAmTheEggman,

Risolto il collegamento demo.
Martin Ender,

@FryAmTheEggman Lo script legge i commenti, ma cerca solo "correttezza verificata" come sottostringa (ignorando il caso).
Martin Ender,

@ MartinBüttner Grazie, buono a sapersi.
FryAmTheEggman,

3
+1 per aver reso questa sfida da sola 10 volte più dura
Sp3000,


7

9. Sapore di pitone - 28

^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Testato su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Ho anche scoperto che non funzionava un minuto fa. Richiede due barre rovesciate di fila per corrispondere, quindi non credo che una bandiera possa salvarla.
febbraio

Whoops .... Avrebbe dovuto essere un * invece di +. Ho modificato la mia risposta
ndc5057,

Correttezza verificata.
FryAmTheEggman,

7

23. Sapore PCRE - 28

([^\\}<]{3}|][^]]|^).?[$PG]$

Testato su Regex101.

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$

Cosa fa [^]?
febbraio

@feersum Nella maggior parte dei gusti, a ]come il primo elemento di una classe di caratteri (dopo la negazione facoltativa), è solo ]all'interno della classe di caratteri e non si chiude (perché le classi di caratteri vuote sono un po 'inutili). Quindi [^]]corrisponde a tutto tranne ]. L'eccezione notevole è ECMAScript, che consente classi di caratteri vuote. In quel caso []non corrisponde a nulla, si comporta come (?!)e [^]corrisponde a qualsiasi personaggio, il che è conveniente, perché ECMAScript non ha un smodificatore ed [\s\S]è una seccatura digitare una lettura.
Martin Ender,

Corretta verifica.
Martin Ender,

7

11. Python - 29

^(.{,4}|.{9}|.{16,19}|.{5}P)$

► Test su RegexPlanet

Quasi tutte le risposte non valide hanno una lunghezza diversa da tutte le risposte valide. Questo regex lo usa.

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Corretta verifica.
febbraio

7

29. Sapore PCRE - 28

^..(.[!)3G^w]|$)|\^.{7}$|G\)

Testato su Regex101

Questa risposta funziona ancora ...

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\

Corretta verifica.
Martin Ender,

1
Bello! A parte il rimpasto, è esattamente quello che avevo
Sp3000,

Stavo cercando di calcolare questo usando l'algoritmo genetico, ma ha prodotto solo regex di 30 caratteri ... Ora eseguendolo per ottenere la risposta successiva. Risultato attuale - 32 caratteri.
Vi.

@Vi Un algoritmo genetico eh, idee interessanti che hai lì: P
Sp3000

@ Sp3000, ora 30 caratteri ... Ma è arrivata un'altra risposta, quindi è necessario riavviare.
Vi.

6

31. Sapore Perl - 29

[?[CP(].[-<)|w]|^P|^[^C|\\]*$

Non so come funzioni, è stato prodotto dalla mia prima incursione in algoritmi genetici . C'è l' output del programma che menziona la risposta.

La prossima risposta deve corrispondere:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

e fallire:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$

Corretta verifica.
Martin Ender,

Ahaha bello - hai usato le risposte precedenti come semi per la popolazione o è finito per assomigliare a quello precedente?
Sp3000,

Le stringhe passanti e non funzionanti vengono utilizzate come blocchi iniziali. Dopo un po 'di tempo, il loro hovewer è stato bandito a causa dei minimi locali. Puoi vedere come va nel registro del programma: il numero tra parentesi dopo "metric =" è la misura di quanto velocemente stiamo andando avanti. È basso a lungo, vietiamo le risposte correnti e ripristiniamo.
Vi.

(Nel frattempo, è già stato trovato un candidato di 31 caratteri per la prossima risposta)
Vi.

Oh, il limite è aumentato? Non lo è 29? In questo modo non finirà presto ... Penso che la sfida principale sia trovare l'ultima, l'ultima regex.
Vi.

6

32. PCRE - 30 byte

^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)

Testato su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E fallire su queste stringhe :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)

1
Corretta verifica.
Martin Ender,

Perché viene aggiunto all'elenco "non riuscito"? Fallisce già su se stesso, quindi può servire come risposta successiva senza modifiche. Suppongo che per ogni risposta non sia possibile scegliere a quale elenco aggiungere.
Vi.

3
@Vi. Immagino che Hwnd si senta bene oggi
Sp3000,

Lo renderò più difficile man mano che continua.
hwnd,

5

1. Sapore ECMAScript - 2 byte

^P

Provalo su Regex101.

Il set di corrispondenza iniziale è PPCGe il set non riuscito [PPCG]. Pertanto, questo regex verifica semplicemente che la stringa inizia conP .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P

E fallire su queste stringhe:

[PPCG]

3
Corretta verifica.
Decadimento beta

5

3. Sapore ECMAScript - 6 byte

[^\]]$

Provalo qui

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$

1
Corretta verifica.
Decadimento beta

5

7. Sapore di pitone - 16

(?<!\\..)(?!]).$

Testato su Regex101

Devo aggiungere un \ alla lista delle corrispondenze :)

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P

Corretta verifica.
NinjaBearMonkey

Questo ... questo è subdolo.
wchargin,

@WChargin Grazie :) Dovresti dare un'occhiata ad alcune delle risposte dell'utente23013 o n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳; alcuni sono piuttosto 'subdoli';)
FryAmTheEggman

5

12. Sapore ECMAScript - 17

!|[^?]P(CG|G..)?$

Provalo qui .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Corretta verifica.
Martin Ender,

5

22. Sapore PCRE - 29 byte

Poiché l'originale # 22 non viene modificato per 1 ora, suppongo che sia diventato non valido.

^.{3,23}[.-~]..\$$|[^P?][PG]$

dimostrazione

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P

1
Corretta verifica. (E sì, esatto, il 22 precedente ora non è valido.)
Martin Ender,

5

26. Sapore di pitone - 28

^..(.[!G)(3w^]|.{7}$|$)|\$\?

Test su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~

Corretta verifica.
Martin Ender,

5

30. Sapore di pitone - 28

[[?C(].[-!)|w]|^P|^[^C|\\]*$

Testato su Regex101

Quando c'è una volontà ...

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$

Corretta verifica.
jimmy23013,

5

37. Sapore Perl - 30

\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)

Presentazione su Regex101 .

La soluzione è stata prodotta con lo stesso programma di prima. Il programma ha anche stampato una soluzione di 29 caratteri\?[^$w]*\$|[]^C]\w)$|w.]|\w.\ , non so perché, dato che sembra una regex malformata ...

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)

Corretta verifica.
Martin Ender,

Ahaha Sono abbastanza seccato di non averlo capito dopo essere arrivato così lontano nel primo tempo: P
Sp3000,

5

40. PCRE - 33 byte

[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$

Testato su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)
\w.\)|\?[^-$]*\$$|[]^C]\w$|w[+^]

E fallire su queste stringhe :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)
\$..\\|\?[^w$]*\$$|w\^|[]^C]\w$
[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$

Corretta verifica.
Vi.

1
Ho un 35 ma non ne sono soddisfatto, quindi vedrò se riesco a ottenere qualcosa di più interessante
Sp3000,

E ho 3 opzioni per una risposta di 32 caratteri, ma l'intera sfida è diventata un po 'noiosa (in particolare la contabilità degli invii Regex101 e gli elenchi delle stringhe fail / pass). Se qualcuno lo desidera, posso pubblicare una risposta.
Vi.

4

4. Sapore ECMAScript - 5 byte

^\^?P

Provalo qui .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P

1
Corretta verifica.
Decadimento beta

4

5. Sapore ECMAScript - 6 byte

^[P^]P

Testato su Regex101 .

È ora di ravvivare un po 'le cose con il set di successo.

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P

Corretta verifica.
FryAmTheEggman,

4

6. Sapore ECMAScript - 9 byte

[^?][PG]$

Testato su Regex101 .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P

1
Corretta verifica.
FireFly,

4

14. Sapore PCRE - 25

([.$?]|G\])\$$|^\^?P|\]P$

Testato su Regex101

Questo sta iniziando a diventare piuttosto difficile.

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Corretta verifica.
Martin Ender,

4

15. Sapore PCRE - 26

([P.$?]\$|[]^]P|G\]\$|CG)$

Testato su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

1
Corretta verifica.
FireFly

4

16. Sapore PCRE - 21

^[^?]*[PG]$|[?$].*\$$

Testato su Regex 101 .

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$

Non corrisponde PPCG.
jimmy23013,

@utente23013 fisso
es1024

Corretta verifica.
jimmy23013,

4

25. Sapore PCRE - 29

^(..[^^].{4,22}\$|[^?]+\w)$|~

Testato qui. (Il regex di test contiene un ulteriore \nper assicurarsi che nessuna corrispondenza si estenda su più righe. Questo non è necessario per abbinare ogni singola stringa.)

Quello era un frutto basso! :) Devo congratularmi con Plannapus, questo regex è incredibilmente elegante per i set di test attuali. Se vuoi votare questa risposta, assicurati di votare anche quella precedente!

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~

1
Corretta verifica.
febbraio

4

35. PCRE - 35 byte

^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

Testato su Regex101

La risposta successiva deve corrispondere alle seguenti stringhe :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E fallire su queste stringhe :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

Il mio verificatore non mostra errori.
Vi.

Corretta verifica. (@Vi., Il dashboard cerca questa frase specifica.)
Martin Ender,

Pensavo di usare quella frase, ma non ero sicuro di voler rendere autorevole il mio commento.
Vi.

La mia altra risposta di 34 caratteri menzionata prima sembra funzionare qui. Aspettando 4 ore (o così) ...
Vi.

Non mi preoccupo di hackerare - lo delego al computer. Magari scrivi un bot per la risposta utilizzando l'API StackExchange? ..
Vi.

4

36. Sapore di pitone - 32

\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

Testato su Regex101

Avevo tre regex a 32 byte pronti e fortunatamente uno di loro funziona ancora: D

La risposta successiva deve corrispondere alle seguenti stringhe:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

E fallire su queste stringhe:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

1
Corretta verifica.
Martin Ender,

Viene anche verificata la correttezza come regex del Perl.
Vi.

Speriamo che la domanda rimanga inattiva fino a domani, poiché ho una risposta in sospeso di 30 caratteri da pubblicare.
Vi.
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.