입력 문자열을 입력 문자열로 시작하는 회문으로 변환하는 프로그램을 작성하십시오. 프로그램 자체는 회문이어야합니다.

예를 들어 input : neverod, print neveroddoreven입니다. 여러 단어로 된 여러 줄 입력도 처리해야합니다.

Dyalog APL, 6 4

⌽,,⌽

여기에서 시도하십시오.

다른 솔루션 :

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

설명

그들은 단지 :

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

모나 딕 ,하고 ⊢문자열에 아무것도하지 않습니다. Dyadic ,는 연결입니다. Dyadic ⊢는 오른쪽 피연산자를 반환합니다. 그리고 ⌽분명히 회귀입니다.

피에트 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

하스켈, 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.Applicativeghci 초기화 파일을 통해 설정할 수있는 범위 내에서 모듈 .ghci: :m Control.Applicative(-> 22 바이트).

코멘트 트릭이 없으며, 그중 4가 호출되지 않은 7 개의 함수 만 있습니다.

프로그램 대신 기능이 허용되는 경우 :

하스켈, 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

설명 : 방금 Jolf 만 시작했으며이 점을 올바르게 설명하고 있다고 생각하지 않습니다.

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 바이트 단축 할 수 있습니다. 그러나 이것은 입력 길이를 9KBytes로 제한합니다. 이론적으로 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.

tinyBF , 40

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

내 첫 번째 생각은 Brainfuck이지만 괄호와 일치하는 것은 불가능합니다 ... 다행히도 작은 BF는 흐름 제어가 더 간단합니다.

주석이 없으면 널 종료 문자열을 입력으로 사용하고 결과를 널 종료 문자열로 리턴합니다. 여기 에서 테스트 할 수 있습니다. Firefox는 중지되지 않습니다 (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 바이트로 줄어 듭니다 (palindrome이 아님).

파이썬 3, 59 바이트

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

나는 한 줄만 사용하는 솔루션을 찾기 위해 최선을 다했지만 운이 없었습니다.

파이썬 3, 79 바이트

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

모든 라인이 회 문인 나의 원래 시도. 나는이 도전에 필요하다고 생각하지 않지만 만일의 경우를 위해 그것을 포함시켰다.

Vitsy, 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 바이트

.Aggregate () 사용으로 2 바이트를 절약했습니다.

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

오 좋은 람다, 당신은 그것을 잡을 수 있습니다

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

그리고 그것을 호출

f("neverod")

펄, 45 바이트

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

매우 간단 print합니다. 입력 ( $_=<>) 다음에 입력 reverse합니다. 우리가 접두사로 스칼라 컨텍스트에서 사용하고 있기 때문에를 reverse반환합니다 . 그런 다음 void 컨텍스트에서 스크립트의 역순으로 (구분 기호로 사용) 를 일치 시킵니다.$_~~m//;

보증을 할 수 있다면 회문을 만들 필요가 없습니다 esrever,><=_$tnirp. 코드를 43 바이트로 줄일 수 있습니다 .

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

용법

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

펄, 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반대의 두 줄에 인쇄합니다. +두 단어를 결합하지만 +끝에 (그리고 시작 부분에) 두 개의 새로운 문장이 필요합니다. 나는 빈 문자열 인 kand를 선택합니다 k. 그런 다음 많은 공백이있어 인쇄를 억제합니다 (빈 공간을 인쇄하면 물론 줄 바꿈이 발생 함).

공백은을 제외한 모든 출력을 억제 +z_z하므로 ks 및 리터럴을 arity 0으로 대체 할 수 있습니다 . 예 : 1 2+ z_z +2 1또는 T Z+ z_z +Z T.

온라인으로 사용해보십시오 .

자바 스크립트, 137 바이트

"댓글 트릭"을 사용하고 있지 않지만 이스케이프 된 따옴표 트릭 LOL을 사용하고 있습니다.

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

자바 스크립트, 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$(=?<

명령 행 인수에서 입력을받습니다. 여러 단어를 인용하고 여러 줄의 개행을 피하십시오.

파이썬 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, 152116 바이트

이름 람다으로, 가정 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에서 반대이며, «입력을 다시 암시 적으로 연결합니다.

참고 : 여전히 회문 인 neverodoreveninput 을 출력 neverod할 수 있다면 palindromize 내장 대신 1 바이트 로 수행 할 수 있습니다 .

û

온라인으로 사용해보십시오.

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

백핸드 , 33 27 바이트

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

온라인으로 사용해보십시오!

여기에있는 많은 솔루션과 달리이 솔루션 은 실제로 palindromized 코드를 사용합니다!

설명:

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