Створіть програму, яка перетворює вхідний рядок у паліндром, починаючи з рядка введення. Сама програма повинна бути паліндром.

Наприклад введення:, neverodдрук neveroddoreven. Ви також повинні обробляти багатослівні та багаторядкові введення.

Діялог АПЛ, 6 4

⌽,,⌽

Спробуйте тут.

Інші рішення:

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

Пояснення

Вони просто:

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

Монадік ,і ⊢нічого не робить на струнах. Діадик ,- це конкатенація. Діадик ⊢повертає свій правильний операнд. І ⌽це очевидно реверсія.

піт 19x2 = 38

Приймає вхід, поки не зустріне 0x00. Не закінчується, але вихід буде правильним.

APL, 9

⍞←Z,⌽,Z←⍞

Пояснення:

       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 байт

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

Спробуйте його онлайн тут

або ..

GolfScript, 9 байт

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

Спробуйте тут

C ++, 162 байти

#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 байт

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 байти

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

Це потрібно запустити з Control.Applicativeмодулем в області застосування, який можна встановити через файл ghci init .ghci: :m Control.Applicative(-> +22 байт).

Без фокусу без коментарів, лише 7 функцій, де 4 з них ніколи не викликаються.

Якщо дозволено функції (замість програм):

Haskell, 55 + 22 = 77 байт

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

Використання f "qwer"->"qwerrewq"

Редагувати: попередня версія була просто неправильною.

Pyth, 11 байт

+z_z " z_z+

У Pyth нічого, що передує пробілу, не друкується. Таким чином, ми просто додаємо мінус рядка до себе, ставимо пробіл, починаємо рядок і дзеркально відбиваємо ліву частину цитати "

Спробуйте його онлайн тут

Рубі, 44

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

Бере багаторядковий рядок як вхід з stdin, виводить представлення Ruby цієї рядка, з'єднаної в його зворотній бік. Може обрізати характер, замінивши ||з #закомментировать мертвий код на другу лінії.

Джольф, 9 байт

Більш нова мова, неконкурентна

Спробуйте тут

aη+i_i+ηa

Пояснення: Я тільки що почав Джольфа і не думаю, що я пояснюю це належним чином.

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$

Спробуйте в Інтернеті

Як пропонує @mazzy, код може бути скорочений на 12 байт при використанні статичного діапазону. Однак це обмежує вхідну довжину до 9 КБ. Теоретично 9MBytes було б можливим, але це значно уповільнило б код.

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

Нечітка Окто Гуакамоле, 17 байт

_{FOG новіший, ніж цей виклик, тому це неконкурентоспроможний.}

^dz''sjX@Xjs''zd^

Альт-рішення в 19 байтах:

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

Вони обидва беруть введення, дублюють і зворотно і приєднуються до стеку.

Пояснення:

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

крихітнийBF , 40

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

Моя перша думка була Brainfuck, але дужки неможливо зіставити ... на щастя, tinyBF має простіший контроль потоку.

Немає коментарів, вона бере нульовий завершений рядок як вхідний і повертає результат у нульовий завершений рядок. Ви можете протестувати його тут , просто попередивши, що він не зупиняється (хоча Firefox принаймні вимагає припинити невідповідний сценарій).

Прокоментував:

|=|                        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-бітні інструкції, він скоротить розмір до 10 байт (це не буде паліндром).

Python 3, 59 байт

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

Я намагався зробити все можливе, щоб знайти рішення, яке використовувало лише одну лінію, але мені не пощастило.

Python 3, 79 байт

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

Моя оригінальна спроба, в якій кожен рядок - паліндром. Я не думаю, що це потрібно для цього виклику, але я включив його на всякий випадок.

Віци, 9 байт

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

Спробуйте в Інтернеті!

Befunge , 37 байт

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

Спробуйте в Інтернеті!

Верхня лінія натискає та друкує кожен символ введення. Другий рядок (перед @) друкує стек у зворотному порядку, але ми вводимо умовно, _щоб споживати -1, що генерується при закінченні введення читання. Інша половина коду (включаючи некрасиві промальовані нові рядки) робить джерело паліндром, але неверно працює.

C # ( 33 32 + 1) * 2 = 68 66 байт

збережено 2 байти до використання .Aggregate ()

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

О, стара добра лямбда, ви можете її спіймати

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

а потім зателефонуйте за допомогою

f("neverod")

Perl, 45 байт

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

Досить простий, prints введення ( $_=<>), а за ним reverseйого вхід . reverseповертається, $_тому що ми використовуємо його у скалярному контексті шляхом префіксації до ~~. Тоді ми співставляємо ( m//використовуючи ;як роздільник), у недійсному контексті, проти зворотного сценарію.

Якщо ми можемо гарантувати, нам не доведеться створювати паліндром, esrever,><=_$tnirpми можемо скоротити код до 43 байт :

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

Використання

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

Perl, 26 байт

Включає 25 байт код + 1 для -p.

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

Я не думаю, що це дійсно, оскільки для цього потрібен -pпрапор, який, на мою думку, не може бути легко поєднаний у вміст сценарію, щоб створити справжній паліндром. В основному ті ж дзвінки, що й вище, за винятком того, що він також покладається на те, що -pтакож додає ;за кадром (на нових Perls ...), щоб закрити m//.

Використання

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

Піт, 15

 k k+ z_z +k k 

Помітьте пробіл на початку та в кінці.

Досить дратівливе завдання в Pyth. z_zдрукує потрібний паліндром, але він друкує z(вхідний рядок) та _zобернену на двох різних лініях. +поєднує два слова, але +в кінці потрібні два нові висловлювання в кінці (і на початку). Я вибираю kі k, які є просто порожніми рядками. Потім багато білого простору, який пригнічує друк (і друк порожніх пробілів, які генерують перерви в рядку курсу).

Оскільки пробіл придушує кожен вихід, окрім +z_z, ви можете замінити ks та літерал на атрибут 0. Наприклад, 1 2+ z_z +2 1або T Z+ z_z +Z T.

Спробуйте в Інтернеті .

Javascript, 137 байт

Я не використовую "трюк з коментарями", але я використовую хитрість лапки, що виходить, 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 байт

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

PHP, 28 + 1 + 28 = 57 байт

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

приймає дані з аргументу командного рядка. цитата для багатослівного слова, уникнути нових рядків для багаторядкових.

Python 2, 51 байт

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

Я здивований, що ніхто про це не думав! Потреби вводяться ( 'або "). Якби функції були дозволені, я міг би це зробити за 37 байт:

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

C ++ 14, 152 116 байт

Як безіменного лямбда, передбачає s, що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(][

Старе рішення:

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

Використання:

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 байт

«q«Â

Спробуйте в Інтернеті.

Пояснення:

        # 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

Або в якості альтернативи:

R«q«R

Спробуйте в Інтернеті.

Де Rреверс, і то« береться неявно знову, щоб визначити.

ПРИМІТКА. Якщо нам дозволено виводити neverodorevenна вхід neverod, який все ще є паліндром, це можна зробити в 1 байт замість вбудованого паліндромізу:

û

Спробуйте в Інтернеті.

x86-64 Асамблея (Microsoft x64 call Convention), 89 байт:

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

Розібрано:

 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

Зауважте, що код після retінструкції at 2Cнедоступний, тому не має значення, що це дурниці

Japt , 4 байти

êêêê

Спробуйте в Інтернеті!

Як це працює

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

Альтернативно 4 байти

pwwp

Спробуйте в Інтернеті!

Як це працює

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

Бекхенд , 33 27 байт

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

Спробуйте в Інтернеті!

В відміну від багатьох рішень тут, це один фактично робить використовувати palindromised код!

Пояснення:

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.

Загалом невиконані інструкції:

       :   i  o :   |}0~Hi