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

Например, введите:, neverodраспечатать neveroddoreven. Вы должны также обрабатывать многословные, многострочные вводы.

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

⌽,,⌽

Попробуй это здесь.

Другие решения:

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

объяснение

Они просто:

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

Monadic ,и ⊢ничего не делает на струнах. Дядький ,это конкатенация. Дядич ⊢возвращает свой правый операнд. И ⌽, очевидно, реверсия.

Пит 19х2 = 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 .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 Кбайт. Теоретически 9 МБ было бы возможно, но это значительно замедлило бы код.

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

tinyBF , 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 input ( $_=<>), а затем 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 байт

Я не использую «трюк с комментариями», но я использую трюк с кавычками, к сожалению.

"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 байте вместо этого с помощью встроенной функции palindromize:

û

Попробуйте онлайн.

Сборка x86-64 (соглашение о вызовах Microsoft x64), 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инструкции 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

Backhand , 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