Dies ist eine Herausforderung für Bullen und Räuber. Dies ist der Faden des Räubers. Der Thread des Polizisten ist hier .

Die Polizei wählt eine beliebige Sequenz aus dem OEIS aus und schreibt ein Programm p , das die erste Ganzzahl aus dieser Sequenz ausgibt. Sie werden auch einige String finden s . Wenn Sie s irgendwo in p einfügen , muss dieses Programm die zweite Ganzzahl aus der Sequenz ausgeben. Wenn Sie s + s an derselben Stelle in p einfügen , muss dieses Programm die dritte Ganzzahl aus der Sequenz ausgeben. s + s + s am selben Ort drucken das vierte und so weiter und so fort. Hier ist ein Beispiel:

Python 3, Sequenz A000027

print(1)

Die versteckte Zeichenfolge besteht aus zwei Bytes .

Die Zeichenfolge lautet +1: Da das Programm print(1+1)die zweite Ganzzahl in A000027 ausgibt, gibt das Programm print(1+1+1)die dritte Ganzzahl usw. aus.

Cops müssen die Sequenz, das ursprüngliche Programm p und die Länge des versteckten Strings s enthüllen . Räuber knacken eine Einreichung, indem sie eine Zeichenfolge bis zu dieser Länge und den Ort finden, an dem sie eingefügt werden soll, um die Sequenz zu erstellen. Die Zeichenfolge muss weder mit der beabsichtigten Lösung übereinstimmen, um ein gültiger Riss zu sein, noch mit der Position, an der sie eingefügt wurde.

Wenn Sie eine der Antworten der Polizei knacken, veröffentlichen Sie Ihre Lösung (mit der verborgenen Zeichenfolge und dem verdeckten Ort) und einen Link zur Antwort. Dann kommentiere die Antwort der Polizei mit einem Link zu deinem Crack hier.

Regeln

• Ihre Lösung muss für eine beliebige Zahl in der Sequenz funktionieren oder zumindest bis zu einer angemessenen Grenze, an der sie aufgrund von Speicherbeschränkungen, Ganzzahl- / Stapelüberlauf usw. fehlschlägt.

• Der gewinnende Räuber ist der Benutzer, der die meisten Einreichungen knackt, wobei der Tiebreaker derjenige ist, der diese Anzahl von Rissen zuerst erreicht hat.

• Der Sieger Cop ist der Cop mit dem kürzesten String s , die nicht geknackt wird. Tiebreaker ist der kürzeste p . Wenn es keine ungerissenen Vorlagen gibt, gewinnt der Cop, dessen Lösung für die längste Zeit ungerissen war.

• Um als sicher eingestuft zu werden, muss Ihre Lösung 1 Woche lang ungerissen bleiben und dann die verborgene Zeichenfolge (und die Position, an der sie eingefügt werden soll) aufgedeckt werden.

• s darf nicht verschachtelt sein, es muss Ende an Ende verkettet werden. Zum Beispiel, wenn s ist 10, würde jede Iteration gehen , 10, 1010, 101010, 10101010...anstatt10, 1100, 111000, 11110000...

• Alle kryptografischen Lösungen (z. B. das Überprüfen des Hashs der Teilzeichenfolge) werden gesperrt.

• Wenn s Nicht-ASCII-Zeichen enthält, müssen Sie auch die verwendete Codierung angeben.

Python 2 , Sequenz A138147 von xnor

Original:

print 10

Gebrochen:

print "1%s0"%10
      ^^^^^^^

Probieren Sie es online!

Brain-Flak , A000984 von Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Dies sind nur 30 Bytes, nicht sicher, was Nitrodon im Sinn hatte.

Probieren Sie es online!

Erläuterung

Ich habe viele Dinge ausprobiert, aber hier ist, was funktioniert hat. Die Terme von A000984 sind die zentralen Elemente von Pascals Dreieck.

Jetzt habe ich herausgefunden, dass ich sie erhalten kann, indem ich die Diagonalen über ihnen addiere:

Beispielsweise:

$1+3+6+10 = 20$

Und da die letzte Aktion in Nitrodons Programm darin besteht, alles zusammenzufassen, was diesen Anschein eines guten Kandidaten erweckt (eher, als hätte ich ein paar Dinge ausprobiert, aber dieses hat funktioniert).

Wir wollen also ein Programm, das eine Teilsumme nimmt und die nächste produziert. Zum Glück gibt es einen ziemlich guten Weg, um von einem zum nächsten zu gelangen. Jede Reihe ist das Delta der nächsten Reihe. Das ist die $n$ - te Term in einer Reihe ist , die Differenz zwischen dem $n$ - ten und $n-1$ - ten Terms in der nächsten Zeile.

Das einzige Problem ist, dass wir nicht genug von der letzten Zeile haben, um die gewünschte Zeile zu berechnen. Da jede Zeile eine Zeile länger als die letzte ist, können wir mit dieser Methode nicht das letzte Mitglied der nächsten Zeile abrufen. Hier haben wir jedoch einen anderen Trick: Das letzte Mitglied jeder Reihe ist gleich allen vorherigen Mitgliedern dieser Reihe!

$1+3+6=10$

Und wenn Sie mit Brain-Flak vertraut sind, sollte das für Sie als etwas herausstechen, das wirklich einfach zu bewerkstelligen ist.

Nun zum Code:

Zu Beginn führen wir die nächste Zeilenberechnung durch, bei der jedes neue Mitglied die Summe von zwei benachbarten alten Mitgliedern ist. Das geht mit:

{({}<>({}))<>}<>

Das verschiebt im Grunde ein Element und fügt hinzu (ohne zu löschen), was jemals zuvor oben drauf war. Dies kehrt jedoch alles um. Wenn wir das nächste Mal eine Zeile erhalten, müssen wir sie zurücksetzen.

{({}<>({}))<>}<>{({}<>)<>}<>

Jetzt müssen wir das letzte Mitglied der Zeile berechnen. Wie gesagt das ist super einfach. Da wir eine Schleife über alle Elemente der Reihe hatten, können wir einfach diese Summe nehmen und sie pushen. Wir schieben es vor die zweite Schleife, damit es unten landet.

({({}<>({}))<>}<>){({}<>)<>}<>

Und das ist es.

Brain-Flak, A000290 , von Sriotchilism O'Zaic

Original:

((()))({}<>)

Gebrochen:

((()))({}([])[]<>)
         ^^^^^^

Probieren Sie es online!

Alternative:

((())([])[])({}<>)
     ^^^^^^

Probieren Sie es online!

MATL , Sequenz A005206 von Luis Mendo

Original:

voOdoO

Probieren Sie es online!

Gebrochen:

voOdoOdNq17L/k
      ^^^^^^^^

Ich bin kein MATL-Experte, aber soweit ich weiß, erstellt das Original voOdoOzwei leere Arrays und ein Array [0]auf dem Stapel. Dies [0]wird ohne eckige Klammern als erstes Element der Sequenz gedruckt. Der Riss / die Lösung macht dann folgendes:

• dNimmt ein Element vom Stapel und verwandelt es (vorausgesetzt, es ist eine Zahl oder ein Array der Größe 1) in ein leeres Array. Diese leeren Arrays werden nicht gedruckt, tragen jedoch zur Stapelgröße bei
• Nqzählt die Größe des Stapels und subtrahiert einen. Dies ist der n+1Begriff bei der Auswertung der Funktion (da sie bei 2 beginnt und sich bei jeder Iteration um eins erhöht, weild dem Stapel unsichtbares Material hinzugefügt wird).
• 17L das ist die Konstante Phi = (1+sqrt(5))/2
• /kDies floor((n+1)/Phi)ist eine der Formeln, die die Elemente der Sequenz berechnet. Diese Formel ist in OEIS aufgeführt, a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2sofern wir nicht die Identität verwenden(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

Probieren Sie es online!

100 Flaschen Bier hinzufügen -1, um die nächste Nummer zu erhalten 99, usw.

Keg , Sequenz A000045 , von A__

Original:

0.

Gebrochen:

01":&+.
 ^^^^^

Beachten Sie, dass die Herausforderung darin bestand, eine Teilzeichenfolge mit einer Länge <= 6 zu finden, die gefundene Zeichenfolge jedoch eine Länge von 5 hat.

Definition der Befehle für diejenigen, die zu faul sind, um die Keg-Spezifikation nachzuschlagen: 0 und 1die entsprechende Nummer auf den Stapel schieben; "bewegt den Stapel nach oben zum Stapel nach unten (Rolle); &Fügt den obersten Stapel in das Register ein, wenn er leer ist. Anderenfalls wird das Register auf den Stapel entleert. +fügt die beiden obersten Stapelwerte hinzu.

Die Initiale 1" fügt einfach eine 1 am unteren Rand des Stapels ein. Diese wachsende Liste von 1en spielt nur eine Rolle in der ersten Iteration, wo es uns , die Stapel beginnen zu übernehmen kann und 1 0nicht nur 0. In der Tat, das Programm 10:&+., wo die:&+ Teil wiederholt wird, genau das gleiche Verhalten wie die obige Lösung, mit der Ausnahme, dass die Liste der Einsen unten nicht wächst.

Da &es im Wiederholungsteil nur einmal verwendet wird und abwechselndes Verhalten aufweist, 1":&+hängt das Verhalten von der Parität der Iteration ab.

Dieses Programm gibt die Sequenz Fibonacci, die mit 0, 1 beginnt, nicht wirklich von Anfang an aus. es gibt tatsächlich die 1, 0-Fibonacci-Sequenz von der zweiten Stelle, dh von der 0, aus.

• In der ersten, dritten, ... Iteration beginnt der Zustand wie [a, b]und endet wiea+b (&=b) .
• In der zweiten, vierten, ... Iteration beginnt der Zustand wie [b] (&=a)und endet wie [b, b+a].

Dies berechnet tatsächlich die Sequenz nach Bedarf.

Java 8+, Sequenz A010686 von Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Brain-Flak, A000578 von Sriotchilism O'Zaic

Original:

((())<>)

Probieren Sie es online!

Gebrochen:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Probieren Sie es online!

Pyret , Sequenz A083420 , von MLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Sie können es hier ausführen, aber ich habe nicht herausgefunden, wie man einen Link zum Code erstellt. Sie müssen kopieren und einfügen.

Die bereitgestellte Funktion ignoriert das zweite Argument. Es verdoppelt seine erste und fügt eine hinzu, die die erforderliche 2^n - 1Sequenz generiert. Ich muss ihr lediglich mitteilen, wie oft diese Operation durchgeführt werden soll, indem die Länge der gefalteten Liste geändert wird. Glücklicherweise beklagt sich Pyret nicht über dieses Komma.

Python 3 , Sequenz A268575 von NieDzejkob

Original:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Gebrochen (100 Bytes):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Probieren Sie es online!

Soweit ich das beurteilen kann, werden im Originalcode Definitionen festgelegt, um die verborgene Zeichenfolge so kurz wie möglich zu halten, und anschließend das ursprüngliche Game of Life-Muster definiert. Die verborgene Zeichenfolge entspricht dann dem Schreiben einer Iteration von Conways Game of Life in 102 Byte.

Für die Zwecke dieses Risses Sist es eine Funktion, die die Elemente in ihren Argumenten (die iterable sind) summiert und Feine Funktion anwendet, die für jedes Element einer Liste eine iterable zurückgibt und alle Ergebnisse zusammenfasst.

• ;A=-1,1,0;Beendet die vorangegangene Anweisung und kürzt das Tupel (-1,1,0) mit A ab, das verwendet product(A,A)wird, um alle Nachbarn in Bezug auf eine gegebene Zelle sowie die Zelle selbst anzugeben .
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);Erstellt eine neue Liste Xmit allen Nachbarn von Zellen in Wund den Zellen in sich Wselbst, indem die relativen Positionen der Nachbarn zu jeder Zelle hinzugefügt und zu einer Liste zusammengefasst werden.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}Durchläuft diese Liste Xund bestimmt, ob jede Zelle Xin der nächsten Iteration zu der Gruppe von Zellen gehört. Dies wurde fast wörtlich von diesem Game of Life Golf übernommen .

Haskell, A014675 von Khuldraeseth na'Barya

Originalcode

main=print$uncurry(!!)([2],0)

Mit Teilstring

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Probieren Sie es online!

Desktop - Rechner, A006125 , von A__

Original:

1n

Gebrochen:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Probieren Sie es online!

Einfache Implementierung.

cQuents , Sequenz A003617 von Stephen

=10#2:pZ
  ^

Probieren Sie es online!

Beginnen Sie mit der niedrigsten n + 1-stelligen Zahl, gefolgt von n Nullen. Das #2gibt an, dass nur der zweite Term der Sequenz gedruckt wird, bei dem es sich um die Sequenzdefinition handelt, die einmal auf den Startwert angewendet wurde. Diese Sequenzdefinition findet einfach die nächste Primzahl und gibt sie zurück.

Python 3 - für immer

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Probieren Sie es online!

MATL , Sequenz A000796 von Luis Mendo

Original:

'pi'td1_&:_1)Y$J)

Probieren Sie es online!

Gebrochen:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

Der ursprüngliche Autor hat das Array im Handumdrehen erstellt [-7:-1]und dann das erste Element extrahiert und negiert, das abgerufen werden soll 7. Er benutzte das dann, um die gerundete 7. Ziffer von pi (was ist 3) zu erhalten und präsentierte es als die erste Ziffer von pi. Durch |SQdas Hinzufügen wird das ursprüngliche Array positiv, sortiert und zu allem hinzugefügt. Dies bedeutet, dass nach allem, anstatt den Index 7abzurufen, der Index -2nach einer Anwendung, -3nach zwei Anwendungen usw. abgerufen wird. Das -ist wichtig, weil es die Y$Funktion anweist, die Ziffern nicht zu runden.

Forth (gforth) , A000042 , von NieDzejkob

.( 1)1 .
^^^^^

Probieren Sie es online!

Das triviale 1-Byte erweitert einfach das Literal. Das Problem ist, dass bereits ab der neunzehnten Stelle 64 Bit überlaufen. Einfache Lösung ist, die einzelne Ziffer wiederholt auszudrucken, oder? Ja, aber so einfach ist es nicht. Wenn Sie 1 .am Ende anheften, werden zwar die zusätzlichen Ziffern gedruckt, die wir benötigen, sie werden jedoch durch Leerzeichen getrennt. Das wird nicht funktionieren.

Laut Wikipedia ist " .((Punkt-Paren) ein unmittelbares Wort, das eine durch Klammern getrennte Zeichenfolge analysiert und anzeigt." Glücklicherweise hat diese Anzeige keine anderen seltsamen Zeichen, daher .(sollte es ausreichen, eine einzelne 1 zu drucken. Und das tut es auch. Nach dem Paren wird kein Leerzeichen benötigt, daher können diese fünf Zeichen (nach dem Paren ein Leerzeichen) nach Herzenslust wiederholt werden. Zur Veranschaulichung habe ich ein Beispiel in TIO aufgenommen, das ein 64-Bit-Int mehrmals überlaufen hätte. Klappt wunderbar.

Unefunge-98 (PyFunge) , Sequenz A000108 , von NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Probieren Sie es online!

Sechsmal wiederholt

Zwei Bytes von den neunzehn sind erlaubt! Was als Leerzeichen erscheint, ist ein 0x01 Start Of Header-Zeichen.

Erläuterung:

Bei dieser Herausforderung geht es darum, a(n)aus a(n-1)und vielleicht etwas zu generieren n. OEIS bietet die explizite Formel a(n) = (2n)!/(n!(n+1)!), in die leicht genug konvertiert werden kann a(n) = a(n-1) * (4n-6) / n. Nun, um dies in Funge umzusetzen.

Ich muss Code zwischen 1und einfügen .. Das ist schon die Hälfte des Puzzles. Was bleibt, ist welcher Code einzufügen? Es fehlt Funge vor allem an Werkzeugen zur Stapelbearbeitung, so dass der Boden des Stapels gesperrt ist. Ich muss beide nund verfolgena(n) ohne den Stapel zu vergrößern. Und wie geht das besser als mit Funge Space?

Dieses 0x01-Zeichen ist mein Zähler n. Ich behalte a(n)den Stack bei, da er sich auf dem Stack befinden muss, nachdem mein Bit ausgeführt wurde.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3 , A008574 von tsh

print(1*2+2)
       ^^^^

Probieren Sie es online!

V, A000290 , von DJMcMayhem

é*Ä2é*Ø.
  ^^^^

ergibt die Quadrate von 1.

Probieren Sie es online!

Die Basis é*fügt die Anzahl der Nicht-Newline-Zeichen in den gesamten Puffer ein *und Ø.zählt sie. Die Einfügung Ädupliziert die oberste Zeile in eine eigene Zeile, in die die 2é*Einfügungen eingefügt werden **. Verkettungen der Insertionen ergeben aufeinanderfolgende ungerade Zahlen, wobei die größten oben liegen. Das Endergebnis Ø.summiert die ersten n ungeraden Zahlen und ergibt so das n-te Quadrat.

AsciiDots , Sequenz A019523 von Alion

\ +++ /
// \ / \

Einmal!

Zweimal!

Zehn Mal!

Beim Versuch herauszufinden, wie der Code / die Sprache funktioniert, habe ich gelernt, dass die ersten beiden Zeilen des vorhandenen Codes die gesamte Arbeit der endlosen Ausgabe der Fibonacci-Sequenz erledigen. Der Code wird beendet, wenn ein Punkt auf den Code trifft. &Ich musste also lediglich eine weitere Verzögerung in die verbleibenden Zeilen einfügen , damit die entsprechende Anzahl von Einträgen ausgegeben werden kann.

Nach einigen Versuchen, Fehlern und Beobachtungen stellte ich fest, dass das korrekte Verzögerungsintervall 16 Zeiteinheiten pro Zahl beträgt. Es schien nicht möglich, genügend Zeichen in eine einzelne Zeile einzufügen. Daher musste ich die Verzögerung in zwei Zeilen einteilen und 10 Zeichen für die tatsächliche Verzögerung belassen. Damit das Muster mit sich selbst übereinstimmt, mussten beide Zeilen 5 Zeichen haben, und da die mittleren drei Zeichen in einer Zeile zweimal durchlaufen werden können, ergeben sich je nach Wunsch 16 Zeiteinheiten.

Das Erfordernis, dies auf die &in der achten Spalte abzustimmen, schien dies unmöglich zu machen, bis mir klar wurde, dass ich mit einer neuen Zeile im Inneren der dritten Reihe beginnen konnte. Dadurch erhält die vorletzte Zeile die richtige Länge und das jetzt überflüssige Ende der dritten Zeile wird entfernt.

Brachylog , Sequenz A114018 nach nicht verwandter

Ursprüngliches Programm:

≜ṗ↔ṗb&w

String zum Einfügen:

≜ṗ↔ṗẹbb&w
    ^^

Probieren Sie es online!

Erläuterung

Hier ist zunächst die Erklärung des ursprünglichen Programms (in Kenntnis der Tatsache, dass die verwendete Sequenz "Primzahl mit mindestens n Ziffern, deren Ziffernumkehr ebenfalls Primzahl ist").

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Wie Sie sehen, ist das Programm ziemlich unkompliziert, abgesehen von einer Sache: Es gibt eine völlig unbrauchbare b - behead Prädikatenaufruf, der das erste Element der Umkehrung unserer Zahl entfernt, mit dem wir nichts anfangen.

Dies ist ein eindeutiger Hinweis darauf, wie wir die Zeichenfolge finden können. Die Idee ist, dass wir, da wir die Länge der Zahl jedes Mal, wenn wir die Zeichenfolge hinzufügen, um eine Ziffer erhöhen möchten, eine Zeichenfolge benötigen, die die Länge dieser Zahl irgendwie "auswertet" und diese unbrauchbar macht b.

Die Lösung besteht darin, Folgendes zu verwenden ẹb: Zuerst ẹ - elementswird die Zahl in eine Liste von Ziffern umgewandelt. Dann b - beheadwird das erste Element entfernt. Der Trick ist, dass dies bfehlschlägt, wenn die Liste der Ziffern leer ist. Jedes Mal, wenn wir a anhängen b, erhöhen wir die Länge der erforderlichen Zahl um 1 (da dies fehlschlägt, bis der zugewiesene Wert von ?hoch genug ist, um ausreichend viele Ziffern zu enthalten, so dass die letzte bZiffer auf eine Liste mit einer Ziffer angewendet wird).

Eine erneute Zuordnung ẹhat keine Auswirkung, da es sich bereits um eine Ziffernliste handelt . Wir brauchen es am Anfang nur einmal, denn wenn wir eine Zahl wie 9001anstelle der Liste ihrer Ziffern enthaupten , erhalten wir, 001 = 1was Informationen über die Anzahl der Ziffern verliert.

VDM-SL , A000312 , nach abgelaufenen Daten

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Da VDM-SL- letAusdrücke Variablen, die bereits in einem einschließenden Bereich gebunden sind, erneut binden x**xkönnen , können sie in Bereichen, in denen xeiner mehr ist als im vorherigen Bereich, beliebig tief verschachtelt ausgewertet werden , während das Original ximmer noch weniger als die Kardinalität von ist m(1).

Haskell, A083318 von xnor

f=length     [2]
        $show

Probieren Sie es online!

Haskell , A000045 (Fibonacci) , durch Rins Fourier-Transformation

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Probieren Sie es online!

Genau 23 Bytes.

Dieser hat Spaß gemacht und war etwas knifflig. Die umgekehrte 0 und 1 warf mich ein wenig ab, bevor mir klar wurde, dass das kein Problem war. Der Mangel an$ Originals ließ mich skizzenhafte Dinge wie $...$id(ein Byte zu lang) ausprobieren, bevor mir klar wurde, dass ich alles in Klammern setzen konnte. Alles in allem ein schönes kleines Puzzle.

H.PWiz weist darauf hin , dass Musterabgleich gespeichert mir mindestens fünf Bytes haben könnte: $(\[x,y]->[y,x+y]). Diese verdammt sinnlose Herausforderung lässt mich überall sinnlos denken.