Expressões regulares de correspondência cruzada

21

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!

code-golf regular-expression GOTO 0
fonte
A regex também precisa corresponder às barras e sinalizações da outra regex?
ProgramFOX
@ProgramFOX sim, adicionei uma linha para deixar claro.
GOTO 0 02/02
Você pode definir correspondência? ou seja, o regex /a/corresponde abc?
O cara com o chapéu
2
@TheGuywithTheHat bem, acho que sim, a menos que você escolha um idioma que imponha certas restrições, como a necessidade de corresponder a toda a string. Isso aborda sua preocupação?
GOTO 0 02/02
11
Para ser claro: suponho que o uso de diferentes delimitadores (como permitido por exemplo, PHP PCRE) não é permitido? (Ou seja, sem a apresentação /^%/e %^/%)
Peter Taylor

Respostas:

7

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

Peter Taylor
fonte
3
Para superar isso, são necessários apenas quatro caracteres não-delimitadores e, como //corresponde a qualquer coisa que significa que cada uma das expressões regulares pode ter no máximo três caracteres não-delimitadores. Usando o PHP PCRE, existem 73339 regexes não correspondentes dentro dessa restrição, e a verificação exaustiva dos pares cujo comprimento é menor que 10 (da ordem de 32Mpairs em vez de 5.7Gpairs porque a maioria deles tem 5 caracteres incluindo delimitadores) aparece esta solução e nenhuma outra. Por isso, afirmo que é ideal para esse mecanismo regex específico.
Peter Taylor
18

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.

Maçaneta da porta
fonte
3
Outra variação seria /x.$/e /^.x/para um monte de x
shiona
Ou /i$/e/\/$/i
Peter Taylor
Ou /i$/e/i\$/i
Peter Taylor
6

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/

ProgramFOX
fonte
5

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
David Herrmann
fonte
5

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.

Justin
fonte
2
Dupe de um comentário que postei na resposta da maçaneta da porta.
Peter Taylor
@PeterTaylor Não percebeu os comentários até agora. Essas foram descobertas independentes.
Justin
Sim, eu também descobri a versão de shiona de forma independente.
Peter Taylor
3

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.

Justin
fonte
2
O primeiro par não é uma expressão válida: você precisa escapar dos /es. A alternativa é um engano de um comentário sobre a resposta da maçaneta da porta.
Peter Taylor
2

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/

ProgramFOX
fonte
2

12 caracteres ;) JS regex

/\d/
/0?\/$/g
Andrew Templeton
fonte
2

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

Gaurang Tandon
fonte
E descubro agora que o @Quiccunx já postou a mesma versão que a minha. Sinto muito pelo Quiccunx e, se houver, excluirei minha resposta.
Gaurang Tandon
1

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.

Peter Taylor
fonte
-1

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).

Ismael Miguel
fonte
Muitos mecanismos de regex aceitam o regex sem barras circunvizinhas, mas a questão é bastante clara ao exigir que sejam contados.
Peter Taylor
Não estou contando isso como resposta. Deixe-me adicionar a nota para isso.
Ismael Miguel
11
@PeterTaylor Adicionei a nota. A versão do Apache está lá apenas porque.
Ismael Miguel
Espere: em quais mecanismos o primeiro analisa e \1não é interpretado como uma referência posterior?
Peter Taylor
Dependendo da maneira como você o usa. No php, por exemplo, se você colocar dentro "/^\1?d/", terá problemas, mas se o fizer '/^\1?d/', tudo bem. As aspas fazem uma enorme diferença quando o código é interpretado.
Ismael Miguel