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.

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.

Piet 19x2 = 38

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

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)

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

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

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.

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

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.

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

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$

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.

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).

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.

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!

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.

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")

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

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 .

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"

JavaScript, 58 Byte

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

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.

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

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;
}

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.

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

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

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