Une expression régulière pour correspondre à trois entiers consécutifs si le troisième entier est la somme des deux premiers

Écrivez une expression régulière qui correspond à une chaîne donnée composée de trois entiers non négatifs séparés par des espaces si et seulement si le dernier entier est la somme des deux précédents. Les réponses peuvent être pour des nombres entiers de n'importe quel système numérique avec une radix entre 2 et 10.

Cas de test

Ceux-ci devraient échouer:

0 1 2
10 20 1000

Ceux-ci doivent correspondre:

10 20 30
28657 46368 75025
0 0 0

Règles

Votre réponse doit consister en une seule expression régulière, sans code supplémentaire (sauf, éventuellement, une liste de modificateurs d'expression régulière requis pour faire fonctionner votre solution). Vous ne devez pas utiliser les fonctionnalités de l'argument regex de votre langue qui vous permettent d'invoquer du code dans la langue d'hébergement (par exemple le modificateur e de Perl).

Veuillez spécifier votre saveur regex dans votre réponse.

C'est le golf regex, donc le regex le plus court en octets gagne. Si votre langue nécessite des délimiteurs (généralement /.../) pour désigner les expressions régulières, ne comptez pas les délimiteurs eux-mêmes. Si votre solution nécessite des modificateurs, ajoutez un octet par modificateur.

_{Crédits à Martin Ender et jaytea pour les règles du regex-golf.}

J'ai des raisons de croire que c'est possible sur la base de la solution de Martin Ender pour trouver et incrémenter des entiers avec regex .

code-golf arithmetic regular-expression

— Josh Withee
source

Vous pouvez utiliser n'importe quelle saveur regex qui existait avant ce défi, cette règle ne reflète pas le consensus actuel, qui dit que les langues (et donc les saveurs regex) créées ou mises à jour après la publication du défi peuvent toujours rivaliser.

— Erik the Outgolfer

En relation. (Je pense que les réponses à cela ressembleront quelque peu à la réponse .NET de jimmy.)

— Martin Ender

@EriktheOutgolfer, il y a vraiment un consensus sur le fait que les langues créées après le défi peuvent CONCURRENCE? C'est totalement absurde

— edc65

@ edc65 Il y a

— Martin Ender

Le /emodificateur de Perl 5 ne s'applique qu'aux substitutions et n'est pas le seul moyen d'exécuter du code externe. De plus, cela disqualifie entièrement Perl 6 car une expression régulière n'est qu'une méthode avec une syntaxe supplémentaire. (La raison en est que cela rend les expressions rationnelles plus faciles à lire et à écrire) Par conséquent, toutes les fonctionnalités nécessaires dans les expressions régulières archaïques ne sont pas nécessaires (ou incluses) comme vous venez de le mettre en code Perl 6. (ce qui signifie qu'il n'est probablement pas possible de relever ce défi si vous vous limitez au code spécifique regex) /^(\d+)**3%' '$ <?{$0[2]==[+] $0[0,1]}>/ou /^(\d+)' '(\d+)' '(\d+)$ <?{$2==$0+$1}>/ou/^(\d+)' '(\d+){}" {$0+$1}"$/

— Brad Gilbert b2gills

Réponses:

Perl / PCRE: 2 685 octets

^ (?! (?! 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} $)). +

Essayez-le en ligne!

J'ai été à l'affût de défis difficiles après une interruption de regex, et je suis tombé sur ce doozy. Vérifier l'ajout (avec Perl / PCRE) est quelque chose auquel j'ai pensé auparavant, mais rapidement rejeté comme impossible ou au-delà de mes capacités. Cependant, j'ai pris une autre fissure maintenant et je suis ravi de dire que je l'ai fait!

Je n'ai pas vraiment joué au golf à part considérer des algorithmes courts et une technique de correspondance globale quand je l'ai écrit. Je suis vraiment content d'avoir réussi: D

Si les gens sont intéressés, je pourrais ajouter des commentaires et expliquer comment cela fonctionne.

Edit: J'ai fait un post détaillé sur mon blog à ce sujet, avec des explications et des commentaires :) profitez-en: http://www.drregex.com/2018/09/a-regex-i-submitted-to-reddit-climbed.html

— Jaytea
source

Certainement intéressé par quelques explications!

— etene

@etene J'ai édité le post avec un lien vers un article complet: D

— jaytea

Merci, ce sera une lecture intéressante!

— etene

Arôme .NET, 139 111 106 + 1 = 107 octets

A besoin du RightToLeftmodificateur r. Entrée en binaire.

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

Essayez-le en ligne! (Utilisation de la rétine .)

Oui pour équilibrer les groupes. Je l'expliquerai plus tard ...

Version décimale, 340 243 + 1 = 244 octets

(?(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}))+$

Essayez-le en ligne!

— Martin Ender
source

"Je t'expliquerai plus tard" Combien de temps plus tard?

— Οurous

@ Οurous beaucoup plus tard, il s'avère.

— Martin Ender

.NET, 96 octets

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

Drapeau: r

Essayez-le en ligne!

Version décimale, 238 octets

^\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}))+$

Drapeau: r

Essayez-le en ligne!

Similaire à la réponse de Martin.

— jimmy23013
source