Riscaldamento: Regex, carta, forbici

Questa è la sfida che inizialmente volevo pubblicare, prima di rendermi conto che esiste una soluzione molto breve. Tuttavia, può essere un problema interessante a cui pensare in preparazione della sfida reale di seguito.

Scrivi tre regex R , P e S in modo tale che si abbinino l'un l'altro in modo ciclico Rock, Paper, Scissors. In particolare, R corrisponde S , S corrisponde P e P corrisponde R , ma R non corrisponde P , S non corrisponde R e P non corrisponde S . Ecco una tabella pratica:

Regex   Matches   Doesn't match
R       S         P
P       R         S
S       P         R

Non importa cosa fanno R , P e S su qualsiasi altro input, inclusi loro stessi.

Qui, match significa solo che una sottostringa (possibilmente vuota) dell'input è abbinata. La partita non deve coprire l'intero input.

La sfida: Regex, Paper, Scissors, Lizard, Spock

Per questa sfida, risolverai una versione più difficile del problema sopra, basato sulla variante RPS Rock, Paper, Scissors, Lizard, Spock (come reso popolare da The Big Bang Theory ). In RPSLV, ci sono cinque simboli diversi, che si battono l'un l'altro in due cicli:

• Roccia → Forbici → Lucertola → Carta → Spock → Roccia
• Roccia → Lucertola → Spock → Forbici → Carta → Roccia

Dovresti scrivere cinque regex R , P , S , L e V che imitano questa struttura quando vengono date l'una all'altra come input. Ecco la tabella corrispondente:

Regex   Matches   Doesn't match
R       L, S      V, P
L       V, P      S, R
V       S, R      P, L
S       P, L      R, V
P       R, V      L, S

Giusto per essere chiari, si dovrebbe non corrispondono con la stringa R, Pecc, ma gli altri regex. Ad esempio, se la tua regex R è ^\w$ad esempio, allora P e V devono corrispondere alla stringa ^\w$, mentre S e L non dovrebbero.

Ancora una volta, match significa solo che almeno una sottostringa (possibilmente vuota) dell'input è abbinata. La partita non deve coprire l'intero input. Ad esempio \b(limite di parole) corrisponde hello(all'inizio e alla fine), ma non corrisponde (^,^).

È possibile utilizzare qualsiasi sapore regex, ma si prega di indicare la scelta nella risposta e, se possibile, fornire un collegamento a un tester online per il sapore scelto. Non puoi usare alcuna funzione regex che ti consenta di invocare il codice nella lingua host del flavour (come il emodificatore del flavour Perl ).

I delimitatori (come /regex/) non sono inclusi nel regex quando vengono forniti come input a un altro e non è possibile utilizzare modificatori esterni al regex. Alcuni sapori consentono ancora di utilizzare modificatori con sintassi inline come (?s).

Il tuo punteggio è la somma delle lunghezze delle cinque regex in byte. È meglio più basso.

Risulta molto più semplice trovare una soluzione funzionante a questo problema di quanto possa sembrare all'inizio, ma spero che trovare una soluzione ottimale sia piuttosto complicato.

PCRE .NET, 35 32 byte

-3 byte grazie a Martin Ender

Roccia:

([*?]$)

Carta:

[)$]$+

Forbici:

[+?]$.*

Lucertola:

[+$]$.?

Spock:

[*)]$

L'idea qui è quella di abbinare i personaggi alla fine di altre regex che sono riservati ai regex, ma smettono di essere trattati come tali all'interno di una classe di caratteri.

PCRE, 15 14 byte

Roccia:
B

Carta:
\b$

Forbici:
b|B.

Lucertola:
\B.

Spock:
^\w

nessuna funzionalità di fantasia, 35 30 byte

5 byte salvati dall'idea di Neil che utilizza ciò che ]non ha bisogno di \.

Funziona ad esempio con il remodulo Python .

R='[SLR]]'
P='[RVP]]'
S='[PLS]]'
L='[PVL]]'
V='[SRV]]'

Cerca un ]preceduto da una lettera che indica quale regola è.

Versione precedente utilizzata R='\[[RSL]'ecc.

Un precedente tentativo con il punteggio 40 stava usando R='[SL]x|Rx'ecc.

PCRE, 20 19

Roccia

W

Carta

^\w

Forbici

^\W

Spock

w?\x57$

Lucertola

[w]W?

20 byte

R = 'R|VP'
L = 'L|RS'
V = 'V|LP'
S = 'S|RV'
P = 'P|LS'

JavaScript, 45 byte

Un'altra soluzione banale.

R:
^R|^.[SL]
P:
^P|^.[RV]
S:
^S|^.[PL]
L:
^L|^.[PV]
V:
^V|^.[SR]

POSIX, 50 45 byte

Rock
.{5}RP?V?
Paper
.{5}PS?L?
Scissors
.{5}SR?V?
Lizard
.{5}LR?S?
Vulcan (Spock)
.{5}VP?L?

Potrebbe essere più breve ma il trucco (nascondi le partite dopo $) è stato usato, quindi sto cercando un altro modo

I primi 5 caratteri di ogni stringa vengono ignorati durante la corrispondenza. Quindi la stringa target effettiva si semplifica fino a X? Y ?. Nessuno di loro ha doppie lettere perché "?" è un carattere ordinario, quindi gli ultimi 4 caratteri quando usati come regex devono corrispondere (stringa nulla). Quindi i modelli collassano fino a "contiene 5 caratteri seguiti dalla lettera di destinazione": significa che i caratteri 6-9 della destinazione devono contenere la lettera di destinazione (il 5 ° carattere in ogni stringa)

Aggiornamento: versione di 35 byte in basso, ora!

PCRE, 65 byte

Questa è una soluzione davvero banale - e non molto intelligente - ma proverò a giocarci a golf.

V:

(?#V).+[SR]\)

L:

(?#L).+[PV]\)

S:

(?#S).+[PL]\)

P:

(?#P).+[RV]\)

R:

(?#R).+[SL]\)

In sostanza, ogni regex ha un 'identificatore', sotto forma di un commento, che dice agli altri regex se deve essere abbinato o meno.

.NET, 50 byte

Per lo sono R, P, S, L, V.

[^R]\^[SL]
[^P]\^[RV]
[^S]\^[PL]
[^L]\^[PV]
[^V]\^[SR]

Funziona cercando il gruppo di identificatori (ad esempio, [^R]) in ciascuna delle altre espressioni.

Cambiare le espressioni in ^R|\^[SL], o simili, sembra funzionare, ma è un po 'troppo simile alla risposta di @dzaima, anche se la porterebbe a 45 byte.

Vanilla RE, 40 caratteri

Non è la soluzione più concisa o elegante ma ha una piacevole struttura visiva quasi semantica!

[^r][sl]
[^p][vr]
[^s][lp]
[^l][pv]
[^v][rs]

Battiti di roccia Forbici di
carta o lucertola Battiti di carta di Vulcan o Rock
Scissors Battiti di lucertola o di carta
Battiti di lucertola di carta o Vulcan
Battiti di pietra o di Vulcan

POSIX, 35 byte

Rock
R?^[LS]
Paper
P?^[RV]
Scissors
S?^[LP]
Lizard
L?^[PV]
Vulcan (Spock)
V?^[RS]

Un modo completamente diverso di "nascondere" dietro un simbolo di inizio / fine, quindi mi sento bene su di esso :) Sto abbinando l'inizio perché "?" dovrebbe sempre andare tra lettera e fine / $ se fatto diversamente.

10 byte in meno rispetto alla mia prima soluzione, e concettualmente semplice che è un bonus che mi piace.