Utwórz program, który konwertuje ciąg wejściowy na palindrom, zaczynając od ciągu wejściowego. Sam program musi być palindromem.

Na przykład wpisz neverod:, wydrukuj neveroddoreven. Powinieneś także obsługiwać dane wejściowe zawierające wiele słów i wiele wierszy.

Dyalog APL, 6 4

⌽,,⌽

Wypróbuj tutaj.

Inne rozwiązania:

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

Wyjaśnienie

Są po prostu:

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

Monadyczny ,i ⊢nic nie robi na łańcuchach. Dyadic ,to konkatenacja. Dyadic ⊢zwraca właściwy operand. I ⌽oczywiście jest to odwrócenie.

piet 19x2 = 38

Akceptuje dane wejściowe, dopóki nie napotka 0x00. Nie kończy się, ale dane wyjściowe będą poprawne.

APL, 9

⍞←Z,⌽,Z←⍞

Wyjaśnienie:

       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 bajtów

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

Wypróbuj online tutaj

lub..

GolfScript, 9 bajtów

.-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";

Wypróbuj tutaj

C ++, 162 bajty

#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 bajtów

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 bajty

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

Musi to zostać uruchomione z Control.Applicativemodułem w zakresie, który można ustawić za pomocą pliku inicjującego ghci .ghci: :m Control.Applicative(-> +22 bajtów).

Bez sztuczki komentowania, tylko 7 funkcji, z których 4 nigdy nie są wywoływane.

Jeśli funkcje (zamiast programów) są dozwolone:

Haskell, 55 + 22 = 77 bajtów

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

Zastosowanie f "qwer"->"qwerrewq"

Edycja: poprzednia wersja była po prostu zła.

Pyth, 11 bajtów

+z_z " z_z+

W Pyth wszystko poprzedzone spacją nie jest drukowane. Więc po prostu dodajemy do siebie znak negatywny ciągu, wstawiamy spację, rozpoczynamy ciąg znaków i odbijamy lewą stronę cytatu „

Wypróbuj online tutaj

Ruby, 44

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

Pobiera ciąg multilinii jako dane wejściowe ze standardowego wejścia, wyświetla Rubinową reprezentację tego łańcucha połączoną z jego odwrotnością. Można przyciąć znak, zastępując ||go, #aby skomentować martwy kod w drugim wierszu.

Jolf, 9 bajtów

Nowszy język, niekonkurujący

Spróbuj tutaj

aη+i_i+ηa

Objaśnienie: Właśnie zacząłem Jolfa i nie sądzę, że wyjaśniam to poprawnie.

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$

Wypróbuj online

Jak sugeruje @mazzy, kod można skrócić o 12 bajtów, gdy używany jest zakres statyczny. Ogranicza to jednak długość wejściową do 9 KB. Teoretycznie możliwe byłoby 9 MB, ale znacznie spowolniłoby to kod.

$args|%{$_+-join$_[9kb..0]}#}]0..bk9[_$nioj-+_${%|sgra$

Fuzzy Octo Guacamole, 17 bajtów

_{FOG jest nowszy niż to wyzwanie, więc nie jest konkurencyjny.}

^dz''sjX@Xjs''zd^

Alt rozwiązanie w 19 bajtach:

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

Obie pobierają dane wejściowe, duplikują i odwracają oraz dołączają do stosu.

Wyjaśnienie:

^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

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

Moją pierwszą myślą było Brainfuck, ale nie można dopasować aparatów ortodontycznych ... na szczęście tinyBF ma prostszą kontrolę przepływu.

Bez komentarzy, pobiera ciąg zakończony znakiem zerowym jako dane wejściowe i zwraca wynik w ciągu zakończonym znakiem zerowym. Możesz to przetestować tutaj , ale ostrzegaj, że się nie zatrzymuje (chociaż Firefox przynajmniej monituje o zatrzymanie niereagującego skryptu).

Skomentowano:

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

Zauważ, że jeśli zakodujesz go w instrukcjach 2-bitowych, zmniejszy on rozmiar do 10 bajtów (nie byłby to palindrom).

Python 3, 59 bajtów

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

Starałem się jak najlepiej znaleźć rozwiązanie wykorzystujące tylko jedną linię, ale nie miałem szczęścia.

Python 3, 79 bajtów

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

Moja oryginalna próba, w której każda linia jest palindromem. Nie sądzę, aby było to konieczne, ale na wszelki wypadek je uwzględniłem.

Vitsy, 9 bajtów

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

Wypróbuj online!

Befunge , 37 bajtów

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

Wypróbuj online!

Górna linia popycha i drukuje każdy znak danych wejściowych. Druga linia (przed @) wypisuje stos w odwrotnej kolejności, ale wchodzimy po stronie kierunkowej, _aby zużyć -1 wygenerowane po zakończeniu odczytu danych wejściowych. Druga połowa kodu (w tym te brzydkie końcowe znaki nowej linii) sprawia, że ​​źródło jest palindromem, ale nigdy nie działa.

C # ( 33 32 + 1) * 2 = 68 66 bajtów

zapisano 2 bajty na użycie .Aggregate ()

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

Och, stara dobra lambda, możesz ją złapać

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

a następnie zadzwoń za pomocą

f("neverod")

Perl, 45 bajtów

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

Całkiem proste, prints input ( $_=<>), po którym następuje reverse. reversezwraca, $_ponieważ używamy go w kontekście skalarnym przez prefiks z ~~. Następnie dopasowujemy ( m//używając ;jako separatora), w pustym kontekście, do rewersu skryptu.

Jeśli możemy zagwarantować, nie będziemy musieli tworzyć palindromu esrever,><=_$tnirp, możemy skrócić kod do 43 bajtów :

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

Stosowanie

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

Perl, 26 bajtów

Zawiera 25 bajtów kodu + 1 dla -p.

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

Nie sądzę, że jest to poprawne, ponieważ wymaga -pflagi, której nie sądzę można łatwo połączyć z treścią skryptu, aby stworzyć prawdziwy palindrom. Prawie takie same wywołania jak powyżej, ale opiera się na tym, że -pdodaje także ;zakulisowe (w nowszych Perlach ...), aby zamknąć m//.

Stosowanie

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

Pyth, 15 lat

 k k+ z_z +k k 

Zwróć uwagę na miejsce na początku i na końcu.

Dość irytujące zadanie w Pyth. z_zwypisuje żądany palindrom, ale wypisuje z(ciąg wejściowy) i _zodwrotny na dwóch różnych liniach. +łączy dwa słowa, ale +na końcu wymaga dwóch nowych instrukcji na końcu (i na początku). Wybieram ki k, które są tylko pustymi ciągami. Następnie dużo białych znaków, które hamują drukowanie (i drukowanie pustych miejsc, które generują oczywiście przerwy linii).

Ponieważ białe znaki pomijają każde wyjście oprócz +z_z, możesz zastąpić kliterał si literą arity 0. Np . 1 2+ z_z +2 1Lub T Z+ z_z +Z T.

Wypróbuj online .

Javascript, 137 bytes

I'm not using the "comment trick" but I am using the escaped quotation mark 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 bytes

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$(=?<

takes input from command line argument. quote for multi-word, escape newlines for multi-line.

Python 2, 51 bytes

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

I'm surprised no-one thought of this! Needs quoted input (' or "). If functions were allowed, I could have done this for 37 bytes instead:

lambda x:x+x[::-1]#]1-::[x+x:x adbmal

C++14, 152 116 bytes

As unnamed lambda, assumes s to be string

[](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(][

Old solution:

[](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(][

Usage:

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«Â

Try it online.

Explanation:

        # 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

Or alternatively:

R«q«R

Try it online.

Where R is reverse, and the « takes the input implicitly again to concat with.

NOTE: If we are allowed to output neverodoreven for the input neverod, which is still a palindrome, it can be done in 1 byte instead with the palindromize builtin:

û

Try it online.

x86-64 Assembly (Microsoft x64 calling convention), 89 bytes:

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

Disassembled:

 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

Note that the code after the ret instruction at 2C is unreachable so it doesn't matter that it's nonsense

Japt, 4 bytes

êêêê

Try it online!

How it works

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

Try it online!

How it works

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

Backhand, 33 27 bytes

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

Try it online!

Unlike a lot of the solutions here, this one actually does use the palindromised code!

Explanation:

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.

Altogether, the unexecuted instructions are:

       :   i  o :   |}0~Hi