Votre tâche consiste à écrire deux expressions régulières, chacune correspondant à l'autre mais ne correspondant pas à elle-même.

Les deux expressions régulières doivent avoir cette forme:

/pattern/optional-flags

C'est également la forme sous laquelle ils doivent être appariés.

La solution la plus courte l'emporte. La longueur de la solution est comptée comme la somme des caractères dans les deux expressions régulières, y compris les barres obliques et les indicateurs.

Utilisez une norme de syntaxe regex de votre choix ou spécifiez un langage de programmation lorsque cela fait une différence.

S'amuser!

PRCE avec le modificateur A: 9 caractères

/A$/
/.A/A

Bien qu'il s'agisse d'une variante de la /modifier$/réponse de Doorknob , je pense que cette innovation la qualifie de réponse distincte plutôt que de commentaire sur la sienne: le modificateur fait double usage. Plutôt que d'être là uniquement pour que les autres expressions rationnelles correspondent, il s'ancre.

La première expression régulière correspond à toute chaîne se terminant par un littéral A. La deuxième expression régulière correspond à n'importe quelle chaîne dont le deuxième caractère est un littéral A, à l'aide d'un indicateur d'ancrage au début.

Démo en ligne

4 + 6 = score de 10

Première expression régulière:

/i$/

Deuxième expression régulière:

/^.i/i

Hourra pour abus de drapeau! :-P

Le premier correspond à tout ce qui se termine par i(donc, toute expression régulière avec le idrapeau).

Le second correspond à n'importe quoi avec un deuxième caractère de i.

Version alternative: /i$/get /g$/i.

Regexes JavaScript, score: 18

Première expression régulière:

/^[^a]+$/

Deuxième expression régulière:

/^[^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

Testez en ligne: http://jsfiddle.net/99Sx6/

Ruby regex, 15

Expressions régulières:

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

Juste compter les personnages ...

Version en ligne

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

Première expression régulière:

/i$/

Deuxième expression régulière:

/\/$/i

i$correspond à quelque chose qui se termine par i, le second. /$correspond à quelque chose qui se termine par /, le premier.

5 + 5 = 10

Regex # 1:

/0.$/

Regex # 2:

/^.0/

Le 0s dans les deux expressions régulières peut être remplacé par n'importe quel non-métacaractère et l'expression régulière fonctionne toujours.

0.$correspond à tout ce dont le dernier caractère est 0, et ^.0correspond à tout ce dont le deuxième caractère est 0.

Regexes JavaScript, score: 13

Première expression régulière:

/\d/

Deuxième expression régulière:

/^[^0]+$/

Explication: le premier regex correspond à tout ce qui contient un chiffre, et le second regex correspond à tout ce qui ne contient pas de 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

Testez en ligne: http://jsfiddle.net/5VYjC/1/

12 caractères ;) JS regex

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

Score: 5 + 5 = 10

Cela m'a pris une demi-heure pour comprendre mais je suis vraiment heureux de l'avoir fait :)

1er est: /j.$/

2e est: /^.j/

Le 1er correspondait à un jsurvenant en deuxième position en partant de la droite. Le 2e correspond à un jsurvenant en deuxième position à partir de la gauche.

Je n'ai pas testé mais je pense que ces RegEx sont vraiment polyvalents car ils jpeuvent être remplacés par n'importe quel \wcaractère (ou plus?) Et devraient toujours fonctionner correctement.

PS Cela devrait (espérons-le) fonctionner dans n'importe quelle langue. Cependant, si cela ne fonctionne pas, veuillez en informer dans les commentaires ci-dessous :)

Tester

PCRE utilisant le modificateur x: 11 caractères

/\s/
/ s.$/x

La première correspond à n'importe quelle chaîne avec un caractère d'espace, mais ne contient pas d'espace. Le second contient des espaces, mais il est ignoré en raison du xmodificateur; il correspond à n'importe quelle chaîne dont l'avant-dernier caractère est s.

PCRE et autres moteurs utilisant des classes de caractères: 11 caractères

/\w+w/
/\Ww/

La première correspond à n'importe quelle chaîne avec un caractère "mot" (lettre, chiffre, trait de soulignement) suivi d'un littéral w; la seconde correspond à n'importe quelle chaîne avec un caractère autre qu'un mot suivi d'un littéral w.

PCRE et autres moteurs utilisant les classes de caractères et l'ancrage des limites de mots: 11 caractères

/\w\w/
/\bw/

La première correspond à n'importe quelle chaîne avec deux caractères "mot" consécutifs; la seconde toute chaîne avec un caractère non mot ou début de chaîne suivi d'un littéral w.

ECMAScript (11 octets):

/^\1?d/
/\d/

Autres moteurs REGEXP (14 octets):

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

Le 1er correspond à \ d [..] ou \ 1d [..].

La seconde correspond à n'importe quelle chaîne avec un nombre.

ÉDITER:

À l'origine, cette réponse a été publiée comme étant compatible avec tous les moteurs, mais elle s'est avérée erronée.

Il y avait un problème avec les références aux groupes de capture (par exemple, en php).