Su tarea aquí es escribir dos expresiones regulares, cada una de las cuales coincide con la otra pero no concuerda.

Ambas expresiones regulares deberían tener esta forma:

/pattern/optional-flags

Esta es también la forma en que deben coincidir.

La solución más corta gana. La longitud de la solución se cuenta como la suma de caracteres en ambas expresiones regulares, incluidas las barras inclinadas y las banderas.

Utilice un estándar de sintaxis de expresiones regulares de su elección, o especifique un lenguaje de programación, cuando haga la diferencia.

¡Que te diviertas!

PRCE con el modificador A: 9 caracteres

/A$/
/.A/A

Aunque esta es una variante del pomo de la puerta /modifier$/ respuesta , creo que esta innovación lo califica como una respuesta separada en lugar de un comentario sobre la suya: el modificador cumple una doble función. En lugar de estar allí solo para que coincida la otra expresión regular, se ancla.

La primera expresión regular coincide con cualquier cadena que termine en un literal A. La segunda expresión regular coincide con cualquier cadena cuyo segundo carácter es un literal A, utilizando un indicador de inicio de anclaje.

Demostración en línea

4 + 6 = puntaje de 10

Primera expresión regular:

/i$/

Segunda expresión regular:

/^.i/i

¡Hurra por el abuso de la bandera! :-PAGS

El primero coincide con todo lo que termina con i(por lo tanto, cualquier expresión regular con la ibandera).

El segundo coincide con cualquier cosa con un segundo personaje de i.

Versión alternativa: /i$/gy /g$/i.

JavaScript regexes, puntuación: 18

Primera expresión regular:

/^[^a]+$/

Segunda expresión regular:

/^[^b]+$/

Prueba de 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

Prueba en línea: http://jsfiddle.net/99Sx6/

Ruby regex, 15

Expresiones regulares:

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

Solo contando personajes ...

Versión en línea

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

Primera expresión regular:

/i$/

Segunda expresión regular:

/\/$/i

i$coincide con algo que termina con iel segundo. /$coincide con algo que termina con /el primero.

5 + 5 = 10

Regex # 1:

/0.$/

Regex # 2:

/^.0/

los 0 s en ambas expresiones regulares se puede reemplazar con cualquier no-metacarácter y la expresión regular todavía funciona.

0.$coincide con cualquier cosa cuyo segundo último carácter es 0, y ^.0coincide con cualquier cosa cuyo segundo carácter es 0.

JavaScript regexes, puntuación: 13

Primera expresión regular:

/\d/

Segunda expresión regular:

/^[^0]+$/

Explicación: la primera expresión regular coincide con todo lo que contiene un dígito, y la segunda expresión regular coincide con todo lo que no contiene un 0.

Prueba de 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

Prueba en línea: http://jsfiddle.net/5VYjC/1/

12 caracteres ;) JS regex

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

Puntuación: 5 + 5 = 10

Me tomó media hora averiguarlo, pero estoy muy feliz de haberlo hecho :)

Primero es: /j.$/

2do es: /^.j/

El primero coincidió con el que jocurrió en la segunda posición comenzando desde la derecha. El segundo coincide con el que jocurre en la segunda posición desde la izquierda.

No lo he probado, pero creo que estos RegEx son realmente versátiles, ya que jse pueden reemplazar con cualquier \wcarácter (¿o más?) Y aún así deberían funcionar bien.

PD: Esto (con suerte) debería funcionar en cualquier idioma. Sin embargo, si no funciona en ninguno, informe en los comentarios a continuación :)

Prueba

PCRE usando el modificador x: 11 caracteres

/\s/
/ s.$/x

El primero coincide con cualquier cadena con un carácter de espacio en blanco, pero no contiene espacios en blanco. El segundo contiene espacios en blanco, pero se ignora debido al xmodificador; coincide con cualquier cadena cuyo penúltimo carácter sea s.

PCRE y otros motores que usan clases de caracteres: 11 caracteres

/\w+w/
/\Ww/

El primero coincide con cualquier cadena con un carácter de "palabra" (letra, dígito, guión bajo) seguido de un literal w; el segundo coincide con cualquier cadena con un carácter que no sea de palabra seguido de un literal w.

PCRE y otros motores que usan clases de caracteres y ancla de límite de palabra: 11 caracteres

/\w\w/
/\bw/

El primero coincide con cualquier cadena con dos caracteres consecutivos de "palabra"; el segundo, cualquier cadena con un carácter que no sea de palabra o inicio de cadena seguido de un literal w.

ECMAScript (11 bytes):

/^\1?d/
/\d/

Otros motores REGEXP (14 bytes):

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

Los primeros partidos \ d [..] o \ 1d [..].

El segundo coincide con cualquier cadena con un número.

EDITAR:

Originalmente, esta respuesta se publicó como compatible con todos los motores, pero se demostró que era incorrecta.

Hubo un problema con las referencias a los grupos de captura (por ejemplo, en php).