Ein Geigerzähler ist ein Gerät, mit dem Strahlung erfasst wird.

Wir werden ein Geigerzählerprogramm machen.

Wie wir alle wissen, entfernt Strahlung, wenn sie auf ein Computerprogramm trifft, zufällig genau 1 Byte. Ein Geigerzähler-Programm ist also ein Programm, das selbst nichts tut, aber wenn ein Byte entfernt wird, wird das geänderte Programm gedruckt beep, um das Vorhandensein von Strahlung anzuzeigen.

Antworten werden in Bytes bewertet, wobei weniger Bytes besser sind. Die Antworten müssen mindestens 1 Byte lang sein.

Ihr Programm druckt möglicherweise beepmit einem Zeilenumbruch oder druckt eine einzelne Zeile für eine leere Ausgabe, sofern dies konsistent geschieht. Ihr Programm kann auch einen anderen Fall verwenden , beepwie zum Beispiel BEEP, bEEPoder Beepso lange , wie es so konsequent tut.

Verloren , 303 293 263 253 238 228 Bytes

v^"peeb"<\>"beepvv"((>@@>>%%>>(((((([[[[[[\
>>>>>>>>>//>>>>>>>>>>>>>>/>>/>>>>>>>>>>>>>\\
>>>>>>>>//>>>>\>>>>>>>>>>/>>>>>>>>>>>>>>>>>\\
>/>>>>>>>/>>>>>>>>>>>>\>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>\\>>>>\>>>>>>>>>>>>>>>>\

Probieren Sie es online!

Überprüfungsskript (aus der Antwort von Benutzer 202729 entlehnt ). Leider kann nur die Hälfte des Codes gleichzeitig getestet werden, aber ich kann Ihnen versichern, dass ich das gesamte Programm getestet habe.

Autsch, das war eine schwierige Frage. Ich zitiere die gelöschte Antwort von WW:

Lost ist vielleicht die interessanteste Sprache für diese Herausforderung. In Lost ist die Startposition und -richtung des Zeigers völlig zufällig. Um deterministische Programme zu erstellen, müssen Sie jede mögliche Startposition und -richtung berücksichtigen. Gleichzeitig müssen Sie aufgrund dieser Herausforderung auch berücksichtigen, dass ein einzelnes Byte entfernt wird.

Leider berücksichtigte seine Antwort nicht das Entfernen von Zeilenumbrüchen, was alles vermasselte.

Erläuterung:

(Beachten Sie, dass hier und da ein paar Bytes aus sein können)

Lassen Sie uns zuerst über die allgemeine Struktur des Codes sprechen:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\       Processing line
>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\      Beep line
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\     Back-up beep line
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\    Back-up return line
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\    Return line

Alles außer der Verarbeitungslinie muss vollständig aus einem >oder mehreren bestehen \/. Warum? Nun, als Beispiel wollen wir eine neue Zeile entfernen:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\

Die erste Zeile ist jetzt viel länger als der Rest des Blocks. Wenn ein Zeiger auf einem Nicht- >\/Charakter mit vertikaler Bewegung erscheint, bleibt er in einer Endlosschleife stecken.

Der größte Teil des Strahlungsdetektors ist der Abschnitt am Ende jeder Zeile.

 \
 \\
 >\\
 >>\\
 >>>\

Normalerweise verlässt eine IP, die diese von der ersten Zeile durchläuft, die letzte Zeile. Wenn jedoch ein Zeichen in der Zeile entfernt wird, wird diese Zeile um eins nach unten verschoben, z.

 \
 \\
 >\\
 >\\
 >>>\

Und die IP verlässt stattdessen die Zeile, in der ein Byte fehlt (mit Ausnahme der letzten Zeile, in der sie die vorletzte Zeile verlässt).

Von dort wird jede der ersten vier Zeilen in die zweite Zeile umgeleitet:

v
>>>>>>>>>>
>>>>>>>>//
>/

Welches führt dann in einen der beiden beepers.

v^"peeb"<<\/"beepvv"((>
>>>>>>>>>>//

Wenn eines der Bytes im ersten beeper entfernt wurde, geht es stattdessen zum zweiten:

v^^"peb"<<\/"beepvv"((>
>>>>>>>>>>>//

Beide beepführen dann zurück zur ersten Zeile und zum Abschluss @.

Einige andere verschiedene Teile:

Das (((((([[[[[[[wird verwendet, um den Stapel zu löschen, wenn der Zeiger in einem Paar Anführungszeichen beginnt und die gesamte erste Zeile zum Stapeln drückt. Es muss leider so lange dauern, da der erste Zeilenumbruch entfernt werden kann, um die erste Zeile doppelt so groß zu machen. Das Experimentieren mit der beepVerwendung von Arithmetik anstelle von Anführungszeichen dauerte länger.

Das über die Zeilen verstreute \s und /s gibt an, dass Bytes in der oberen Codezeile durch Umleiten des Zeigers auf die richtigen Zeilen abgelegt werden sollen. Da die meisten Bottom-Lines nur Filler sind, kann nur die Top-Line gespielt werden. Wenn jemand Ideen für einen kürzeren strahlungssicheren Stapel hat, der klarer ist als das, was ich jetzt habe, kann er dies gerne kommentieren.

Hexagony , 38 Bytes

.....;p;<>b;e;/<b;e;;p...@@.......;@..

Probieren Sie es online!

Überprüfungsprogramm.

Erläuterung

Wir nutzen hier die automatische Erkennung der Sechseckseitenlänge durch Hexagony.

Wenn keine Bytes entfernt werden, hat das Programm die Seitenlänge 4 und sieht folgendermaßen aus:

Wenn jedoch ein Byte entfernt wird. Es gibt 2 Fälle.

1. Das entfernte Byte ist nach dem zweiten <.

   Der Ausführungsablauf wäre:

   

   Es gibt 2 aufeinanderfolgende @in der 5. Zeile. Selbst wenn eine davon entfernt wird, schlägt die IP sicher ein @.

2. Das entfernte Byte liegt bei oder vor dem zweiten <.

   Dann bleibt die zweite Hälfte erhalten und die IP wird dadurch nicht mehr nach oben umgeleitet <. Bild des Ausführungsablaufs:

   

Hexagony , 34 29 Bytes

//..>;e;<b@;p;/|/;e;;\.b@;p<@

Probieren Sie es online! Nachprüfung!

Erläuterung:

Hier ist der normale Code, der mit HexagonyColorer zu einem richtigen Hexagon formatiert wurde :

Das Double //am Anfang sorgt dafür, dass dieser Weg immer eingeschlagen wird. Wenn ein Zeichen entfernt wird, @wird es aus dem Pfad entfernt, entweder um eins zurückgeschoben oder selbst entfernt:

In diesem Fall haben wir ein Zeichen nach dem |folgenden Pfad entfernt beep:

Wenn wir stattdessen ein Zeichen vor dem |(oder dem |selbst) entfernen , folgen wir dem anderen Signaltondrucker:

Wir haben dann alle Möglichkeiten berücksichtigt und verwenden nur beepdie nicht bestrahlten Teile des Programms.

Selbstmodifizierendes Brainfuck , 73 63 Bytes

<<[[[[<<]]>[[.>>..>>.[,>]]]]   bbeepp+[<<<]>>[[>]>>>.>>..>>.,+]

Probieren Sie es online! Nachprüfung!

Die Leerzeichen in der Mitte des Codes repräsentieren tatsächlich NUL-Bytes.

Erläuterung:

Der Code ist durch 3 NUL-Bytes in der Mitte in zwei Abschnitte unterteilt. Beide drucken grundsätzlich, beepwenn der andere Abschnitt bestrahlt wird (mit ein paar Ausnahmen).

Zunächst muss <<[[sichergestellt werden, dass ]zu jedem Zeitpunkt alle s übereinstimmen. [s wird nicht versuchen, nach einer Übereinstimmung zu suchen, ]wenn die Zelle positiv ist, während ]s dies tut . Wenn überhaupt] zu einer dieser Klammern zurück, springt er normalerweise sofort zurück, weil sich die Zelle in einer Klammer befindet 0.

Im nächsten Teil wird [[<<]]>dann geprüft, ob die Länge von Abschnitt 2 gerade ist. In diesem Fall wird die andere Hälfte von Abschnitt 1 ausgeführt, die beepmit dem bbeeppam Anfang von Abschnitt 2 angegebenen Befehl gedruckt wird .

[[.>>..>>.[,>]]]]

Anschließend wird der gesamte Abschnitt 2 gelöscht, sodass er nicht ausgeführt wird.

In Abschnitt 2 prüfen wir, ob die Länge von Abschnitt 1 und den NUL-Bytes durch 3mit teilbar ist +[<<<]>>.

[[>]>>>.>>..>>.,+]

Ebenso drucken wir beep.

Z80Golf , 53 36 34 Bytes

-16 Bytes dank @Lynn
-2 Bytes dank @Neil

Da es sich nur um Z80-Maschinencode handelt, sind in diesem Code viele nicht druckbare Dateien enthalten. Verwenden Sie also einen xxd -rumkehrbaren Hexdump:

00000000: ddb6 2120 10dd b615 280c 003e 62ff 3e65  ..! ....(..>b.>e
00000010: ffff 3e70 ff76 003e 62ff 3e65 ffff 3e70  ..>p.v.>b.>e..>p
00000020: ff76                                     .v

Probieren Sie es online! (ausführlicher Tester in Python)

Erläuterung

z80golf ist Anarchy Golfs hypothetische Z80-Maschine, bei der call $8000es sich um einen Putchar handelt.call $8003 einen Getchar handelt, haltder den Interpreter beendet, Ihr Programm abgelegt $0000wird und der gesamte andere Speicher mit Nullen gefüllt ist. Es ist ziemlich schwierig, Programme in der Assembly strahlungssicher zu machen, aber eine allgemein nützliche Technik ist die Verwendung von Anweisungen mit einem Byte im Idempotenten. Beispielsweise,

or c        ; b1    ; a = a | c

ist nur ein Byte und a | c | c == a | c kann daher durch einfaches Wiederholen des Befehls strahlungssicher gemacht werden. Beim Z80 besteht ein 8-Bit-Sofortladevorgang aus zwei Bytes (wobei der Sofortladevorgang sich im zweiten Byte befindet), sodass Sie auch einige Werte zuverlässig in Register laden können. Das habe ich ursprünglich zu Beginn des Programms getan, damit Sie die längeren Varianten analysieren können, die ich am Ende der Antwort archiviert habe, aber dann habe ich festgestellt, dass es einen einfacheren Weg gibt.

Das Programm besteht aus zwei unabhängigen Nutzlasten, von denen eine durch Strahlung beschädigt worden sein könnte. Ich überprüfe, ob ein Byte entfernt wurde und ob das entfernte Byte vor der zweiten Kopie der Nutzdaten lag, indem ich die Werte einiger absoluter Speicheradressen überprüfe.

Zuerst müssen wir gehen, wenn keine Strahlung beobachtet wurde:

    or a, (ix+endbyte) ; dd b6 21 ; a |= memory[ix+0x0021]
    jr nz, midbyte     ; 20 10    ; jump to a halt instruction if not zero

Wenn irgendein Byte entfernt wurde, dann alle werden die Bytes verschieben und $0020die letzte enthalten 76, so$0021 eine Null. Wir können es uns leisten, den Beginn des Programms zu strahlen, obwohl es praktisch keine Redundanz gibt:

• Ist der Sprung versetzt $10 entfernt wird, wird die Strahlung korrekt erfasst, der Sprung wird nicht ausgeführt, und der Versatz spielt keine Rolle. Das erste Byte des nächsten Befehls wird verbraucht, aber da es so konzipiert ist, dass es resistent gegen das Entfernen von Bytes ist, spielt dies keine Rolle.
• Wenn der Sprung - Opcode $20entfernt wird, dann versetzte der Sprung $10wird als dekodieren djnz $ffe4(raubend das nächste Befehlsbyte als Offset - siehe oben), die eine Schleifenanweisung ist - Dekrement - B, und zu springen , wenn das Ergebnis nicht null ist. Weil ffe4-ffffmit Nullen gefüllt ist (nop ist und der Programmzähler einen Zeilenumbruch durchführt, wird der Programmanfang 256-mal ausgeführt und anschließend fortgesetzt. Ich bin erstaunt, dass dies funktioniert.
• Wenn Sie das entfernen, $ddwird der Rest des Snippets als dekodiert or (hl) / ld ($1020), hlund dann in den nächsten Teil des Programms verschoben. Das orändert keine wichtigen Register, und da HL zu diesem Zeitpunkt Null ist, wird das Schreiben ebenfalls abgebrochen.
• Wenn Sie das entfernen, $b6wird der Rest ld ($1020), ixwie oben beschrieben dekodiert .
• Wenn Sie den entfernen $21, frisst der Decoder den $20und löst das djnzVerhalten aus.

Beachten Sie, dass durch die Verwendung von or a, (ix+*)zwei Bytes ld a, (**) / and a / and adurch die integrierte Prüfung auf Null gespart wird .

Wir müssen jetzt entscheiden, welche der beiden Kopien der Nutzlast ausgeführt werden soll:

    or (ix+midbyte)  ; dd b6 15
    jr z, otherimpl  ; 28 0c
    nop              ; 00
    ; first payload
    ld a, 'b'        ; 3e 62
    rst $0038        ; ff
    ld a, 'e'        ; 3e 65
    rst $0038        ; ff
    rst $0038        ; ff
    ld a, 'p'        ; 3e 70
    rst $0038        ; ff
midbyte:
    halt             ; 76
otherimpl:
    nop              ; 00
    ld a, 'b'        ; 3e 62
    ; ...            ; ...
    rst $0038        ; ff
endbyte:
    halt             ; 76

Die zwei Kopien sind durch ein NOP getrennt, da ein relativer Sprung verwendet wird, um zwischen ihnen zu wählen, und Strahlung das Programm auf eine Weise hätte verschieben können, die den Sprung zum Überspringen des ersten Bytes nach dem Ziel führen würde. Zusätzlich wird der NOP als Null codiert, wodurch es einfach ist, verschobene Bytes zu erkennen. Beachten Sie, dass es keine Rolle spielt, welche Nutzdaten ausgewählt werden, wenn der Switch selbst beschädigt ist, da dann beide Kopien sicher sind. Stellen wir aber sicher, dass es nicht in den nicht initialisierten Speicher springt:

• Durch Löschen $ddwerden die nächsten zwei Bytes als dekodiertor (hl) / dec d . Clobbers D. Keine große Sache.
• Durch das Löschen $b6wird eine undokumentierte längere Codierung für erstellt dec d. Das gleiche wie oben.
• Beim Löschen $15wird $28stattdessen der Wert als Versatz gelesen , und die Ausführung erfolgt $0cwie unten beschrieben.
• Wenn $28verschwindet, wird der $0cals dekodiert inc c. Die Nutzlast kümmert sich nicht darum c.
• Löschen $0c- dafür ist der NOP da. Andernfalls wäre das erste Byte der Nutzlast als Sprungoffset gelesen worden, und das Programm würde in den nicht initialisierten Speicher springen.

Die Nutzlast selbst ist ziemlich einfach. Ich denke, die geringe Größe der Zeichenfolge macht diesen Ansatz kleiner als eine Schleife, und es ist einfacher, auf diese Weise positionsunabhängig zu machen. Die ein beepWiederholungen, so kann ich ein abrasieren ld a. Auch, weil alle Speicher zwischen $0038und auf $8000Null gesetzt wird, kann ich durch sie fallen und eine kürzere verwenden rstVariante der callAnweisung, die nur funktioniert für $0, $8, $10und so weiter, bis zu$38 .

Ältere Ansätze

64 Bytes

00000000: 2e3f 3f2e 3f3f 7e7e a7a7 201f 1e2b 2b1e  .??.??~~.. ..++.
00000010: 2b2b 6b00 7ea7 2814 003e 62cd 0080 3e65  ++k.~.(..>b...>e
00000020: cd00 80cd 0080 3e70 cd00 8076 003e 62cd  ......>p...v.>b.
00000030: 0080 3e65 cd00 80cd 0080 3e70 cd00 8076  ..>e......>p...v

58 Bytes

00000000: 2e39 392e 3939 7e7e a7a7 2019 3a25 00a7  .99.99~~.. .:%..
00000010: 2814 003e 62cd 0080 3e65 cd00 80cd 0080  (..>b...>e......
00000020: 3e70 cd00 8076 003e 62cd 0080 3e65 cd00  >p...v.>b...>e..
00000030: 80cd 0080 3e70 cd00 8076                 ....>p...v

53 Bytes

Dieser hat eine Erklärung in der Bearbeitungshistorie, aber es ist nicht zu unterschiedlich.

00000000: 3a34 00a7 a720 193a 2000 a728 1400 3e62  :4... .: ..(..>b
00000010: cd00 803e 65cd 0080 cd00 803e 70cd 0080  ...>e......>p...
00000020: 7600 3e62 cd00 803e 65cd 0080 cd00 803e  v.>b...>e......>
00000030: 70cd 0080 76                             p...v

Was ist, wenn: eine nicht leere Ausgabe in Ordnung war anstelle eines Pieptons

1 Byte

v

halts das Programm normalerweise, aber wenn Strahlung es entfernt, dann ist der Speicher voll von Nullen, so $8000dass unendlich oft ausgeführt wird und viele Null-Bytes gedruckt werden.

> <> 23 Bytes

<|o<"beep"/
>o<"beep"<\

Probieren Sie es online! Nachprüfung.

Es ist ehrlich gesagt wirklich überraschend, wie kurz ich das habe. Endet mit einem Fehler.

Nicht fehlerhafte Version, 29 Bytes

<<;oooo"beep"/
 ;oooo"beep"<\

Probieren Sie es online!

Klein , eine von jeder Topologie, insgesamt 291 Bytes

Nachdem ich die Antwort von WW anhand der 001Topologie gesehen hatte, entschloss ich mich zu prüfen, wie schwierig es sein würde, für jede Topologie einen Geigerzähler zu erstellen. (Spoiler: sehr schwer. Es ist schwierig herauszufinden, wohin der Zeiger ohne Handbewegungen führen wird, die mich aussehen lassen, als würde ich herausfinden, welche Hand meine linke ist.)

Nachprüfung!

(Ich habe auch darüber nachgedacht, ein Programm zu schreiben, das ein gültiger Geigerzähler für alle Topologien ist, aber das muss möglicherweise warten. Wenn jemand anderes es dennoch versuchen möchte, biete ich eine Prämie von 500 Wiederholungen an.)

000 und 010, 21 Bytes

<<@"peeb"/
.@"peeb"<\

Probieren Sie 000 online! und versuchen Sie 010 online!

Dies ist aus meiner ><>Lösung portiert . Dies funktioniert offensichtlich in 000, da dies die Standardtopologie für die meisten 2D-Sprachen ist, aber ich war überrascht, dass es auch in funktioniert 010.

001 und 011, 26 Bytes

!.<<@"peeb"/
.@"peeb"..<..

Versuchen Sie 001 online! und versuchen Sie 011 online!

Dieser wird direkt aus der Antwort von WW übernommen . Vielen Dank!

100, 21 Bytes

//@"peeb"\
@"peeb".</

Probieren Sie es online!

101, 21 Bytes

//@"peeb"/
@"peeb".<!

Probieren Sie es online!

110, 26 Bytes

<.<@"peeb"\\
.\@."peeb".\<

Probieren Sie es online!

111, 24 Bytes

<<@"peeb"<\
...@"peeb"//

Probieren Sie es online!

200, 21 Bytes

<<@"peeb"\
@"peeb".!/

Probieren Sie es online!

201, 31 Bytes

\\.\.@"peeb"</./
./...@"peeb"<\

Probieren Sie es online!

Mit Abstand das nervigste.

210, 26 Bytes

/\\@"peeb"</\
/@.."peeb"<\

Probieren Sie es online!

211, 27 Bytes

\\."peeb"((</
!/@@<"peeb"<\

Probieren Sie es online!

Der einzige, bei dem ich den Piepser über die rechte Seite eingeben musste.

Selbstmodifizierender Brainfuck , 144 102 Bytes

Nicht druckbare Dateien werden beispielsweise als Escape-Sequenz angezeigt \x01.

\xa8<<[[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[[[.<-]>[>-]\x01qffb\x00\x00beep\x00]]]<[>]<<[>[-<+>]+<<]>[[>]>>[.>]]\x01

Nachprüfung!

Runenverzauberungen , 29 Bytes

>>yyLL@"peeb"/
     @"peeb"L\

Probieren Sie es online!

Im Wesentlichen dasselbe wie die Klein 000-Antwort oder die> <> -Antwort (ich habe mit der Klein-Antwort begonnen). Die einzige wirklich notwendige Änderung bestand darin, das <in Lund .in  (Übersetzung von Befehlssymbolen) umzuwandeln, die IP-Einstiegspunkte einzufügen (brauchen Sie 2, andernfalls würde ein Löschen zu einem nicht kompilierenden Programm führen) und den yBefehl dela einzufügen , um das zu erhalten zwei IPs zusammenführen (also nur eine drucken)beep ), wieder zwei benötigen. Außerdem müssen zusätzliche NOPs eingefügt werden, um die Leitungslängen gleich zu halten. Klein nutzt bequemerweise auch@ für "Drucken und Beenden".

Keine Möglichkeit, das Leerzeichen unten links zu verwenden, da Reflektoren zur Richtungsänderung die Fähigkeit zur Strahlungserkennung beeinträchtigen. zB (26 Bytes, bestrahlt y):

/yLL@"peeb"/
\<<  @"peeb"L\

Druckt keine Ausgabe, da das verbogene Eingangssegment eine Rückreflexion zum Abschlusswiderstand der unteren Zeile verursacht.

Befunge-93 , 55 Bytes

<< >       vv
>,,@#"beep"<"
v  |   _ #-<_
>"peeb",,,,@>

Probieren Sie es online! Nachprüfung!

Ich hatte gehofft, dass es ein bisschen kleiner wird, aber die Länge des beepDruckers ist der Engpass.

Wumpus , 37 34 32 31 Bytes

777*7..@ $o&4"beep"|"@peeb"4&o@

Probieren Sie es online! Nachprüfung!

Diese Lösung nutzt die Tatsache, dass . die Länge des Programms zu einem Positionsmodul springt.

Alternativ für die gleiche Anzahl von Bytes

" @o&4"beep"}@
@o&4"beep"}$}  

Probieren Sie es online! Nachprüfung!

Dieser nutzt den Unterschied in der Richtung des Zeigers für ungerade und gerade Zeilenlängen. (Ich weiß nicht wirklich, wie das erste "tatsächlich funktioniert, wenn der Zeilenumbruch entfernt wird)

Klein (001), 26 Bytes

!.<<@"peeb"/
.@"peeb"..<..

Probieren Sie es online!

Überprüfen!

Erläuterung

Dieses Programm nutzt die einzigartige Topologie von Klein, insbesondere die 001 Topologie, bei der es sich um eine Klein-Flasche handelt.

Unbearbeitet folgt das Programm dem Ausführungspfad:

Das Entfernen eines Bytes aus dem Programm kann das Programm auf vier Arten beeinflussen (jede in einer anderen Farbe):

Das Erste, was zu beachten ist, ist, dass <<die IP beim Start immer links vom Ursprung abgelenkt wird. Wird eines der <s gelöscht, tritt das andere an seine Stelle. Wenn also ein Byte aus dem roten Bereich entfernt wird, folgt der folgende Ausführungspfad:

Wenn das blaue Byte entfernt wird, erhalten wir den sehr einfachen Pfad:

Wenn der Zeilenumbruch entfernt wird, erhalten wir den Pfad:

Der gelbe Weg ist etwas komplexer. Da die unterste Zeile länger als die oberste Zeile ist, wird beim Quadrieren des Programms zu Beginn der Ausführung ein virtuelles Zeichen an das Ende der ersten Zeile angefügt, um die gleiche Größe zu erhalten. Wenn ein Byte in der zweiten Zeile entfernt wird, wird die Zeile gekürzt und das virtuelle Zeichen nicht hinzugefügt. Dies ist wichtig, da !normalerweise über den virtuellen Charakter gesprungen wird, in seiner Abwesenheit jedoch /.

Rückhand , 25 21 Bytes

vv""ppeeeebb""jjHH@

Probieren Sie es online! Nachprüfung!

Dies nutzt die Fähigkeit von Backhand, den Zeigerschrittwert zu ändern, um jeden Schritt einer Anweisung zu überspringen und das Redunanzproblem sauber zu lösen. Es verwendet dann diej Befehl geprüft, ob der Code bestrahlt wird, indem zum letzten Zeichen ( @, halt) Hund, falls ja , zum vorletzten ( , halt und Ausgabestapel) gesprungen wird .