Escreva uma expressão regular que corresponda a uma determinada sequência que consiste em três números inteiros não negativos e separados por espaço, se e somente se o último número inteiro for a soma dos dois anteriores. As respostas podem ser para números inteiros de qualquer sistema numérico com uma raiz entre 2 e 10.

Casos de teste

Estes devem falhar:

0 1 2
10 20 1000

Estes devem corresponder:

10 20 30
28657 46368 75025
0 0 0

Regras

Sua resposta deve consistir em um único regex, sem nenhum código adicional (exceto, opcionalmente, uma lista de modificadores de regex necessários para fazer sua solução funcionar). Você não deve usar recursos do tipo regex do seu idioma que permitam chamar código no idioma de hospedagem (por exemplo, o modificador e Perl).

Especifique o seu sabor regex na sua resposta.

Como o regex golf, ganha o menor regex em bytes. Se o seu idioma exigir delimitadores (geralmente /.../) para indicar expressões regulares, não conte os delimitadores. Se sua solução exigir modificadores, adicione um byte por modificador.

_{Créditos a Martin Ender e jaytea pelas regras de regex-golfe.}

Tenho motivos para acreditar que isso é possível com base na solução de Martin Ender para encontrar e incrementar números inteiros com regex .

Perl / PCRE: 2.685 bytes

^ (?! (?! 0 * + (? = (\ D *?) ((?: (? = \ D + 0 * + (\ d *?) (\ D (? (4) \ 4))) 0 * (\ d *?) (\ d \ 6? +) $) \ d) +)) (? = (? (?! \ 1 (?: (? = \ d + 0 * \ 3 ((\ 7? +) \ d)) (? = \ d (\ d * 0 * \ 3 \ 8)) (? = 0 \ 9 [9] | 1 \ 9 [8] | 2 \ 9 [7] | 3 \ 9 [6] | 4 \ 9 [5] | 5 \ 9 [4] | 6 \ 9 [3] | 7 \ 9 [2] | 8 \ 9 [1] | 9 \ 9 [0]) \ d) * + (? = \ d (\ d * 0 * \ 3 \ 8? +)) (? = [5-9] \ 10 [5-9] | 1 \ 10 [9] | 2 \ 10 [89] | 3 \ 10 [7-9] | 4 \ 10 [6-9] | 6 \ 10 [4] | 7 \ 10 [34] | 8 \ 10 [2-4] | 9 \ 10 [1-4]) ) (? = \ d + \ d + 0 * \ 1 \ 3 \ 6 $) | (? (?!. * + \ 3) \ d +) (? = \ d * (\ 2 | \ 4) (. *? 0 * +) \ d + $) (? (? = 9 * \ 11) (?: 9 (? = \ D * \ 12 [1] (\ 13? +0))) *? (? = \ 11) \ 11 \ 12 [1] \ 13? + \ 6 $ | (?: (\ D) (? = \ D * \ 12 (\ 15? + \ 14))) * (? = \ D (\ d * \ 12 \ 15? +)) (? = 0 \ 16 [1] | 1 \ 16 [2] | 2 \ 16 [3] | 3 \ 16 [4] | 4 \ 16 [5] | 5 \ 16 [ 6] | 6 \ 16 [7] | 7 \ 16 [8] | 8 \ 16 [9]) \ d (?: 9 (? = \ D * \ 12 \ 15? + \ D (\ 17? +0 ))? * 11 \ 12 \ 15? + \ D \ 17? + \ 6 $))) \ 1 (?: (? = (\ D) \ d * 0 * + \ 3 ((19? +) \ d) \ d * 0 * + \ 5 ((\ 21? +) \ d)) (? = \ d (\ d * 0 * + \ 3 \ 20) \ d (\ d * 0 * + \ 5 \ 22)) (? (?! \ 18 (?:(? = \ d + 0 * + \ 3 \ 19 ((\ 25? +) \ d)) (? = \ d (\ d * 0 * + \ 3 \ 19 \ 26)) (? = 0 \ 27 [ 9] | 1 \ 27 [8] | 2 \ 27 [7] | 3 \ 27 [6] | 4 \ 27 [5] | 5 \ 27 [4] | 6 \ 27 [3] | 7 \ 27 [2 ] | 8 \ 27 [1] | 9 \ 27 [0]) \ d) * + (? = \ D (\ d * 0 * + \ 3 \ 19 \ 26? +)) (? = [5-9 ] \ 28 [5-9] | 1 \ 28 [9] | 2 \ 28 [89] | 3 \ 28 [7-9] | 4 \ 28 [6-9] | 6 \ 28 [4] | 7 \ 28 [34] | 8 \ 28 [2-4] | 9 \ 28 [1-4])) (? = 1 \ 23 (?: 1 \ 24 [2] | 2 \ 24 [3] | 3 \ 24 [4] | 4 \ 24 [5] | 5 \ 24 [6] | 6 \ 24 [7] | 7 \ 24 [8] | 8 \ 24 [9] | 9 \ 24 [0]) | 2 \ 23 (?: 1 \ 24 [3] | 2 \ 24 [4] | 3 \ 24 [5] | 4 \ 24 [6] | 5 \ 24 [7] | 6 \ 24 [8] | 7 \ 24 [9 ] | 8 \ 24 [0] | 9 \ 24 [1]) | 3 \ 23 (?: 1 \ 24 [4] | 2 \ 24 [5] | 3 \ 24 [6] | 4 \ 24 [7] | 5 \ 24 [8] | 6 \ 24 [9] | 7 \ 24 [0] | 8 \ 24 [1] | 9 \ 24 [2]) | 4 \ 23 (?: 1 \ 24 [5] | 2 \ 24 [6] | 3 \ 24 [7] | 4 \ 24 [8] | 5 \ 24 [9] | 6 \ 24 [0] | 7 \ 24 [1] | 8 \ 24 [2] | 9 \ 24 [3]) | 5 \ 23 (?: 1 \ 24 [6] | 2 \ 24 [7] | 3 \ 24 [8] | 4 \ 24 [9] | 5 \ 24 [0] | 6 \ 24 [1] | 7 \ 24 [2] | 8 \ 24 [3] | 9 \ 24 [4]) | 6 \ 23 (?: 1 \ 24 [7] | 2 \ 24 [8] | 3 \ 24 [9] | 4 \ 24 [0] | 5 \ 24 [1] | 6 \ 24 [2] | 7 \ 24 [3] | 8 \ 24 [4] | 9 \ 24 [5]) | 7 \ 23 (?: 1 \ 24 [8] | 2 \ 24 [9] | 3 \ 24 [0] | 4 \ 24 [1] | 5 \ 24 [2] | 6 \ 24 [3] | 7 \ 24 [4 ] | 8 \ 24 [5] | 9 \ 24 [6]) | 8 \ 23 (?:1 \ 24 [9] | 2 \ 24 [0] | 3 \ 24 [1] | 4 \ 24 [2] | 5 \ 24 [3] | 6 \ 24 [4] | 7 \ 24 [5] | 8 \ 24 [6] | 9 \ 24 [7]) | 9 \ 23 (?: 1 \ 24 [0] | 2 \ 24 [1] | 3 \ 24 [2] | 4 \ 24 [3] | 5 \ 24 [4] | 6 \ 24 [5] | 7 \ 24 [6] | 8 \ 24 [7] | 9 \ 24 [8]) | 0 \ 23 (\ d) \ 24 \ 29 | (\ d) \ 23 [0] \ 24 \ 30) | (? = 1 \ 23 (?: 0 \ 24 [2] | 1 \ 24 [3] | 2 \ 24 [4] | 3 \ 24 [5] | 4 \ 24 [6] | 5 \ 24 [7] | 6 \ 24 [8] | 7 \ 24 [9] | 8 \ 24 [0] | 9 \ 24 [1]) | 2 \ 23 (?: 0 \ 24 [3] | 1 \ 24 [4] | 2 \ 24 [5] | 3 \ 24 [6] | 4 \ 24 [7] | 5 \ 24 [8] | 6 \ 24 [9] | 7 \ 24 [ 0] | 8 \ 24 [1] | 9 \ 24 [2]) | 3 \ 23 (?: 0 \ 24 [4] | 1 \ 24 [5] | 2 \ 24 [6] | 3 \ 24 [7 ] | 4 \ 24 [8] | 5 \ 24 [9] | 6 \ 24 [0] | 7 \ 24 [1] | 8 \ 24 [2] | 9 \ 24 [3]) | 4 \ 23 (? : 0 \ 24 [5] | 1 \ 24 [6] | 2 \ 24 [7] | 3 \ 24 [8] | 4 \ 24 [9] | 5 \ 24 [0] | 6 \ 24 [1] | 7 \ 24 [2] | 8 \ 24 [3] | 9 \ 24 [4]) | 5 \ 23 (?: 0 \ 24 [6] | 1 \ 24 [7] | 2 \ 24 [8] | 3 \ 24 [9] | 4 \ 24 [0] | 5 \ 24 [1] | 6 \ 24 [2] | 7 \ 24 [3] | 8 \ 24 [4] | 9 \ 24 [5]) | 6 \ 23 (?: 0 \ 24 [7] | 1 \ 24 [8] | 2 \ 24 [9] | 3 \ 24 [0] | 4 \ 24 [1] | 5 \ 24 [2] | 6 \ 24 [3] | 7 \ 24 [4] | 8 \ 24 [5] | 9 \ 24 [6]) | 7 \ 23 (?: 0 \ 24 [8] | 1 \ 24 [9] | 2 \ 24 [ 0] | 3 \ 24 [1] | 4 \ 24 [2] | 5 \ 24 [3] | 6 \ 24 [4] | 7 \ 24 [5] | 8 \ 24 [6] | 9 \ 24 [7 ]) | 8 \ 23 (?:0 \ 24 [9] | 1 \ 24 [0] | 2 \ 24 [1] | 3 \ 24 [2] | 4 \ 24 [3] | 5 \ 24 [4] | 6 \ 24 [5] | 7 \ 24 [6] | 8 \ 24 [7] | 9 \ 24 [8]) | 9 \ 23 (?: 0 \ 24 [0] | 1 \ 24 [1] | 2 \ 24 [2] | 3 \ 24 [3] | 4 \ 24 [4] | 5 \ 24 [5] | 6 \ 24 [6] | 7 \ 24 [7] | 8 \ 24 [8] | 9 \ 24 [9]) | 0 \ 23 (?: 0 \ 24 [1] | 1 \ 24 [2] | 2 \ 24 [3] | 3 \ 24 [4] | 4 \ 24 [5] | 5 \ 24 [6] | 6 \ 24 [ 7] | 7 \ 24 [8] | 8 \ 24 [9] | 9 \ 24 [0])))) \ d) + \ | ^ 0 + \ 0 * (\ d +) \ 0 * \ g {-1 } $ | ^ 0 * (\ d +) \ 0+ \ 0 * \ g {-1} $)).

Experimente online!

Eu estive à espreita por desafios difíceis depois de um hiato de regex, e por acaso tropeçou nesse doozy. Verificar adição (com Perl / PCRE) é algo em que pensei antes, mas prontamente descartado como impossível ou além da minha capacidade. No entanto, tomei outra rachadura agora e estou muito emocionado em dizer que realmente fiz isso!

Eu realmente não joguei isso além de considerar algoritmos curtos e técnica de correspondência geral quando escrevi. Estou muito feliz por ter feito: D

Se as pessoas estiverem interessadas, eu poderia adicionar comentários e explicar como isso funciona.

Edit: Eu fiz um post detalhado no meu blog sobre isso, com explicações e comentários :) aproveite: http://www.drregex.com/2018/09/a-regex-i-submitted-to-reddit-climbed.html

Tipo .NET, 139 111 106 + 1 = 107 bytes

Precisa do RightToLeftmodificador r. Entrada em binário.

(?(2)!)^\5 \7 ((?(2)()(?(2)!)(?<-2>){2})(0|(?<-2>1))(?<=(((0|(?<2>1)|\b)(?=.*(?<=(\5).*))?\7?) \d*){2}))+$

Experimente online! (Usando Retina .)

Yay para grupos de equilíbrio. Eu vou explicar isso mais tarde ...

Versão decimal, 340 243 + 1 = 244 bytes

(?(2)!)^\5 \7 ((?(2)()(?(2)!)(?<-2>){10})(0|(?<-2>1|(?<-2>2|(?<-2>3|(?<-2>4|(?<-2>5|(?<-2>6|(?<-2>7|(?<-2>8|(?<-2>9))))))))))(?<=(((0|(?<2>1|(?<2>2|(?<2>3|(?<2>4|(?<2>5|(?<2>6|(?<2>7|(?<2>8|(?<2>9)))))))))|\b)(?=.*(?<=(\5).*))?\7?) \d*){2}))+$

Experimente online!

.NET, 96 bytes

^\4 \6((?(2)()(?(2)^)(?<-2>){2}| ?)(0|(?<-2>1))(?<=((0|(?<2>1)|)\4?) .*((0|(?<2>1)|)\6?) .*))+$

Bandeira: r

Experimente online!

Versão decimal, 238 bytes

^\5 \6(?<-6>)((?(2)()(?(2)^)(?<-2>){10}| ?)((?<-2>[1469]|(?<-2>[27]))|[0358])(?([5-9])(?<-2>){5})(?([3489])(?<-2>){3})(?<=(((((?=[5-9](?<2>){5}|)(?=[3489](?<2>){3}|)((?<2>[1469]|(?<2>[27]))|.))?(?( .*)\6?(?<-6>)?|\5?(?<-5>)))) .*){2}))+$

Bandeira: r

Experimente online!

Semelhante à resposta de Martin.