Um tipo diferente de Meta Regex Golf


42

Aviso: Após a demanda popular, relaxei um pouco as regras:

  • O tamanho máximo de regex cresce 1 byte a cada 5 respostas . A resposta N pode usar até 29 + ⌈N / 5⌉ bytes.
  • A pontuação de cada resposta será (M / (30 + N / 5)) N

No regex golf, você recebe dois conjuntos de strings e é solicitado a criar o menor regex que corresponda a todas as strings no primeiro conjunto, mas que falhe em todas as strings no segundo conjunto.

É isso que vamos fazer, mas cada vez que alguém responder, a própria expressão regular será adicionada a um dos dois conjuntos de strings (de sua própria escolha). Portanto, há uma ordem estrita de respostas nesse desafio.

Vamos passar por um exemplo:

  • Digamos que eu comece com isso abc(o que não vou) e coloque-o no conjunto de correspondências .
  • Em seguida, uma segunda resposta válida seria a, pois corresponde ao acima (e não há seqüências que precisem falhar ainda). Digamos que esta resposta esteja no conjunto de falhas .
  • Agora a terceira resposta precisa corresponder, abcmas falha a. Uma terceira resposta possível é, portanto b. Vamos colocar isso no conjunto de fósforos .
  • A quarta resposta agora precisa corresponder abce b, mas falha a. Não permitiremos respostas duplicadas, portanto, uma regex válida seria c|b.

O importante é que sua resposta seja a mais curta possível. Isso pode ser trivial para as primeiras respostas, mas uma vez que recebemos algumas respostas, deve ser cada vez mais difícil obter a correspondência desejada com o menor número possível de caracteres.

Para o desafio real, inicialmente o conjunto de correspondências contém PPCGe o conjunto de falhas contém [PPCG], e eu já forneci a primeira resposta.

Respondendo

O principal a entender sobre esse desafio é que apenas uma pessoa pode responder de cada vez e cada resposta depende da resposta anterior .

Nunca deve haver duas respostas com o mesmo N. Se duas pessoas responderem simultaneamente a algumas N, quem responder mais tarde (mesmo que seja uma diferença de alguns segundos) deve excluir graciosamente sua resposta.

Para tornar isso um pouco mais suave, tente seguir as etapas abaixo ao postar sua resposta:

  • Certifique-se de que alguém tenha verificado independentemente a exatidão da resposta anterior (e deixado um comentário correspondente).
  • Faça os dois conjuntos de testes encontrados na resposta anterior e escreva um regex que corresponda a todas as seqüências de caracteres em um conjunto e nenhuma no outro.
  • Poste sua resposta no seguinte formato:

    # N. [regex flavour] - [regex size in bytes]
    
        [regex]
    
    [link to online regex tester]
    
    [notes, explanation, observations, whatever]
    
    ### The next answer has to match the following strings:
    
        [match set]
    
    ### And fail on these strings:
    
        [fail set]
    

    Onde Nestá o número da sua resposta. Copie [match set]e [fail set]da resposta anterior e anexe seu regex a um deles.

    Isso é absolutamente vital para o desafio! Forneci uma ferramenta de painel para o desafio de ajudar na contabilidade e ela se baseia no modelo acima. (Veja a parte inferior da postagem.)

  • Outro usuário agora deve revisar seu envio e deixar um comentário "Correção verificada" se sua resposta seguir todas as regras (veja abaixo). Caso contrário, eles devem deixar um comentário indicando falhas. Você tem 15 minutos para corrigir esses problemas. Caso contrário, sua resposta será considerada inválida, deverá ser excluída e outra pessoa poderá postar uma resposta de acompanhamento na resposta anterior. (Se isso acontecer, você poderá enviar uma nova resposta a qualquer momento.)

Esses regulamentos podem parecer bastante rígidos, mas são necessários para evitar respostas inválidas em algum lugar da cadeia.

Regras

  • Um usuário pode enviar apenas uma resposta por período de 4 horas. (Isso evita que os usuários assistam constantemente à pergunta e respondam o máximo possível.)
  • Um usuário não pode enviar duas respostas seguidas. (por exemplo, desde que eu enviei a resposta 1, não posso responder 2, mas poderia fazer 3.)
  • Não edite respostas que foram verificadas. (Mesmo que você encontre uma maneira de reduzi-lo!)
  • Se um erro for descoberto mais cedo na cadeia (ou seja, após as respostas terem sido postadas), a resposta incorreta deve ser excluída e será removida do conjunto de strings em que os novos envios devem falhar. No entanto , todas as respostas postadas desde então não devem ser alteradas para refletir.
  • Indique claramente um sabor em que sua regex é válida. Você pode escolher qualquer sabor que possa ser testado on-line gratuitamente. Há uma boa lista de testadores on - line no StackOverflow . Em particular, o Regex101 e o RegexPlanet devem ser úteis, pois oferecem suporte a uma ampla variedade de sabores. Inclua um link para o testador que você escolheu na sua resposta. Ao ativar os modificadores lobal ge multilina no testador, você pode testar todas as cadeias de uma vez, uma em cada linha (esses modificadores não são contados no tamanho do seu regex, porque não são necessários em nenhuma cadeia individual).
  • Sua regex não deve estar vazia.
  • O seu regex para a resposta N não deve exceder 29 + ⌈N / 5⌉ bytes. Ou seja, as respostas 1 a 5 podem usar até 30 bytes (inclusive), as respostas 6 a 10 podem usar até 31 bytes ... as respostas 31 a 35 podem usar até 36 bytes. Verifique o painel para ver quantos caracteres a próxima resposta pode usar.
  • Sua regex não deve ser idêntica a nenhuma sequência em nenhum conjunto de testes.
  • Não inclua delimitadores no seu envio ou na contagem de bytes, mesmo que o idioma do host relevante os use. Se o seu regex usa modificadores, adicione um byte por modificador ao tamanho do regex. Por exemplo, /foo/iseria 4 bytes.

Pontuação

A pontuação de cada resposta é calculada como (M / (30 + N / 5)) N , onde M é o tamanho da expressão regular em bytes e N é o número. A pontuação de cada usuário é o produto de todas as suas respostas. O usuário com a menor pontuação geral vence. No improvável evento de empate, o usuário com o último envio vence. Aceitarei a resposta mais recente desse usuário.

Se você preferir somar pontuações, pode calcular a pontuação de cada resposta como N * (log (M) - log (30)) e resumi-las sobre todas as respostas. Isso dará a mesma ordem de classificação.

Não há necessidade de incluir a pontuação de uma resposta na resposta, apenas relatar M . O painel de desafio na parte inferior da pergunta calculará as pontuações e, no caso de duas pontuações muito próximas, verificarei novamente os resultados usando tipos de precisão arbitrária.

Observe que a pontuação de cada resposta é menor que 1, para que você possa melhorar sua pontuação geral fornecendo uma nova resposta. No entanto, quanto mais curtos forem os envios, mais eficientemente você poderá diminuir sua pontuação. Além disso, respostas posteriores podem alcançar uma pontuação mais baixa, embora sejam mais longas, devido ao crescente expoente.

painel de controle

Escrevi uma pequena ferramenta do Dashboard, usando Stack Snippets, com base no trabalho do Optimizer aqui . Espero que isso nos ajude a obter alguma ordem para esses desafios que dependem de respostas.

Isso exibirá o status atual do desafio - em particular, se houver respostas conflitantes, se uma resposta precisar ser verificada ou se a próxima resposta puder ser publicada.

Também produz uma lista de todas as respostas com pontuações, bem como uma tabela de classificação de todos os usuários. Atenha-se ao formato do desafio acima, para que o painel possa ler as sequências relevantes de suas respostas. Caso contrário, você pode não ser incluído na tabela de classificação.

Informe-me (de preferência no bate-papo ) se você encontrar algum erro ou tiver alguma idéia de como a utilidade da ferramenta pode ser melhorada.


As regras acabaram sendo um pouco mais rígidas do que eu pretendia. Depois de alguma discussão no chat, estou pensando em relaxar as regras um pouco depois que a recompensa acabar. Vou postar 3 comentários para as opções que posso pensar abaixo. Por favor, indique sua preferência votando nos comentários.
Martin Ender

2
Regras são regras. Não os mude. Pode ser uma pena que seja praticamente impossível postar outra resposta, mas isso não justifica a alteração das regras.
Martin Ender

2
Permita um byte adicional a cada 10 respostas. Correspondentemente, alterar a pontuação resposta para (M / (30 + N / 10)) ^ N . Isso seria aplicado retroativamente, para que a próxima resposta pudesse usar até 32 bytes. A mudança na pontuação não afetaria os dois primeiros lugares na tabela de classificação, mas os outros usuários seriam embaralhados um pouco.
Martin Ender

8
Permita um byte adicional a cada 5 respostas. Correspondentemente, alterar a pontuação resposta para (M / (30 + N / 5)) ^ N . Isso seria aplicado retroativamente, para que a próxima resposta pudesse usar até 35 bytes. A mudança na pontuação não afetaria os dois primeiros lugares na tabela de classificação, mas os outros usuários seriam embaralhados um pouco.
Martin Ender

4
Vocês são estranhos e distorcidos. Por que vocês fariam isso sozinhos? (É divertido ler que: P)
Joe

Respostas:


5

42. sabor Python - 38

\?[^w$]*\$$|^P|\w.\)|w.?\+|w\^|[^?P]P$

Testado no Regex101

A falta de entropia nas últimas respostas estava me atingindo ... (deveria ter feito isso antes)

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)
\w.\)|\?[^-$]*\$$|[]^C]\w$|w[+^]
[]^C]\w$|\w.\)|-\$|w[+^]|\?[^w$]*\$$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)
\$..\\|\?[^w$]*\$$|w\^|[]^C]\w$
[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$
\?[^w$]*\$$|^P|\w.\)|w.?\+|w\^|[^?P]P$

Correção verificada.
Martin Ender

Meu programa luta para encontrar uma resposta com menos de 45 caracteres ...
Vi.

@Vi. Bem, eu posso dizer que uma solução 38 faz existir, pelo menos, mas é claro que seria interessante se alguém consegue menor :)
SP3000

11

28. sabor Python - 29

\.\)|P[.$?]|w\^|^[^|C\\]*$|^P

Testado no Regex101

Muitas brincadeiras foram feitas - o número 4 no conjunto de passes provavelmente é a maior dor, pois é uma subcadeia de uma regex no conjunto de falhas e também compartilha um sufixo com outro regex no conjunto de falhas.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\

Correção verificada.
quer

9

24 - Sabor Python - 29

^(..[^^].{4,22}\$|[^?]+\w)$|2

Testado aqui

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2

1
Correção verificada.
feersum

8

10. sabor Python - 19

^[\w^]*$|!|]P|G]\$$

Testado no Regex101 .

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Correção verificada.
FryAmTheEggman 13/11

8

8. sabor ECMAScript - 14 bytes

[^?][PG]$|<|PG

Demo

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG

Correção verificada.
FryAmTheEggman 13/11

Corrigido o link da demonstração.
Martin Ender

@FryAmTheEggman O script lê os comentários, mas procura apenas "correção verificada" como uma sub- string (ignorando maiúsculas e minúsculas).
Martin Ender

@ MartinBüttner Obrigado, bom saber.
FryAmTheEggman

3
+1 para tornar o desafio 10 vezes mais difícil
sozinho

7

2. sabor ECMAScript - 6 bytes

^[P\^]

Teste aqui

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P

E falhe nessas strings:

[PPCG]
^[P\^]

1
Correção verificada.
Martin Ender

7

9. sabor Python - 28

^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Testado no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)*[^\\|]*[^\]]$

Também achei que isso não funcionava um minuto atrás. Requer duas barras invertidas seguidas para corresponder, portanto, não acho que uma bandeira possa salvá-la.
feersum

Opa .... Deveria ter sido um * em vez de +. Eu editei minha resposta
ndc5057

Correção verificada.
FryAmTheEggman # 13/1114

7

23. sabor PCRE - 28

([^\\}<]{3}|][^]]|^).?[$PG]$

Testado no Regex101.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$

O que [^]faz?
feersum

@feersum Na maioria dos tipos, a ]como o primeiro elemento de uma classe de personagem (após negação opcional), é apenas um elemento ]dentro da classe de personagem e não fecha (porque as classes de caracteres vazias são um pouco inúteis). Então [^]]combina com qualquer coisa menos ]. A exceção notável é ECMAScript, que permite classes de caracteres vazias. Nesse caso [], não corresponde a nada, ele age como (?!)e [^]corresponde a qualquer caractere, o que é conveniente, porque o ECMAScript não possui um smodificador e [\s\S]é uma tarefa difícil digitar uma leitura.
Martin Ender

Correção verificada.
Martin Ender

7

11. Python - 29

^(.{,4}|.{9}|.{16,19}|.{5}P)$

► Teste no RegexPlanet

Quase todas as respostas inválidas têm um comprimento diferente das respostas válidas. Este regex faz uso disso.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Correção verificada.
feersum

7

29. sabor PCRE - 28

^..(.[!)3G^w]|$)|\^.{7}$|G\)

Testado no Regex101

Esta resposta ainda funciona ...

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\

Correção verificada.
Martin Ender

1
Agradável! Restrição de remodelação, que é exatamente o que eu tinha
SP3000

Eu estava tentando calcular isso usando o algoritmo genético, mas produziu apenas regex de 30 caracteres ... Agora, execute-o para obter a próxima resposta. Resultado atual - 32 caracteres.
Vi.

@Vi Um algoritmo genético eh, idéias interessantes que você tem aí: P
Sp3000 21/04

@ Sp3000, agora com 30 caracteres ... Mas outra resposta chegou, então é preciso reiniciar.
Vi.

6

31. sabor Perl - 29

[?[CP(].[-<)|w]|^P|^[^C|\\]*$

Não sei como funciona, foi produzido pela minha primeira incursão em algoritmos genéticos . Há saída do programa que menciona a resposta.

A próxima resposta deve corresponder:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

e falhar:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$

Correção verificada.
Martin Ender

Ahaha legal - você usou as respostas anteriores como sementes para a população ou acabou parecendo a anterior?
Sp3000

As strings de passagem e falha são usadas como blocos de construção iniciais. Eles foram banidos depois de algum tempo devido a serem mínimos locais. Você pode ver como isso ocorre no log do programa: o número entre parênteses após "métrica =" é a medida de quão rápido estamos avançando. Está baixo por muito tempo, banimos as respostas atuais e redefinimos.
Vi.

(Enquanto isso, o candidato de 31 caracteres para a próxima resposta já foi encontrado)
Vi.

Oh, o limite aumentou? Não é 29? Dessa forma, não vai acabar tão cedo ... Eu acho que o principal desafio é encontrar o último, o melhor regex.
Vi.

6

32. PCRE - 30 bytes

^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)

Testado no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E falhe nessas strings :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)

1
Correção verificada.
Martin Ender

Por que é adicionado à lista "falhar"? Ele já falha em si mesmo, portanto pode servir como a próxima resposta sem modificações. Suponho que, para cada resposta, não há escolha de qual lista ela deve ser anexada.
Vi.

3
@Vi. Eu acho que de hwnd sensação agradável hoje
SP3000

Vou tornar mais difícil à medida que continua.
hwnd

5

1. Tipo ECMAScript - 2 bytes

^P

Teste-o no Regex101.

O conjunto de correspondência inicial é PPCGe o conjunto com falha [PPCG]. Portanto, este regex testa simplesmente que a seqüência começa com P.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P

E falhe nessas strings:

[PPCG]

3
Correção verificada.
Decay Beta

5

3. sabor ECMAScript - 6 bytes

[^\]]$

Teste aqui

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P

E falhe nas seguintes strings:

[PPCG]
^[P\^]
[^\]]$

1
Correção verificada.
Decay Beta

5

7. sabor Python - 16

(?<!\\..)(?!]).$

Testado no Regex101

Tem que adicionar um \ à lista de correspondências :)

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P

Correção verificada.
NinjaBearMonkey

Isso ... isso é desonesto.
wchargin

@WChargin Thanks :) Você deve verificar algumas respostas do user23013 ou n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳; alguns são bastante "desonestos";)
FryAmTheEggman 14/11

5

12. sabor ECMAScript - 17

!|[^?]P(CG|G..)?$

Teste aqui .

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Correção verificada.
Martin Ender

5

22. sabor PCRE - 29 bytes

Como o nº 22 original não foi modificado por 1 hora, presumo que ele se tornou inválido.

^.{3,23}[.-~]..\$$|[^P?][PG]$

Demo

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P

1
Correção verificada. (E sim, isso mesmo, a anterior 22 agora é inválido.)
Martin Ender

5

26. sabor Python - 28

^..(.[!G)(3w^]|.{7}$|$)|\$\?

Teste no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~

Correção verificada.
22815 Martin Ender #

5

30. sabor Python - 28

[[?C(].[-!)|w]|^P|^[^C|\\]*$

Testado no Regex101

Quando há vontade ...

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$

Correção verificada.
precisa saber é o seguinte

5

37. sabor Perl - 30

\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)

Submissão no Regex101 .

A solução foi produzida pelo mesmo programa de antes. O programa também imprimiu solução de 29 caracteres\?[^$w]*\$|[]^C]\w)$|w.]|\w.\ , não sei por que, pois parece um regex malformado ...

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)

Correção verificada.
Martin Ender

Ahaha estou muito irritado eu não consegui isso depois de chegar tão longe com o primeiro semestre: P
SP3000

5

40. PCRE - 33 bytes

[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$

Testado no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)
\w.\)|\?[^-$]*\$$|[]^C]\w$|w[+^]

E falhe nessas strings :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)
\?[^$w]*\$$|[]C^]\w$|w.]|\w.\)
\$..\\|\?[^w$]*\$$|w\^|[]^C]\w$
[]^C]\w$|\w.\)|w[[+^]|\?[^w$]*\$$

Correção verificada.
Vi.

1
Eu tenho um 35, mas não estou satisfeito com ele, então eu vou ver se consigo algo mais interessante
SP3000

E eu tenho três opções para uma resposta de 32 caracteres, mas todo o desafio ficou um pouco chato (especialmente a contabilidade dos envios do Regex101 e as listas de sequências de falha / aprovação). Se alguém quiser, posso postar uma resposta.
Vi.

4

4. sabor ECMAScript - 5 bytes

^\^?P

Teste aqui .

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P

1
Correção verificada.
Decay Beta

4

5. sabor ECMAScript - 6 bytes

^[P^]P

Testado no Regex101 .

Hora de apimentar um pouco as coisas com o sucesso estabelecido.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P

Correção verificada.
FryAmTheEggman 13/11

4

6. sabor ECMAScript - 9 bytes

[^?][PG]$

Testado no Regex101 .

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P

1
Correção verificada.
FireFly

4

14. sabor PCRE - 25

([.$?]|G\])\$$|^\^?P|\]P$

Testado no Regex101

Isso está começando a ficar bastante difícil.

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

Correção verificada.
Martin Ender

4

15. sabor PCRE - 26

([P.$?]\$|[]^]P|G\]\$|CG)$

Testado no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$

1
Correção verificada.
FireFly

4

16. sabor PCRE - 21

^[^?]*[PG]$|[?$].*\$$

Testado no Regex 101 .

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$

Não combina PPCG.
jimmy23013

@ user23013 corrigido
es1024

Correção verificada.
jimmy23013

4

25. sabor PCRE - 29

^(..[^^].{4,22}\$|[^?]+\w)$|~

Testado aqui. (O regex de teste contém um adicional \npara garantir que nenhuma correspondência abranja várias linhas. Isso não é necessário para corresponder a cada sequência individual.)

Essa foi uma fruta baixa! :) Eu tenho que parabenizar o plannapus, porém, esse regex é incrivelmente elegante para os conjuntos de testes atuais. Se você deseja votar novamente esta resposta, certifique-se de votar também na anterior!

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~

1
Correção verificada.
feersum

4

35. PCRE - 35 bytes

^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

Testado no Regex101

A próxima resposta deve corresponder às seguintes seqüências de caracteres :

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)

E falhe nessas strings :

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

Meu verificador não mostra erros.
Vi.

Correção verificada. (@Vi, a aparência do painel para esta frase específica..)
Martin Ender

Pensei em usar essa frase, mas não tinha certeza se quero fazer meu comentário com autoridade.
Vi.

Minha outra resposta de 34 caracteres mencionada antes parece funcionar aqui. Esperando 4 horas (ou algo assim) ...
Vi.

Eu não me incomodo em invadir - eu delego para o computador. Talvez escreva um bot de resposta usando a API StackExchange? ..
Vi.

4

36. sabor Python - 32

\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

Testado no Regex101

Eu tinha três regexes de 32 bytes prontos e, felizmente, um deles ainda funciona: D

A próxima resposta deve corresponder às seguintes seqüências de caracteres:

PPCG
^P
^[P^]P
[^?][PG]$
(?<!\\..)(?!]).$
^[\w^]*$|!|]P|G]\$$
!|[^?]P(CG|G..)?$
[^])]\$|^\^?P|P.\].$
([.$?]|G\])\$$|^\^?P|\]P$
([P.$?]\$|[]^]P|G\]\$|CG)$
!|((G.|P|\.)\$|[^?]P|CG)$
^[(!P]|G..$|]..\||[^?]P$
^.{3,23}[.-~]..\$$|[^P?][PG]$
^..(.[!G)(3w^]|.{7}$|$)|\$\?
\.\)|P[.$?]|w\^|^[^|C\\]*$|^P
^..(.[!)3G^w]|$)|\^.{7}$|G\)
\?[^w$]*\$$|[]^C]\w+$|w\^|\|..\)

E falhe nessas strings:

[PPCG]
^[P\^]
[^\]]$
^\^?P
[^?][PG]$|<|PG
^[^\\|]*(\\\\)+[^\\|]*[^\]]$
^(.{,4}|.{9}|.{16,19}|.{5}P)$
^[^?]*[PG]$|[?$].*\$$
^[^[]P|]P|(G]|[.])\$$
\..$|!|\|G|^[\^P]P|P\^|G.\$$
...\^.P|^!|G]\$$|w|<!|^\^?P
([^\\}<]{3}|][^]]|^).?[$PG]$
^(..[^^].{4,22}\$|[^?]+\w)$|2
^(..[^^].{4,22}\$|[^?]+\w)$|~
^..(.[!()3G^w]|.{7}$|$)|G\\
[[?C(].[-!)|w]|^P|^[^C|\\]*$
[?[CP(].[-<)|w]|^P|^[^C|\\]*$
^..(.{7}$|.[3Gw!^)]|$)|G.?.?\)
^...[3w!G)]|^[^\\C|]*$|G.?.?\)
^[^C\\|]+$|G.\)|\.\)|w\^|^P|\...?]
^P|!.3|w\^|^[^C\\|]+$|\.[)$-](?!.!)

1
Correção verificada.
Martin Ender

A correção como um regex Perl também é verificada.
Vi.

Espero que a pergunta fique inativa até amanhã, pois tenho uma resposta pendente de 30 caracteres para publicar.
Vi.
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.