Ein regulärer Ausdruck, der drei aufeinanderfolgende ganze Zahlen enthält, wenn die dritte ganze Zahl die Summe der ersten beiden ist

Schreiben Sie einen regulären Ausdruck, der einer bestimmten Zeichenfolge entspricht, die aus drei nicht negativen, durch Leerzeichen getrennten Ganzzahlen besteht, und zwar genau dann, wenn die letzte Ganzzahl die Summe der beiden vorhergehenden ist. Die Antworten können für ganze Zahlen eines beliebigen Zahlensystems mit einem Radix zwischen 2 und 10 erfolgen.

Testfälle

Diese sollten fehlschlagen:

0 1 2
10 20 1000

Diese sollten übereinstimmen mit:

10 20 30
28657 46368 75025
0 0 0

Regeln

Ihre Antwort sollte aus einem einzelnen regulären Ausdruck ohne zusätzlichen Code bestehen (mit Ausnahme einer optionalen Liste von regulären Ausdrucksmodifikatoren, die erforderlich sind, damit Ihre Lösung funktioniert). Sie dürfen keine Funktionen der Regex-Variante Ihrer Sprache verwenden, mit denen Sie Code in der Hosting-Sprache aufrufen können (z. B. der e-Modifikator von Perl).

Bitte geben Sie in Ihrer Antwort Ihren Regex-Geschmack an.

Dies ist Regex-Golf, also gewinnt der kürzeste Regex in Bytes. Wenn in Ihrer Sprache Begrenzer (normalerweise /.../) für reguläre Ausdrücke erforderlich sind, zählen Sie die Begrenzer nicht selbst. Wenn Ihre Lösung Modifikatoren erfordert, fügen Sie ein Byte pro Modifikator hinzu.

_{Dank an Martin Ender und jaytea für die Regex-Golfregeln.}

Ich habe Grund zu der Annahme, dass es basierend auf der Lösung von Martin Ender möglich ist , Ganzzahlen mit Regex zu finden und zu erhöhen .

code-golf arithmetic regular-expression

— Josh Withee
quelle

Sie können jede Regex-Variante verwenden, die vor dieser Herausforderung existierte. Diese Regel spiegelt nicht den aktuellen Konsens wider. Dies besagt, dass Sprachen (und daher Regex-Varianten), die nach dem Posten der Herausforderung erstellt oder aktualisiert wurden, weiterhin konkurrieren können.

— Erik der Outgolfer

Verbunden. (Ich vermute, Antworten auf diese Frage werden etwas ähnlich aussehen wie die .NET-Antwort von Jimmy dort.)

— Martin Ender

@EriktheOutgolfer gibt es wirklich einen Konsens, dass Sprachen, die nach der Herausforderung erstellt wurden, WETTBEWERBEN können? Das ist

— totaler

@ edc65 Ab vor einem halben Jahr.

— Martin Ender

Der /eModifikator von Perl 5 gilt nur für Ersetzungen und ist nicht die einzige Möglichkeit, externen Code auszuführen. Auch dies disqualifiziert Perl 6 vollständig, da ein regulärer Ausdruck nur eine Methode mit zusätzlicher Syntax ist. (Der Grund dafür ist, dass reguläre Ausdrücke einfacher zu lesen und zu schreiben sind.) Daher werden alle Funktionen, die in archaischen regulären Ausdrücken benötigt werden, nicht benötigt (oder sind enthalten), da Sie gerade Perl 6-Code eingegeben haben. (es wahrscheinlich Sinn ist nicht möglich , diese Herausforderung zu tun , wenn Sie auf regex spezifischen Code begrenzen nur) /^(\d+)**3%' '$ <?{$0[2]==[+] $0[0,1]}>/oder /^(\d+)' '(\d+)' '(\d+)$ <?{$2==$0+$1}>/oder/^(\d+)' '(\d+){}" {$0+$1}"$/

— Brad Gilbert b2gills

Antworten:

Perl / PCRE: 2.685 Bytes

^ (?! (?! 0 * + (? = (\ D *?) ((?: (? = \ D + 0 * + (\ d *?) (\ D (? (4) \ 4)) 0 * (\ d *?) (\ d \ 6? +) $) \ d) +) (? = (? (?! \ 1 (?: (? = \ d + 0 * \ 3 ((\ 7? +) \ d)) (& agr; = \ d (\ d * 0 * \ 3 \ 8)) (& agr; = 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) * + (& agr; = \ d (\ d * 0 * \ 3 \ 8 & agr; +)) (& agr; = [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 +)) (& agr; = 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 (& agr;: 9 (& agr; = \ d * \ 12 \ 15 & agr; + \ d (\ 17 & agr; +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]) (& agr; = 1 \ 23 (& agr;: 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} $)). +

Probieren Sie es online!

Ich war nach einer Pause von Regex auf der Suche nach schwierigen Herausforderungen und bin zufällig über diesen Trottel gestolpert. Die Überprüfung der Hinzufügung (mit Perl / PCRE) ist etwas, worüber ich bereits nachgedacht habe, wurde jedoch umgehend als unmöglich oder über meine Möglichkeiten hinaus abgetan. Allerdings habe ich es jetzt noch einmal durchgesehen und bin sehr erfreut zu sagen, dass ich es tatsächlich geschafft habe!

Ich habe nicht wirklich Golf gespielt, außer kurze Algorithmen und die gesamte Matching-Technik zu berücksichtigen, als ich es geschrieben habe. Ich bin nur sehr froh, dass ich es geschafft habe: D

Wenn die Leute interessiert sind, könnte ich Kommentare hinzufügen und erklären, wie es funktioniert.

Bearbeiten: Ich habe in meinem Blog einen ausführlichen Beitrag dazu verfasst, mit Erläuterungen und Kommentaren :) Viel Spaß: http://www.drregex.com/2018/09/a-regex-i-submitted-to-reddit-climbed.html

— Jaytea
quelle

Ich bin auf jeden Fall an ein paar Erklärungen interessiert!

— Etene

@etene Ich habe den Beitrag mit einem Link zu einer ausführlichen Beschreibung bearbeitet: D

— jaytea

Vielen Dank, das wird eine interessante Lektüre!

— Etene

.NET-Variante, 139 111 106 + 1 = 107 Byte

Benötigt den RightToLeftModifikator r. Eingabe in binärer Form.

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

Probieren Sie es online! (Mit Retina .)

Ja für Bilanzkreise. Das erkläre ich später ...

Dezimalversion, 340 243 + 1 = 244 Byte

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

Probieren Sie es online!

— Martin Ender
quelle

"Das erkläre ich später." Wie viel später?

— Urous

@ Οurous viel später, wie sich herausstellt.

— Martin Ender

.NET, 96 Bytes

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

Flagge: r

Probieren Sie es online!

Dezimalversion, 238 Byte

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

Flagge: r

Probieren Sie es online!

Ähnlich wie Martins Antwort.

— jimmy23013
quelle