Sua tarefa aqui é escrever duas expressões regulares, cada uma correspondendo à outra, mas não corresponde a si mesma.

Ambas as expressões regulares devem ter este formato:

/pattern/optional-flags

Essa também é a forma na qual eles devem ser correspondidos.

A solução mais curta vence. O comprimento da solução é contado como a soma dos caracteres nas duas expressões regulares, incluindo barras e sinalizadores.

Use um padrão de sintaxe regex de sua escolha ou especifique uma linguagem de programação, quando isso fizer diferença.

Diverta-se!

PRCE com o modificador A: 9 caracteres

/A$/
/.A/A

Embora essa seja uma variante da /modifier$/resposta de Maçaneta da porta , acho que essa inovação a qualifica como uma resposta separada, e não como um comentário sobre ele: o modificador tem dupla função. Em vez de estar lá apenas para a outra regex corresponder, ela ancora.

O primeiro regex corresponde a qualquer sequência que termina em um literal A. O segundo regex corresponde a qualquer sequência cujo segundo caractere é literal A, usando um sinalizador de âncora para iniciar.

Demonstração online

4 + 6 = pontuação 10

Primeiro regex:

/i$/

Segundo regex:

/^.i/i

Viva por abuso de bandeira! :-P

O primeiro corresponde a qualquer coisa que termine com i(portanto, qualquer regex com o isinalizador).

O segundo corresponde a qualquer coisa com um segundo caractere de i.

Versão alternativa: /i$/ge /g$/i.

Regexes JavaScript, pontuação: 18

Primeiro regex:

/^[^a]+$/

Segundo regex:

/^[^b]+$/

Teste 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

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

Regex em rubi, 15

Expressões regulares:

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

Contando apenas caracteres ...

Versão 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

Primeiro regex:

/i$/

Segundo regex:

/\/$/i

i$corresponde a algo que termina com io segundo. /$corresponde a algo que termina com /, o primeiro.

5 + 5 = 10

Regex # 1:

/0.$/

Regex # 2:

/^.0/

Os 0s em ambos os regexes podem ser substituídos por qualquer não-metacaractere e o regex ainda funciona.

0.$corresponde a qualquer coisa cujo segundo último caractere seja 0e ^.0corresponde a qualquer coisa cujo segundo caractere seja 0.

Regexes JavaScript, pontuação: 13

Primeiro regex:

/\d/

Segundo regex:

/^[^0]+$/

Explicação: o primeiro regex corresponde a tudo que contém um dígito e o segundo regex corresponde a tudo que não contém a 0.

Teste 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

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

12 caracteres ;) JS regex

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

Pontuação: 5 + 5 = 10

Levei meia hora para descobrir, mas estou muito feliz por ter :)

1º é: /j.$/

O segundo é: /^.j/

A primeira corresponde a uma jocorrência na segunda posição, começando pela direita. O segundo corresponde a uma jocorrência na segunda posição, começando da esquerda.

Não testei, mas acho que esses RegExs são realmente versáteis, pois jpodem ser substituídos por qualquer \wcaractere (ou mais?) E ainda devem funcionar bem.

PS Isso deve (espero) funcionar em qualquer idioma. No entanto, se não funcionar em nenhum, por favor, informe nos comentários abaixo :)

Teste

PCRE usando o modificador x: 11 caracteres

/\s/
/ s.$/x

O primeiro corresponde a qualquer sequência com um caractere de espaço em branco, mas não contém espaços em branco. O segundo contém espaço em branco, mas é ignorado por causa do xmodificador; corresponde a qualquer string cujo penúltimo caractere seja s.

PCRE e outros mecanismos usando classes de caracteres: 11 caracteres

/\w+w/
/\Ww/

O primeiro corresponde a qualquer string com um caractere "word" (letra, dígito, sublinhado) seguido por um literal w; o segundo corresponde a qualquer string com um caractere que não seja palavra seguido por um literal w.

PCRE e outros mecanismos que usam classes de caracteres e âncora de limite de palavras: 11 caracteres

/\w\w/
/\bw/

O primeiro corresponde a qualquer string com dois caracteres consecutivos "word"; o segundo qualquer string com um caractere que não seja da palavra ou o início da string seguido por um literal w.

ECMAScript (11 bytes):

/^\1?d/
/\d/

Outros mecanismos REGEXP (14 bytes):

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

O primeiro corresponde a \ d [..] ou \ 1d [..].

O segundo corresponde a qualquer sequência com um número.

EDITAR:

Originalmente, essa resposta foi publicada como sendo compatível com todos os mecanismos, mas provou estar errada.

Houve um problema com as referências aos grupos de captura (por exemplo, em php).