Il tuo compito qui è scrivere due espressioni regolari, ognuna delle quali corrisponde all'altra ma non corrisponde a se stessa.

Entrambe le espressioni regolari dovrebbero avere questa forma:

/pattern/optional-flags

Questa è anche la forma in cui dovrebbero essere abbinati.

Vince la soluzione più breve. La lunghezza della soluzione viene conteggiata come la somma di caratteri in entrambe le espressioni regolari inclusi barre e flag.

Utilizzare uno standard di sintassi regex di propria scelta o specificare un linguaggio di programmazione, quando fa la differenza.

Divertiti!

PRCE con il modificatore A: 9 caratteri

/A$/
/.A/A

Sebbene questa sia una variante della /modifier$/risposta di Doorknob , penso che questa innovazione la qualifichi come una risposta separata piuttosto che un commento sulla sua: il modificatore fa il doppio dovere. Piuttosto che essere lì solo per far coincidere l'altro regex, si ancora.

Il primo regex corrisponde a qualsiasi stringa che termina in un letterale A. La seconda regex corrisponde a qualsiasi stringa il cui secondo carattere è letterale A, usando un flag anchor-to-start.

Demo online

4 + 6 = punteggio di 10

Primo regex:

/i$/

Seconda regex:

/^.i/i

Evviva per abuso di bandiera! :-P

Il primo corrisponde a tutto ciò che termina i(quindi, qualsiasi regex con la ibandiera).

Il secondo corrisponde a qualsiasi cosa con un secondo carattere di i.

Versione alternativa: /i$/ge /g$/i.

Regex JavaScript, punteggio: 18

Primo regex:

/^[^a]+$/

Seconda regex:

/^[^b]+$/

Test JavaScript:

var regex1 = "/^[^a]+$/";
var regex2 = "/^[^b]+$/";
alert(/^[^a]+$/.test(regex2)); // true: regex1 matches regex2
alert(/^[^b]+$/.test(regex1)); // true: regex2 matches regex1
alert(/^[^a]+$/.test(regex1)); // false: regex1 doesn't match regex1
alert(/^[^b]+$/.test(regex2)); // false: regex2 doesn't match regex2

Test online: http://jsfiddle.net/99Sx6/

Ruby regex, 15

Espressioni regolari:

/.{9}/
/^.{06}$/

Solo contando i personaggi ...

Versione online

r1 = '/.{9}/'
r2 = '/^.{06}$/'

p r1 =~ /^.{06}$/ #0:   r2 matches r1
p r2 =~ /.{9}/    #0:   r1 matches r2
p r1 =~ /.{9}/    #nil: r1 doesn't match r1
p r2 =~ /^.{06}$/ #nil: r2 doesn't match r2

4 + 6 = 10

Primo regex:

/i$/

Seconda regex:

/\/$/i

i$corrisponde a qualcosa che termina i, il secondo. /$corrisponde a qualcosa che termina /, il primo.

5 + 5 = 10

Regex # 1:

/0.$/

Regex # 2:

/^.0/

Le 0s in entrambi i regex possono essere sostituite con qualsiasi non metacarattere e il regex funziona ancora.

0.$corrisponde a tutto il cui ultimo carattere è 0e ^.0corrisponde a tutto il cui secondo carattere è 0.

Regex JavaScript, punteggio: 13

Primo regex:

/\d/

Seconda regex:

/^[^0]+$/

Spiegazione: il primo regex corrisponde a tutto ciò che contiene una cifra e il secondo regex corrisponde a tutto ciò che non contiene a 0.

Test JavaScript:

var regex1 = "/\d/";
var regex2 = "/^[^0]+$/";
alert(/\d/.test(regex2)); // true: regex1 matches regex2
alert(/^[^0]+$/.test(regex1)); // true: regex2 matches regex1
alert(/\d/.test(regex1)); // false: regex1 doesn't match regex1
alert(/^[^0]+$/.test(regex2)); // false: regex2 doesn't math regex2

Test online: http://jsfiddle.net/5VYjC/1/

12 caratteri ;) JS regex

/\d/
/0?\/$/g

Punteggio: 5 + 5 = 10

Mi ci sono voluti mezz'ora per capire ma sono davvero felice di averlo fatto :)

Il primo è: /j.$/

Il secondo è: /^.j/

Il primo corrisponde a un javvenimento nella seconda posizione a partire da destra. Il 2 ° corrisponde a un javvenimento in seconda posizione a partire da sinistra.

Non ho testato ma penso che questi RegEx siano davvero versatili in quanto jpossono essere sostituiti con qualsiasi \wpersonaggio (o più?) E dovrebbero comunque funzionare bene.

PS Questo dovrebbe (si spera) funzionare in qualsiasi lingua. Tuttavia, se non funziona in nessuno, si prega di informare nei commenti qui sotto :)

Test

PCRE usando il modificatore x: 11 caratteri

/\s/
/ s.$/x

Il primo corrisponde a qualsiasi stringa con un carattere di spazi bianchi, ma non contiene spazi bianchi. Il secondo contiene spazi bianchi, ma viene ignorato a causa del xmodificatore; corrisponde a qualsiasi stringa il cui penultimo carattere è s.

PCRE e altri motori che usano classi di caratteri: 11 caratteri

/\w+w/
/\Ww/

Il primo corrisponde a qualsiasi stringa con un carattere "parola" (lettera, cifra, trattino basso) seguito da un valore letterale w; il secondo corrisponde a qualsiasi stringa con un carattere non verbale seguito da un valore letterale w.

PCRE e altri motori che utilizzano le classi di caratteri e l'ancoraggio al limite delle parole: 11 caratteri

/\w\w/
/\bw/

Il primo corrisponde a qualsiasi stringa con due caratteri "parola" consecutivi; la seconda qualsiasi stringa con un carattere non verbale o inizio della stringa seguita da un valore letterale w.

ECMAScript (11 byte):

/^\1?d/
/\d/

Altri motori REGEXP (14 byte):

/^\\\\1?d/
/\d/

La prima corrispondenza \ d [..] o \ 1d [..].

Il secondo corrisponde a qualsiasi stringa con un numero.

MODIFICARE:

Inizialmente, questa risposta è stata pubblicata come compatibile con tutti i motori, ma si è dimostrata sbagliata.

Si è verificato un problema con i riferimenti ai gruppi di acquisizione (ad esempio, in php).