Giriş dizesini, giriş dizesinden başlayarak bir palindrom'a dönüştüren bir program oluşturun. Programın kendisi bir palindrom olmalıdır.

Örneğin giriş:, neverodyazdırın neveroddoreven. Çok kelimeli, çok hatlı girişleri de kullanmalısınız.

Dyalog APL, 6 4

⌽,,⌽

Burada dene.

Diğer çözümler:

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

açıklama

Onlar sadece:

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

Monadic ,ve ⊢dizelerde hiçbir şey yapmıyor. Dyadic ,birleştirmedir. Dyadiç ⊢sağ operasını geri veriyor. Ve ⌽tabii ki tersine çevriliyor.

piet 19x2 = 38

0x00 ile karşılaşana kadar girişi kabul eder. Sonlandırılmaz, ancak çıktı doğru olacaktır.

APL, 9

⍞←Z,⌽,Z←⍞

Açıklama:

       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 bayt

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

Burada çevrimiçi deneyin

veya..

GolfScript, 9 bayt

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

Burada dene

C ++, 162 bayt

#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 bayt

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 bayt

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

Bu Control.Applicative, ghci init dosyası aracılığıyla ayarlanabilen, kapsamda olan modül ile çalıştırılmalıdır .ghci: :m Control.Applicative(-> +22 bytes).

Yorum yapma hilesi, 4 tanesinin asla çağrılmadığı 7 işlev.

İşlevlere (programlar yerine) izin verilirse:

Haskell, 55 + 22 = 77 bayt

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

Kullanım f "qwer"->"qwerrewq"

Düzenleme: önceki sürüm sadece yanlıştı.

Pyth, 11 bayt

+z_z " z_z+

Pyth'te boşluktan önceki hiçbir şey yazdırılmıyor. Bu yüzden sadece dizginin negatifini kendisine ekler, bir boşluk koyarız, bir dizgeyi başlatır ve teklifin sol tarafını yansıtırız "

Burada çevrimiçi deneyin

Ruby, 44

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

Stdin'den girdi olarak çok satırlı bir dizge alır, tersine birleştirilmiş dizenin Ruby gösterimini verir. İkinci satırdaki ölü kodu yorumlamak için ||ile değiştirerek bir karakter kırpılabilir #.

Jolf, 9 bayt

Rekabet etmeyen yeni dil

Burada dene

aη+i_i+ηa

Açıklama: Jolf'a daha yeni başladım ve bunu doğru şekilde açıklayacağımı sanmıyorum.

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$

Çevrimiçi deneyin

@Mazzy tarafından önerildiği gibi, statik bir aralık kullanılırken kod 12 bayt kısaltılabilir. Ancak bu, giriş uzunluğunu 9 KB ile sınırlandırır. Teorik olarak 9 MBayt mümkün olacaktı ancak kodu önemli ölçüde yavaşlatacaktı.

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

Bulanık Octo Guacamole, 17 bayt

_{FOG bu mücadeleden daha yeni, bu yüzden rekabet dışı.}

^dz''sjX@Xjs''zd^

19 baytta Alt çözüm:

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

Her ikisi de girdi alır, kopyalar ve geri alır ve yığına katılır.

Açıklama:

^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

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

İlk düşüncem Brainfuck'tı, ama diş tellerini eşleştirmek imkansız ... neyse ki tinyBF daha kolay akış kontrolüne sahip.

Yorum yok, giriş olarak boş sonlandırılmış bir dizge alır ve sonucu boş sonlandırılmış bir dizeyle döndürür. Burada test edebilirsiniz , durdurulmaması için uyarılmalıdır (Firefox en azından yanıt vermeyen senaryoyu durdurmayı istemesine rağmen).

Yorumlananlar:

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

2 bit komutuna kodlarsanız, boyutu 10 bayta keser (bir palindrome olmaz).

Python 3, 59 bayt

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

Sadece bir satır kullanan bir çözüm bulmak için elimden geleni yaptım ama şansım olmadı.

Python 3, 79 bayt

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

Her çizginin bir palindrom olduğu orijinal girişim. Bu zorluk için gerekli olduğunu sanmıyorum, ancak tam da dahil ettim.

Vitsy, 9 bayt

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

Çevrimiçi deneyin!

Befunge , 37 bayt

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

Çevrimiçi deneyin!

Üst satır, girişin her karakterini iter ve yazdırır. İkinci satır (önce @) yığını ters olarak yazdırır, ancak _okuma girişi bittiğinde üretilen -1 değerini tüketmek için contional'a gireriz . Kodun diğer yarısı (çirkin takip eden yeni satırlar dahil) kaynağı bir palindrom yapar, ancak sinirler çalışır.

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

.Aggregate () kullanımına 2 bayt kaydedildi

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

Ah eski güzel lambda, onu yakalayabilirsin.

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

ve sonra ara

f("neverod")

Perl, 45 bayt

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

Oldukça basit, printbunun arkasındaki girdi ( $_=<>) reverse. reverseDöndürür $_çünkü skaler bağlamda önek ile kullanıyoruz ~~. Sonra ( bağlamlayıcı olarak m//kullanarak ;) geçersiz bağlamda komut dosyasının tersiyle eşleşiriz.

Eğer bir garanti verebilirsek, bir palindrom oluşturmak zorunda kalmayacağız esrever,><=_$tnirp, kodu 43 byte kısaltabiliriz :

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

kullanım

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

Perl, 26 bayt

İçin 25 bayt kodu + 1 içerir -p.

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

Bunun geçerli olduğunu sanmıyorum çünkü -pgerçek bir palindrom oluşturmak için sanırım betiğin içeriğiyle kolayca birleştirilebileceğini sanmıyorum. Hemen hemen aynı çağrıları, dışında kapatmak için sahne arkasına (yeni Perls ...) -pde ekleyen gerçeğine dayanması dışında .;m//

kullanım

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

Pyth, 15

 k k+ z_z +k k 

Başlangıçtaki ve sonundaki boşluğa dikkat edin.

Pyth'ta oldukça sinir bozucu bir görev. z_zistenen palindromu yazdırır, ancak iki farklı satırda z(giriş dizesi) ve _ztersini yazdırır . +iki kelimeyi birleştirir, fakat +sonunda iki başında yeni ifadeler gerektirir (ve başında). Seçtiğim kvek sadece boş dizeler olan . Ardından, yazdırmayı (ve tabii ki satır sonları oluşturan boş alanları yazdırmayı) önleyen çok fazla beyaz alan.

Beyaz boşluk hariç her çıktısını almaz yana +z_z, sen yerini alabilecek kArity 0. Eg ile s ve edebi 1 2+ z_z +2 1ya T Z+ z_z +Z T.

Çevrimiçi deneyin .

Javascript, 137 bayt

"Yorum hilesi" kullanmıyorum ama kaçan tırnak işareti hilesi lol kullanıyorum.

"a\"};))''(nioj.)(esrever.)''(tilps.b(tacnoc.b nruter{)b(a noitcnuf";function a(b){return b.concat(b.split('').reverse().join(''));};"\a"

JavaScript, 58 bayt

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

PHP, 28 + 1 + 28 = 57 bayt

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

komut satırı argümanından girdi alır. çoklu kelime için alıntı, çoklu hat için yeni hatlardan kaçış.

Python 2, 51 bayt

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

Bunu kimsenin düşünmemesine şaşırdım! Alıntılanan giriş ( 'veya ") gerekir. Eğer fonksiyonlara izin verilseydi, bunun yerine 37 byte yapabilirdim:

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

C ++ 14, 152 116 bayt

Adsız lamda solduğu gibistring

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

Eski çözüm:

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

Kullanımı:

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 bayt

«q«Â

Çevrimiçi deneyin.

Açıklama:

        # 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

Veya alternatif olarak:

R«q«R

Çevrimiçi deneyin.

Nerede Rters olduğunu ve «birlikte concat için örtülü tekrar girdi alır.

NOT: Hala bir palindrom olan neverodorevengiriş için çıkış yapmamıza izin neverodverilirse, palindromize builtin yerine 1 byte olarak yapılabilir :

û

Çevrimiçi deneyin.

x86-64 Derleme (Microsoft x64 çağrı kuralı), 89 bayt:

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

Demonte:

 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

Not sonra kod o retöğretim 2Co 's saçma olduğunu önemli değil bu yüzden erişilemiyor

Japt , 4 bayt

êêêê

Çevrimiçi deneyin!

Nasıl çalışır

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

Alternatif 4 bayt

pwwp

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Burada çözümleri bir çok farklı olarak, bu aslında yapar palindromised kodu kullanabilirsiniz!

Açıklama:

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.

Toplamda, beklenmeyen talimatlar:

       :   i  o :   |}0~Hi