Palindrom-Palindrom-Generator

22

Erstellen Sie ein Programm, das die Eingabezeichenfolge beginnend mit der Eingabezeichenfolge in ein Palindrom konvertiert. Das Programm selbst muss ein Palindrom sein.

Zum Beispiel Eingabe:, neverodDrucken neveroddoreven. Sie sollten auch Mehrwort- und Mehrzeileneingaben verarbeiten.

tmp
quelle
2
Dies scheint dieser Frage sehr ähnlich zu sein , außer dass wir hier generieren anstatt zu prüfen. Es ist jedoch wahrscheinlich, dass die gleichen Tricks angewendet werden, um das Programm zu einem Palindrom zu machen.
Sp3000,
2
Ich kann die abgelehnte Frage völlig verstehen, aber warum wurde die Antwort abgelehnt?
John Dvorak
2
@ JanDvorak Ich vermute, es ist, weil es Kommentare verwendet, um das Palindrom zu machen, was diese Strategie speziell in Ordnung macht. Dies ist keine sehr interessante Methode und ist in mindestens einer Frage, die palindromischen Code erfordert, ausdrücklich verboten: codegolf.stackexchange.com/q/28190/15599 . Tomek, willkommen beim Programmieren von Rätseln und Codegolf. Ich stimme trotzdem zu, damit Sie Zugriff auf unsere Sandbox haben . Denken Sie auch daran, nach ähnlichen Fragen zu suchen, bevor Sie "
Level River St
Sind Funktionen erlaubt (anstelle von ganzen Programmen)?
Nimi
Können wir einen Begrenzer für das erzeugte Palindrom verwenden? dh neverod-> neverodadoreven(mit dem adazwischen)
Rɪᴋᴇʀ

Antworten:

26

Dyalog APL, 6 4

⌽,,⌽

Probieren Sie es hier aus.

Andere Lösungen:

⌽,⊢⊢,⌽
⌽⊢⊢,⊢⊢⌽

Erläuterung

Sie sind nur:

{⌽((,⍵),(⌽⍵))}
{⌽((,⍵)⊢((⊢⍵),(⌽⍵)))}
{(⌽⍵)⊢((⊢⍵),((⊢⍵)⊢(⌽⍵)))}

Monadisch ,und macht nichts mit Streichern. Dyadisch ,ist Verkettung. Dyadic gibt seinen rechten Operanden zurück. Und ist offensichtlich Umkehrung.

jimmy23013
quelle
1
Beachten Sie, dass dies nur in Dyalog APL funktioniert.
FUZxxl
22

Piet 19x2 = 38

http://www.pietfiddle.net/img/aoNhlwC47U.png?cs=15&rot=4

Akzeptiert Eingaben, bis sie auf 0x00 treffen. Beendet nicht, aber die Ausgabe ist korrekt.

captncraig
quelle
3
Symmetrisch: ja; palindromisch:?
Blau
@Blue Ich glaube nicht, dass es möglich ist, eine PNG-Bilddatei aufgrund der Kopf- und Fußzeile palindrom zu machen. Außerdem bedeutet PNG-Komprimierung, dass die Bytes im Bild mit ziemlicher Sicherheit nicht palindrom sind.
Esolanging Fruit
1
@EsolangingFruit Man könnte jedoch argumentieren, dass das Bildäquivalent eines Palindroms zentrosymmetrisch sein sollte.
Jonathan Frech
17

APL, 9

⍞←Z,⌽,Z←⍞

Erläuterung:

       Z←⍞  ⍝ read a line from the keyboard, and store it in Z
      ,     ⍝ flatten into one-dimensional array (this has no effect here)
     ⌽      ⍝ reverse
   Z,       ⍝ concatenate Z to its reverse
⍞←         ⍝ explicit output (not necessary, but it makes it a palindrome)
Marinus
quelle
13

CJam, 13 Bytes

qL;_-1%1-_;Lq

qL;                 "Read the input, Put an empty array on stack and pop that array";
   _-1%             "Now the string is on top, make a copy and reverse the copy";
       1-           "Remove occurrences of integer 1 from the reverse string. [no-op]";
         _;         "Copy the reversed string and pop it";
           Lq       "Put an empty array on stack and read the remaining input. Remaining";
                    "input will be empty as we already read whole of the input";

Probieren Sie es hier online aus


oder..

GolfScript, 9 Bytes

.-1%}%1-.

.                 "Input is already on stack. Make a copy";
 -1%              "Reverse the copy";
    }             "This marks the beginning of a super comment. Anything after this in the";
                  "code is a comment";
     %1-.         "no-op comment";

Probieren Sie es hier aus

Optimierer
quelle
Ich denke, Sie haben einen Fehler im GolfScript-Parser mit Ihrem "Superkommentar" gefunden. Wohlgemerkt, ein gewöhnlicher #Kommentar würde dort genauso gut funktionieren.
Ilmari Karonen
@IlmariKaronen Es ist nicht ich, }bekanntermaßen ein super Kommentar seit Ewigkeiten :)
Optimizer
8

C ++, 162 Bytes

#include<cstdio>//
main(){int c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c tni{)(niam
//>oidtsc<edulcni#

C 117 Bytes

main(c){c=getchar();if(c>0)putchar(c),main(),putchar(c);}//};)c(rahctup,)(niam,)c(rahctup)0>c(fi;)(rahcteg=c{)c(niam
tmp
quelle
1
Gott segne die zwei Schrägstriche lol
Abr001am
7

Haskell, 102 + 22 = 124 Bytes

a b fa=fa<|>b
fa=reverse>>=a
main=interact fa
niam=main
af tcaretni=niam
a=>>esrever=af
b>|<af=af b a

Dies muss mit dem Control.ApplicativeModul im Bereich ausgeführt werden, der über die ghci init-Datei eingestellt werden kann.ghci : :m Control.Applicative(-> +22 Bytes).

Kein Kommentar-Trick, nur 7 Funktionen, von denen 4 niemals aufgerufen werden.

Wenn Funktionen (anstelle von Programmen) erlaubt sind:

Haskell, 55 + 22 = 77 Bytes

a b fa=fa<|>b
f=reverse>>=a
a=>>esrever=f
b>|<af=af b a

Verwendung f "qwer"->"qwerrewq"

Bearbeiten: die vorherige Version war einfach falsch.

nimi
quelle
3

Pyth, 11 Bytes

+z_z " z_z+

In Pyth wird nichts gedruckt, was mit einem Leerzeichen vorausgeht. Also fügen wir einfach das Negativ der Zeichenkette zu sich selbst hinzu, setzen ein Leerzeichen, beginnen eine Zeichenkette und spiegeln die linke Seite des Zitats. "

Probieren Sie es hier online aus

Optimierer
quelle
3

Rubin, 44

s=gets p
s+=s.reverse||esrever.s=+s
p steg=s

Nimmt eine mehrzeilige Zeichenfolge als Eingabe von stdin und gibt eine Ruby-Darstellung dieser Zeichenfolge aus, die umgekehrt verkettet ist. Könnte ein Trim_Character durch Ersetzen ||mit #dem toten Code in der zweiten Zeile auszukommen.

Histokrat
quelle
s=gets p! =p steg=s
CalculatorFeline
... stimmt, ich habe keine Ahnung, was ich damit gemeint habe.
Histokrat
3

Jolf, 9 Bytes

Neuere Sprache, nicht konkurrierend

Versuch es hier

aη+i_i+ηa

Erklärung: Ich habe gerade erst mit Jolf angefangen und glaube nicht, dass ich das richtig erkläre.

aη         alert function, arity of the function can't be reduced by 1 so it stays at 1
  +i_i     concatenate the input with the reversed input
      +η   arity of the add reduced by 1, it just takes the following character (a)
        a  returns the input
schwillt an
quelle
1
Willkommen bei PPCG! Ich habe deine andere Antwort gesehen und ich schätze es sehr, dass du diese Sprache benutzt! Es sind meine eigenen Erfindungen, ich hoffe es gefällt euch :) Dies ist eine wirklich schöne Lösung, sehr gut gemacht! Ich mag die Art und Weise, wie Sie ηin der Lösung verwendet haben, sehr gut gemacht. Sie können zwei Bytes speichern , indem sie die mu eliminiert, wie: a+i_i+a. (Jolf hat auch implizite Eingaben, um den Rest der Argumente auszufüllen, aber dies ist kein Problem, da immer nur eine Eingabe auf einmal erfolgt.) Ich würde Ihre ursprüngliche Lösung trotzdem in der Antwort behalten.
Conor O'Brien
@ Cᴏɴᴏʀ O'Bʀɪᴇɴ Danke! Ich habe mich nur für eine Golfsprache entschieden, die mir nicht allzu unheimlich vorkam und bin sofort reingesprungen. Es hat mir Spaß gemacht, das herauszufinden. Ich habe versucht, herauszufinden, woher das η kommt, und habe festgestellt, dass es von dem Versuch herrührt, meinen Startpunkt von + i_i + zu bestimmen. Danke für die Information!
schwillt
3

PowerShell, 67

$args|%{$_+-join$_[$_.Length..0]}#}]0..htgneL._$[_$nioj-+_${%|sgra$

Probieren Sie es online aus

Wie von @mazzy vorgeschlagen, kann der Code bei Verwendung eines statischen Bereichs um 12 Byte verkürzt werden. Dies begrenzt jedoch die Eingabelänge auf 9 KByte. Theoretisch wären 9 MByte möglich, dies würde den Code jedoch erheblich verlangsamen.

$args|%{$_+-join$_[9kb..0]}#}]0..bk9[_$nioj-+_${%|sgra$
J. Bergmann
quelle
1
Alternative 67 Bytes:param($s)$s+-join$s[$s.Length..0]#]0..htgneL.s$[s$nioj-+s$)s$(marap
mazzy
Wenn die Länge der eingegebenen Zeichenfolge weniger als 9 KB beträgt, dann $args|%{$_+-join$_[9Kb..0]}#}]0..bK9[_$nioj-+_${%|sgra$(55 Byte)
mazzy
2

Fuzzy Octo Guacamole, 17 Bytes

FOG ist neuer als diese Herausforderung, daher ist dies nicht konkurrierend.

^dz''sjX@Xjs''zd^

Alternative Lösung in 19 Bytes:

^Czs''.jX@Xj.''szC^

Beide nehmen Eingaben entgegen, duplizieren und kehren sie um und verbinden den Stapel.

Erläuterung:

^dz''sj@js''zd^
^                # Get input
 d               # Duplicate ToS (input)
  z              # Reverse ToS
   ''            # Push empty string (for joining separator)
     s           # Move the empty string to the inactive stack
      j          # Join the active stack with the top of the inactive stack as the delimiter and push the result.
       X         # Print the ToS
        @        # End the program
        Xjs''zd^  # Backwards version of the beginning.
Rɪᴋᴇʀ
quelle
Auch nicht konkurrierend: P
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Ups. : P
Rɪᴋᴇʀ
1

tinyBF , 40

|=||==>|=|=|=+|=>==||==>=|+=|=|=|>==||=|

Mein erster Gedanke war Brainfuck, aber es ist unmöglich, die Zahnspangen zusammenzubringen ... Zum Glück hat tinyBF eine einfachere Flusskontrolle.

Keine Kommentare, es wird eine nullterminierte Zeichenfolge als Eingabe verwendet und das Ergebnis in einer nullterminierten Zeichenfolge zurückgegeben. Sie können es hier testen. Seien Sie jedoch gewarnt, dass es nicht anhält (obwohl Firefox zumindest dazu auffordert, das nicht reagierende Skript anzuhalten).

Kommentiert:

|=|                        Retrieve a byte of input.
|                          Positive (opening) bracket.
   ==                      Output the byte.
   >                       Move the pointer in positive direction.
   |=|                     Retrieve a byte of input.
   =                       Switch direction to negative.
|                          Negative (closing) bracket.
=                          Switch direction.
+                          Increment byte to execute return loop.
|                          Opening bracket.
   =>                      Move the pointer in negative direction.
   ==                      Output the byte.
|                          Closing bracket.
|=|                        Output the null terminator.
|==>|=|=|=+|=>==|          ...and keep null terminating it just to be sure.

Beachten Sie, dass bei der Codierung in 2-Bit-Anweisungen die Größe auf 10 Byte reduziert wird (dies wäre kein Palindrom).

Komintern
quelle
1

Python 3, 59 Bytes

a=input()#
print(a+a[::-1])#([1-::]a+a)tnirp
#()tupni=a

Ich habe mein Bestes versucht, um eine Lösung zu finden, die nur eine Zeile verwendet, aber ich hatte kein Glück.

Python 3, 79 Bytes

a=input()#()tupni=a#
print(a+a[::-1])#([1-::]a+a)tnirp
#a=input()#()tupni=a

Mein ursprünglicher Versuch, bei dem jede Zeile ein Palindrom ist. Ich denke nicht, dass es für diese Herausforderung notwendig ist, aber ich habe es für alle Fälle aufgenommen.

Noomann
quelle
1
Einzeilig, aber noch länger (73, da lambdaso lang):print((lambda a:a+a[::-1])(input()))#)))(tupni()]1-::[a+a:a adbmal((tnirp
no1xsyzy
Sehr schön. Lambdas sind mir weniger vertraut, aber ich gewöhne mich langsam an sie. Danke für das Teilen.
Noomann
1

Vitsy, 9 Bytes

z:Zr?rZ:z
z          Grab all string input from the command line arguments.
 :         Duplicate this stack.
  Z        Print all elements in this stack as a string.
   r       Reverse (reverses an empty stack).
    ?      Go right a stack.
     r     Reverse (reverses the input).
      Z    Print all elements in this stack as a string.
       :   Duplicate the stack (duplicates an empty stack).
        z  Grab all input from the command line (the command line arguments stack is already empty).

Probieren Sie es online!

Addison Crump
quelle
1

Befunge , 37 Bytes

~:0`!#v_:,
  >:#,_@_,#:>  
,:_v#!`0:~

Probieren Sie es online!

Die oberste Zeile drückt und druckt jedes Zeichen der Eingabe. Die zweite Zeile (vor der @) gibt den Stapel in umgekehrter Reihenfolge aus, aber wir geben die Bedingung ein _, um das -1 zu verbrauchen, das nach dem Lesen der Eingabe generiert wird. Die andere Hälfte des Codes (einschließlich dieser hässlichen, nachgestellten Zeilenumbrüche) macht die Quelle zu einem Palindrom, läuft aber trotzdem.

Linus
quelle
1

C # ( 33 32 + 1) * 2 = 68 66 Bytes

2 Bytes für die Verwendung von .Aggregate () gespart

s=>s+s.Aggregate("",(a,b)=>b+a);//;)a+b>=)b,a(,""(etagerggA.s+s>=s

Oh, der gute alte Lambda, mit dem du es fangen kannst

Func<string, string> f=<lambda here>

und dann mit anrufen

f("neverod")
hstde
quelle
1

Perl, 45 Bytes

;print$_=<>,~~reverse;m;esrever~~,><=_$tnirp;

Ziemlich einfach, prints die Eingabe ( $_=<>), gefolgt von der reversedavon. reversewird zurückgegeben, $_weil wir es im skalaren Kontext verwenden, indem wir ein Präfix mit eingeben ~~. Dann stimmen wir überein (m// mit; als Trennzeichen) im leeren Kontext mit der Umkehrung des Skripts .

Wenn wir garantieren können, müssen wir kein Palindrom erstellen. esrever,><=_$tnirpWir können den Code auf 43 Bytes verkürzen :

g.print$_=<>,reverse.m.esrever,><=_$tnirp.g

Verwendung

echo -n 'neverod' | perl -e 'g.print$_=<>,reverse.m.esrever,><=_$tnirp.g'
neveroddoreven

Perl, 26 Bytes

Beinhaltet 25 Byte Code + 1 für -p.

$_.=reverse;m;esrever=._$

Ich denke nicht, dass dies gültig ist, da es das -pFlag erfordert, von dem ich glaube, dass es nicht einfach mit dem Skriptinhalt kombiniert werden kann, um ein echtes Palindrom zu erzeugen. So ziemlich die gleichen Aufrufe wie oben, außer dass es sich um die Tatsache handelt, dass -pauch a hinzugefügt wird; hinter die Kulissen (auf neuere Perls ...) zum Schließen desm// .

Verwendung

echo -n 'neverod' | perl -pe ';$_.=reverse;m;esrever=._$;'
neveroddoreven
Dom Hastings
quelle
0

Pyth, 15

 k k+ z_z +k k 

Beachten Sie das Leerzeichen am Anfang und am Ende.

Ziemlich nervige Aufgabe in Pyth. z_zdruckt das gewünschte Palindrom, druckt aber z(die Eingabezeichenfolge) und _zdas Inverse in zwei verschiedenen Zeilen. +kombiniert die beiden Wörter, +erfordert aber am Ende zwei neue Aussagen am Ende (und am Anfang). Ich wähle kundk , das sind nur leere Zeichenfolgen. Dann viel weißer Raum, der das Drucken unterdrückt (und leere Räume, die natürlich Zeilenumbrüche erzeugen).

Da der Leerraum jede Ausgabe außer dem unterdrückt +z_z, können Sie das ks und das Literal durch arity 0 ersetzen . ZB 1 2+ z_z +2 1oderT Z+ z_z +Z T .

Probieren Sie es online aus .

Jakube
quelle
1
Ich habe eine 11 in Pyth, die ich noch nicht gepostet habe, weil ich dachte, Sie werden es sicherlich schlagen;)
Optimierer
0

Javascript, 137 Bytes

Ich verwende nicht den "Kommentar-Trick", aber ich verwende den "Escape-Anführungszeichen-Trick" lol.

"a\"};))''(nioj.)(esrever.)''(tilps.b(tacnoc.b nruter{)b(a noitcnuf";function a(b){return b.concat(b.split('').reverse().join(''));};"\a"
Steve
quelle
4
Ich denke nicht, dass das zählt; Die beiden zentralen Zeichen sind ";. Das Hinzufügen eines ;als letztes Zeichen in der Zeichenfolge sollte dies beheben.
ETHproductions
Gegenwärtig ist diese Antwort ungültig. Bitte entweder reparieren oder entfernen.
Jonathan Frech
0

JavaScript, 58 Byte

p=>p+[...p].reverse().join``//``nioj.)(esrever.]p...[+p>=p
ericw31415
quelle
0

PHP, 28 + 1 + 28 = 57 Bytes

<?=($x=$argv[1]).strrev($x);#;)x$(verrts.)]1[vgra$=x$(=?<

Nimmt Eingaben vom Kommandozeilenargument entgegen. Zitat für Multi-Word, Escape-Zeilen für Multi-Line.

Titus
quelle
0

Python 2, 51 Bytes

s=input();print s+s[::-1]#]1-::[s+s tnirp;)(tupni=s

Ich bin überrascht, dass niemand daran gedacht hat! Benötigt eine Eingabe in Anführungszeichen ( 'oder "). Wenn Funktionen erlaubt wären, hätte ich dies stattdessen für 37 Bytes tun können:

lambda x:x+x[::-1]#]1-::[x+x:x adbmal
Erik der Outgolfer
quelle
0

C ++ 14, 152 116 Bytes

Wie unbenannte Lambda nimmt szustring

[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;}//};r+s nruter};r+c=r{)s:c otua(rof;r)s(epytlced{)s otua(][

Alte Lösung:

[](auto s){auto r=s;for(auto p=s.rbegin()-1;++p!=s.rend();r+=*p);return r;}//};r nruter;)p*=+r;)(dner.s=!p++;1-)(nigebr.s=p otua(rof;s=r otua{)s otua(][

Verwendung:

auto f=[](auto s){decltype(s)r;for(auto c:s){r=c+r;}return s+r;};

main(){
 string a="123456789";
 cout << f(a) << endl;
}
Karl Napf
quelle
0

05AB1E , 5 Bytes

«q«Â

Probieren Sie es online aus.

Erläuterung:

        # Bifurcate (short for Duplicate & Reverse) the (implicit) input
         #  i.e. "neverod" → "neverod" and "doreven"
 «       # Concat both together
         #  i.e. "neverod" and "doreven" → "neveroddoreven"
  q      # Exit the program (and implicitly output the concatted result)
   «Â    # No-ops

Oder alternativ:

R«q«R

Probieren Sie es online aus.

Wo Rist umgekehrt, und das «nimmt die Eingabe implizit wieder auf, um mit zu konkatieren.


HINWEIS: Wenn wir neverodorevenfür die Eingabe neverod, die immer noch ein Palindrom ist, eine Ausgabe durchführen dürfen , kann dies stattdessen in 1 Byte mit der integrierten Funktion palindromize erfolgen:

û

Probieren Sie es online aus.

Kevin Cruijssen
quelle
0

x86-64-Assembly (Microsoft x64-Aufrufkonvention), 89 Byte:

80 39 00 48 8B D1 4C 8B C1 74 0B 48 FF C2 49 FF C0 80 3A 00 75 F5 48 FF CA 8A 02 41 88 00 48 8B C2 48 FF CA 49 FF C0 48 3B C1 77 ED C3 ED 77 C1 3B 48 C0 FF 49 CA FF 48 C2 8B 48 00 88 41 02 8A CA FF 48 F5 75 00 3A 80 C0 FF 49 C2 FF 48 0B 74 C1 8B 4C D1 8B 48 00 39 80

Zerlegt:

 0000000000000000: 80 39 00           cmp         byte ptr [rcx],0
 0000000000000003: 48 8B D1           mov         rdx,rcx
 0000000000000006: 4C 8B C1           mov         r8,rcx
 0000000000000009: 74 0B              je          0000000000000016
 000000000000000B: 48 FF C2           inc         rdx
 000000000000000E: 49 FF C0           inc         r8
 0000000000000011: 80 3A 00           cmp         byte ptr [rdx],0
 0000000000000014: 75 F5              jne         000000000000000B
 0000000000000016: 48 FF CA           dec         rdx
 0000000000000019: 8A 02              mov         al,byte ptr [rdx]
 000000000000001B: 41 88 00           mov         byte ptr [r8],al
 000000000000001E: 48 8B C2           mov         rax,rdx
 0000000000000021: 48 FF CA           dec         rdx
 0000000000000024: 49 FF C0           inc         r8
 0000000000000027: 48 3B C1           cmp         rax,rcx
 000000000000002A: 77 ED              ja          0000000000000019
 000000000000002C: C3                 ret
 000000000000002D: ED                 in          eax,dx
 000000000000002E: 77 C1              ja          FFFFFFFFFFFFFFF1
 0000000000000030: 3B 48 C0           cmp         ecx,dword ptr [rax-40h]
 0000000000000033: FF 49 CA           dec         dword ptr [rcx-36h]
 0000000000000036: FF 48 C2           dec         dword ptr [rax-3Eh]
 0000000000000039: 8B 48 00           mov         ecx,dword ptr [rax]
 000000000000003C: 88 41 02           mov         byte ptr [rcx+2],al
 000000000000003F: 8A CA              mov         cl,dl
 0000000000000041: FF 48 F5           dec         dword ptr [rax-0Bh]
 0000000000000044: 75 00              jne         0000000000000046
 0000000000000046: 3A 80 C0 FF 49 C2  cmp         al,byte ptr [rax+FFFFFFFFC249FFC0h]
 000000000000004C: FF 48 0B           dec         dword ptr [rax+0Bh]
 000000000000004F: 74 C1              je          0000000000000012
 0000000000000051: 8B 4C D1 8B        mov         ecx,dword ptr [rcx+rdx*8-75h]
 0000000000000055: 48 00 39           add         byte ptr [rcx],dil
 0000000000000058: 80

Beachten Sie, dass der Code nach der retAnweisung unter 2Cnicht erreichbar ist, sodass es keine Rolle spielt, dass es sich um Unsinn handelt

Govind Parmar
quelle
0

Japt , 4 Bytes

êêêê

Probieren Sie es online!

Wie es funktioniert

U.ê("ê".ê("ê"))  Transpiled to JS

       .ê("ê")   String.ê(string): true if `this` is palindrome
    "ê".ê("ê")   true (treated same as 1)
U.ê(          )  String.ê(number): palindromify
                   "abc"->"abccba" if `number` is odd, "abcba" otherwise
                 `true` is odd number, so we achieve the desired function

Alternative 4 Bytes

pwwp

Probieren Sie es online!

Wie es funktioniert

U.p("w".w("p"))  Transpiled to JS
    "w".w(   )   Reverse of "w" ("p" is ignored)
U.p("w")         Append U.w(), which is reverse of U, to the right of U
Bubbler
quelle
0

Rückhand , 33 27 Bytes

iH~0}|{<:: oi]io ::<{|}0~Hi

Probieren Sie es online!

Im Gegensatz zu vielen anderen Lösungen hier ist dies tatsächlich eine Fall den palindromisierte Code verwenden!

Erläuterung:

i  0 |{      Get the first character and enter the loop
        :  o    Output the character while preserving it
              i  :     Get input and duplicate it
                   <{  Turn around
             ]         Increment the copy to check if EOF   
    }| <    Loop again if not EOF
  ~   If EOF, pop the extra copy of EOF
 H    Terminate, printing the contents of the stack.

Insgesamt sind die nicht ausgeführten Anweisungen:

       :   i  o :   |}0~Hi
Scherzen
quelle