Diese Herausforderung zelebriert meine erste esoterische Sprache, Backhand !

Rückhand ist eine eindimensionale Sprache mit einem nichtlinearen Zeigerfluss. Der Zeiger bewegt sich drei Schritte gleichzeitig und führt nur jeden dritten Befehl aus.

Das Programm 1..1..+..O..@addiert 1 + 1 und gibt 2 aus, bevor es beendet wird. Die Zwischeninstruktionen werden übersprungen, es 1<>1()+{}O[]@handelt sich also genau um das gleiche Programm.

Wenn der Zeiger das Ende des Bandes verlässt, dreht er stattdessen die Richtung um und geht in die andere Richtung, so dass [email protected]+.das gleiche Programm läuft. Beachten Sie, dass die Endanweisung nur einmal gezählt wird. Dadurch können wir die meisten linearen Programme wie z1O+1@

Hier besteht Ihre Herausforderung darin, ein Programm oder eine Funktion zu schreiben, die eine Zeichenfolge akzeptiert, und die Anweisungen auszugeben, die ausgeführt würden, wenn das Programm wie Rückhand interpretiert würde (Sie müssen keine tatsächlichen Rückhandanweisungen verarbeiten). Sie dürfen nur ausgeben, bis der Zeiger auf dem letzten Zeichen des Strings landet (an diesem Punkt würde die Ausführung normalerweise rückwärts gehen).

Aber warte , das ist noch nicht alles! Wenn Ihr Programm selbst auf diese Weise interpretiert wird, sollte der resultierende Code einen der folgenden Werte ausgeben:

• (Mostly) works
• Turing complete
• 'Recreational' (Anführungszeichen können entweder 'oder "aber nicht beide sein)
• Perfectly okay
• Only a few bugs

Wenn Ihr Quellcode beispielsweise lautet code 2 backhand, sollte das Programm ce cankb od2ahdeinen dieser Sätze ausgeben.

Testfälle:

"1  1  +  O  @"  -> "11+O@"
"1O+1@"          -> "11+O@"
"HoreWll dlo!"   -> "Hello World!"
"abcdefghijklmnopqrstuvwxyz" -> "adgjmpsvyxurolifcbehknqtwz"
"0123456789"     -> "0369"  (not "0369630369")
"@"              -> "@"
"io"             -> "io"  (Cat program in Backhand)
"!?O"            -> "!?O" (Outputs random bits forever in Backhand)
"---!---!"       -> "-!-----!"

Und ein Referenzprogramm, das natürlich in Backhand geschrieben ist ( das könnte ein bisschen fehlerhaft sein Okay, ich denke, ich habe es behoben).

Regeln.

• Standardlücken sind verboten
• Die Eingabe des ersten Programms enthält nur druckbare ASCII- und Zeilenumbrüche (dh Bytes 0x20- 0x7Esowie 0x0A).
• Sie können wählen, ob Ihr zweites Programm von Ihrem ersten byte- oder UTF-8-Zeichen konvertiert wird.
• Zweites Programm:
  • Groß- und Kleinschreibung spielt keine Rolle, daher kann Ihre Ausgabe auch eine sein, pErFectLy OKaywenn Sie möchten.
  • Beliebig viele nachgestellte / führende Leerzeichen (Zeilenumbrüche, Tabulatoren, Leerzeichen) sind ebenfalls in Ordnung.
  • Das zweite Programm sollte dieselbe Sprache wie das erste sein, jedoch nicht unbedingt dasselbe Format (Programm / Funktion)
  • Ich freue mich, Vorschläge aus den Kommentaren zu zusätzlichen Phrasen aufzunehmen (sofern diese nicht zu kurz sind).
• Da dies Codegolf ist , ist es Ihr Ziel, die kürzeste Antwort für Ihre Sprache zu erhalten!
• In zwei Wochen werde ich die kürzeste Rückhand-Antwort mit 200 Kopfgeldern belohnen.

R , 187 Bytes

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g=function(x,n=nchar(x),i=c(1:n,(n-1):1,2:n),j=seq(1,3*n-2,3),k=i[j][1:which(i[j]==n)[1]])cat(substring(x,k,k),sep='') 

Probieren Sie es online!

Das einzelne Leerzeichen am Ende wird benötigt, damit das \nnie gedruckt wird, wenn das Programm auf sich selbst angewendet wird.

Erläuterung

Teil 1:

Ungolfed:

 # c  a  t  (  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  )  #
g <- function(x) {
  n <- nchar(x)                      # number of characters in string
  i <- c(1:n, (n - 1):1, 2:n)        # index: 1 to n, n-1 back to 1, 2 to n
  j <- seq(1, 3 * n - 2, 3)          # every third element of i
  k <- i[j][1:which(i[j] == n)[1]]   # the elements of i at indices j, up to the first appearance of n
  cat(substring(x, k, k), sep = "")  # extract from x the characters at indices k, and paste them together
}

Teil 2:

Die Funktion erzeugt dies, wenn sie auf das gesamte Programm einwirkt:

cat('Perfectly okay')#=ni(ncr)=1,-:2)=q,n,,i]:i(j=[]assi(k)e' 

Python 2 , 163 130 127 121 115 99 96 Bytes

i=input() ###
print(i+i[-2:0:-1]+i)[:len(i)*(len(i)%3%2or 3):3]  

#'p lr+yi  n'ottk(ca'eyPf'er)

Probieren Sie es online!

Ausgänge:

int #rt+-01i:n)l(%2 : 
print('Perfect' + # 33o3ie*(l)]:2i(i
#(p=iu)#pni[:-+[ei(n)%r)]
'ly okay')

Perl 6 , 101 86 Bytes

Wow, -25 Bytes dank nwellnhof durch drastische Verbesserung des ersten Programms

##
{S:g/(.).?.?/$0/}o{.comb%3-1??.chop~.flip~S/.//!!$_} #
#}{ "" s( kM ro os wt  l )y.

Probieren Sie es online!

Ich hoffe, dass mehr Leute den Rebound nutzen. Das Rückhandprogramm ist

#{g.?//{o%1.o.iS/!}
{"(Mostly) works"}#_!.~l~h?-bco0?.(:
#S/).$}.m3?cpfp//$ #        .

Was sich gerade dazu äußert {"(Mostly) works"}.

05AB1E , 43 40 38 37 Bytes

-2 Bytes (40 → 38) dank @Emigna .

„€€Ã€„Ѐ€µ'€Ý)\[ûDN3*©è  ?®IgD#<ÖNĀ*#

Probieren Sie es online aus . (PS: Wechseln Sie die Sprache von 05AB1E (Legacy) zu 05AB1E für Testfälle um 0123456789. Die Legacy-Version ist schneller, zeigt jedoch falsche Ergebnisse für Zahleneingaben mit führenden Nullen.)

Das "Rückhand" -Programm wird:

„ÃеÝ[N© I#N#

Welches wird perfectly okayin Kleinbuchstaben ausgegeben .

Probieren Sie es online aus.

Erläuterung Basisprogramm:

„€€Ã€           # Push the string "the pointed"
„Ѐ€µ           # Push the string "dm one"
'€Ý            '# Push the string "been"
     )          # Wrap the entire stack in a list
      \         # And remove that list from the stack again
[               # Start an infinite loop
 û              #  Palindromize the string at the top of the stack
                #   i.e. "1O+1@" becomes "1O+1@1+O1" the first iteration,
                #        and "1O+1@1+O1O+1@1+O1" the next iteration, etc.
  D             #  Duplicate the palindromized string
 N3*            #  0-indexed index of the loop multiplied by 3
    ©           #  Save it in the register (without popping)
     è?         #  Index into the string and print the character
  Ig            #  If the length of the input is exactly 1:
     #          #   Stop the infinite loop
 ®  D <Ö        #  If the value from the register is divisible by the length - 1
          *     #  And
        NĀ      #  The 0-indexed index of the loop is NOT 0:
           #    #   Stop the infinite loop

Erklärung 'Rückhand' Programm:

„ÃÐµÝ           # Push the string "perfectly okay"
     [          # Start an infinite loop
      N©        #  Push the index, and store it in the register (without popping)
          I     #  Push the input (none given, so nothing happens)
           #    #  If the top of the stack is 1, stop the infinite loop
            N   #  Push the index again
             #  #  If the top of the stack is 1, stop the infinite loop

Schritt für Schritt passiert folgendes:

1. „ÃеÝ: STACK wird ["perfectly okay"]
2. [: Endlosschleife starten
3. (erste Schleifeniteration) N©: STACK wird["perfectly okay", 0]
4. (erste Schleifeniteration) I: STACK bleibt bestehen, ["perfectly okay", 0]da keine Eingabe erfolgt
5. (erste Schleifeniteration) #: STACK wird ["perfectly okay"]und die Schleife wird fortgesetzt
6. (erste Schleifeniteration) N: STACK wird["perfectly okay", 0]
7. (erste Schleifeniteration) #: STACK wird ["perfectly okay"]und die Schleife wird fortgesetzt
8. (zweite Schleifeniteration) N©: STACK wird["perfectly okay", 1]
9. (zweite Schleifeniteration) I: STACK bleibt bestehen, ["perfectly okay", 1]da keine Eingabe erfolgt
10. (zweite Schleifeniteration) #: STACK wird ["perfectly okay"], und die Schleife bricht wegen der 1(Wahrheit)
11. Druckt implizit den oberen Bereich des Stapels nach STDOUT: perfectly okay

Befolgen Sie die hier beschriebenen Schritte, wenn der Debugger für TIO aktiviert ist.

Sehen Sie diese 05AB1E Spitze von mir (Abschnitt Wie das Wörterbuch benutzen? ) Zu verstehen , warum „€€Ã€„Ѐ€µ'€Ýsind the pointed, dm oneund beenund „ÃеÝist perfectly okay.

Alte 38-Byte-Version:

„€€Ã€„Ѐ€µ'€Ý)\ giqë¬?[ûDN>3*©è?®Ig<Ö#

Probieren Sie es online aus . (PS: Wechseln Sie die Sprache von 05AB1E (Legacy) zu 05AB1E für Testfälle 0123456789und @. Die Legacy-Version ist schneller, zeigt jedoch falsche Ergebnisse für Zahleneingaben mit führenden Nullen oder Eingaben mit einzelnen Zeichen.)

Das "Rückhand" -Programm wird:

„ÃÐµÝ q?D3èIÖ<®©>û¬i\€€„€€€€')gë[N*?g#

(Wo der qdas Programm verlässt und alles andere no-ops macht.)

Probieren Sie es online aus.

Python 2 , 130 Bytes

p='r'#i  n  t  '  P  e  r  f  e  c  t  l  y     o  k  a  y  '  # 
s=input();S=s+s[-2:0:-1]+s
print S[:len(~-len(s)%3and S or s):3]

Probieren Sie es online!

JavaScript (ES6), 130 Byte

Früher Versuch. Nicht sehr befriedigend.

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/(g=p=>(c=y[p])?m++%3?g(p+d):y[p+1]?c+g(p+d):c:g(p-d-d,d=-d))(m=0,d=1)

Probieren Sie es online!

Wenn der Code von selbst verarbeitet wird, werden die folgenden Zeichen isoliert:

f  =/*>  "  P  e  r  f  e  c  t  l  y     o  k  a*/y=>""+/**/…
^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^  ^

was gibt:

f=>"Perfectly okay"//…

Gelee , 34 Bytes

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€

Ein vollständiges Programm oder ein monadischer Link, der eine Liste von Zeichen akzeptiert, die gedruckt oder ausgegeben werden.

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Der durch die Rückhand geparste Code lautet dann:

Jȧ“N2s]Ỵ»ị@€

Ein volles Programm oder ein Niladic Link drucken oder ergeben (bzw.) Turing abgeschlossen .

Wie?

JŒḄȧ`ȯ“”NNŒḄ2¡3s@”]ȧZỴḢḢ»`Qị⁸ȧ@11€ - Main Link: list of characters   e.g. 'abcd'
J                                  - range of length                      [1,2,3,4]
 ŒḄ                                - bounce                         [1,2,3,4,3,2,1]
    `                              - use as both arguments of:
   ȧ                               -   logical AND [x AND x = x]
      “”                           - literal empty list of characters
     ȯ                             - logical OR [when x is truthy: x OR y = x]
        N                          - negate  }
         N                         - negate  } together a no-op
             ¡                     - repeat this...
            2                      - ... two times:
          ŒḄ                       -   bounce                       [1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1,2,3,4,3,2,1]
              3                    - literal three
               s@                  - split into (threes)            [[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1,2,3],[4,3,2],[1]]
                 ”]                - literal ']' character
                   ȧ               - logical AND [']' is truthy so a no-op]
                    Z              - transpose                      [[1,4,1,4,1,4,1,4,1],[2,3,2,3,2,3,2,3],[3,2,3,2,3,2,3,2]]
                     Ỵ             - split at new lines [no newline characters exist in this list of ints so effectively wrap in a list]
                      Ḣ            - head [undo that wrap]
                       Ḣ           - head [get the first of the transposed split indices]
                                   -                                [1,4,1,4,1,4,1,4,1]
                         `         - use as both arguments of:
                        »          -   maximum [max(x, x) = x]
                          Q        - de-duplicate                   [1,4]
                            ⁸      - chain's left argument (the input)
                           ị       - index into it                  "ad"
                               11€ - literal eleven for €ach (of input)
                             ȧ@    - logical AND with swapped args [[11,11,...,11] is truthy]
                                   -                                "ad"
                                   - (as a full program implicit print)

Der durch die Rückhand geparste Code lautet dann:

Jȧ“N2s]Ỵ»ị@€ - Main Link: no arguments
J            - range of length (of an implicit 0, treated as [0]) -> [1]
  “N2s]Ỵ»    - compression of "Turing complete"
 ȧ           - logical AND [[1] is truthy] -> "Turing complete"
           € - for each character in the list of characters:
          @  -   with swapped arguments (an implicit 0 is on the right, so f(0, "Turing complete"))
         ị   -     index into
             - (as a full program implicit print)

Runenverzauberungen , 294 Bytes

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                                  /{\!?   =ka:{;!?=ka\
v   R                         R {{R:ak=?!\:$:'@=?!;{:/
v/?!/:$:'@=?!;}:ak= ?!;}:ak=?!\}\        }
y\=ka:L                      }{ /        }
\iuakrU      y<<              !  }}}L {{{L

Probieren Sie es online!

Unkomprimierte (und fast lesbare) Version:

>; "  O  n  l  y     a     F  e  w     B  u  g  s  "  @
                               ;           /                                 \
/y<<         R                         R {{R:ak=?!\:$:'@=?!;{:ak=?!\{:ak=?!\{/
RiuakrR:ak=?!/:$:'@=?!;}:ak= ?!/}:ak=?!\}\        }                ;
\y<<  U                               }{ /        }
      \                                !          L                     }}}L

Probieren Sie es online!

Das ... ist so nah wie ich nur kann.

Wenn Sie es weiter komprimieren, müssen Sie herausfinden, wie Sie mit den verschiedenen Loop-Swapping-Punkten umgehen können, ohne dass sie mit anderen Elementen kollidieren. Die erste Zeile (der einzige Teil, der als Eingabe an sich selbst übergeben werden muss) muss getrennt bleiben: Die gesamte Zeichenfolge kann nicht ohne Probleme in die zweite Zeile passen ( _für erforderliche Leerzeichen):

Needed string:
>; "  O  n  l  y  _  a  _  F  e  w  _  B  u  g  s
Best fit:
>; "  O  n  l  y  _  a  _  F  e  w/{_\!?   =ka:{;!?=ka\
Collision:                             ↑

Dies ?kann nicht von dem entfernt werden, !was selbst nicht von dem entfernt werden kann, \und keine der zulässigen Nachrichten lässt eines dieser drei Zeichen an dieser Position zu.

Die Alternative wäre, die Flussumleitung zu verwenden. Dies führt jedoch zu einem Problem in der unteren Zeile:

Last usable character:
            ↓
>"Only a Few Bugs"@
/.../
ur         }{L
              ↑
Earliest available free space:

Da müssen wir den Loop-Schalter im Hauptprogramm meiden.

Bekannte Probleme:

• Extrem große Eingänge. Aufgrund der IP-Stack-Beschränkungen von Runic führt das Drücken sehr großer Eingabezeichenfolgen dazu, dass die IP-Adresse vor dem Abschluss abläuft. Dies kann minimiert werden, indem zusätzliche IPs erzeugt und zusammengeführt werden (z. B., abcdefghijklmnopqrstuvwxyzwenn nur nicht die gesamte eigene Quelle verarbeitet wird). Und es gibt eine Grenze, unabhängig davon, wie viele Zusammenführungen stattfinden. Kann bis zu 58 Bytes an Eingaben im Ist-Zustand verarbeiten (zusätzlich muss zur Erhöhung der Anzahl der IPs herausgefunden werden, wie diese zusammengeführt werden können, ohne mehr Speicherplatz zu belegen). Kann zwei weitere IP-Einträge in die Loop-Return-Zeile einfügen (rechts von der UZeile beginnend \y<<in der unkomprimierten Version oder links von der Zeile über der y<<in der komprimierten Version), wodurch die maximale Länge der Eingabe auf 78 erhöht wird.
• Eingabezeichenfolgen mit Leerzeichen müssen mit einem Escapezeichen versehen sein (z 1\ \ 1\ \ +\ \ O\ \ @. B. ). Dies ist eine Einschränkung der Syntaxanalyse der Sprache.
• Eingaben, die aus Zeichenfolgen bestehen, die wie Ganzzahlen aussehen, die mit einer beliebigen Anzahl von 0s beginnen, können nicht bereitgestellt werden (wenn sie in eine Zahl auf dem Stapel umgewandelt werden, geht die 0verloren). Auch hier Einschränkung der Syntaxanalyse der Sprache.

Wie es funktioniert

Eintrag:

1. Kombiniere 4 Befehlszeiger
2. Eingaben lesen, in Zeichen aufteilen, eine neue Zeile anhängen, umkehren, in die Hauptschleife eintreten.

Hauptschleife (vor allem, was auf dem Stack erscheint, steht ein Dup):

1. Drucken Sie die Oberseite des Stapels
2. Vergleiche mit newline. True: Loops wechseln und Stack zweimal nach links drehen.
3. Vergleichen Sie mit @. True: Beenden. (Kommando beenden ausgeführt)
4. Stapel nach rechts drehen
5. Vergleiche mit newline. True: Beenden. (Befehl ganz rechts ausgeführt)
6. Stapel nach rechts drehen
7. Vergleiche mit newline. True: Loops wechseln und Stack dreimal nach links drehen.
8. Stapel nach rechts drehen
9. Zurück zum Anfang der Schleife

Sekundärschleife:

• Identisch mit der Hauptschleife, nur Schalter nach rechts drehen mit nach links drehen