소개

모르는 사람들에게 회문은 문자열이 문자열과 거꾸로 같을 때입니다 (구멍 뚫기, 공백 등 제외). 회 문의 예는 다음과 같습니다.

abcdcba

이것을 뒤집 으면 다음과 같이 끝납니다.

abcdcba

어느 것도 동일합니다. 그러므로 우리는 이것을 회문이라고 부릅니다. 일을 귀찮게하기 위해 문자열의 예를 살펴 보겠습니다.

adbcb

이것은 회문이 아닙니다. 이것을 palindromize하기 위해, 우리는 반전 된 문자열을 초기 문자열 의 오른쪽에있는 초기 문자열 에 병합하여 두 버전을 그대로 유지해야합니다. 짧을수록 좋습니다.

가장 먼저 시도 할 수있는 것은 다음과 같습니다.

adbcb
bcbda
^^ ^^

모든 문자가 일치하는 것은 아니므로 반전 된 문자열의 올바른 위치가 아닙니다. 우리는 오른쪽으로 한 걸음갑니다 :

adbcb
 bcbda
 ^^^^

이것은 또한 모든 문자와 일치하지 않습니다. 우리는 오른쪽으로 또 다른 단계를 밟습니다.

adbcb
  bcbda

이번에는 모든 문자가 일치 합니다. 우리는 할 수 있습니다 병합 두 문자열 그대로를 떠나는 . 최종 결과는 다음과 같습니다.

adbcbda

이것은 palindromized 문자열 입니다.

작업

소문자 만 포함 된 문자열 (적어도 하나의 문자가있는 문자열) (또는 더 적합한 경우 대문자)이 제공되면 palindromized string을 출력하십시오 .

테스트 사례

Input     Output

abcb      abcba
hello     hellolleh
bonobo    bonobonob
radar     radar
hex       hexeh

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

젤리, 11 10 바이트

ṫỤfU$Ḣœ^;U

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

작동 원리

ṫỤfU$Ḣœ^;U  Main link. Argument: s (string)

 Ụ          Yield all indices of s, sorted by their corr. character values.
ṫ           Tail; for each index n, remove all characters before thr nth.
            This yields the list of suffixes of s, sorted by their first character,
            then (in descending order) by length.
    $       Combine the two links to the left into a chain:
   U        Upend; reverse all suffixes.
  f         Filter; only keep suffixes that are also reversed suffixes.
            This gives the list of all palindromic suffixes. Since all of them
            start with the same letter, they are sorted by length.
     Ḣ      Head; select the first, longest palindromic suffix.
      œ^    Multiset symmetric difference; chop the selected suffix from s.
         U  Upend; yield s, reversed.
        ;   Concatenate the results to the left and to the right.

Pyth (커밋 b93a874), 11 바이트

.VkI_IJ+zbB

테스트 스위트

이 코드는 현재 버전의 Pyth, commit b93a874 의 버그를 이용합니다 . 버그는 _IJ+zb마치 Pyth의 설계 의도에 따라와 같이 구문 분석되어야 할 때 q_J+zbJ+zb와 동일 _I+zb+zb하게 구문 분석되며 q_J+zbJ이는에 해당합니다 _I+zb. 이렇게하면 버그를 수정 한 후 바이트를 저장할 수 있습니다 .VkI_IJ+zbJB. 버그가 수정되면 올바른 코드가됩니다 . 대신 그 코드를 설명하겠습니다.

기본적으로 코드 무차별은 입력에 추가되어 회문을 형성하고 결합 된 문자열을 출력 할 수있는 가장 짧은 문자열을 찾을 때까지 가능한 모든 문자열을 강제 실행합니다.

.VkI_IJ+zbJB
                z = input()
.Vk             For b in possible strings ordered by length,
       +zb      Add z and b,
      J         Store it in J,
    _I          Check if the result is a palindrome,
   I            If so,
          J     Print J (This line doesn't actually exist, gets added by the bug.
          B     Break.

파이썬, 46 바이트

f=lambda s:s*(s==s[::-1])or s[0]+f(s[1:])+s[0]

끈이 회 문인 경우 반환하십시오. 그렇지 않으면, 나머지 문자열에 대해 첫 번째 문자를 재귀 결과 주위에 끼 웁니다.

고장 예 :

f(bonobo)
b  f(onobo) b
b o f(nobo) o b 
b o n f(obo) n o b
b o n obo n o b

하스켈, 36 바이트

f s|s==reverse s=s|h:t<-s=h:f t++[h]

더 읽기 쉽게 :

f s
 |s==reverse s = s
 |(h:t)<-s     = h:(f t)++[h]

끈이 회 문인 경우 반환하십시오. 그렇지 않으면 문자열의 꼬리에 대한 첫 번째 문자를 재귀 결과 주위에 끼 웁니다.

스트링 s은 h:t두 번째 가드에서 분리 되어이 경우 필러가 1>0필요하지 않습니다. 이것은 s@(h:t)입력 보다 짧습니다 .

Pyth- 16 12 바이트

@FryAmTheEggman 덕분에 4 바이트가 절약되었습니다.

FGITW, 많은 골프 가능.

h_I#+R_Q+k._

테스트 스위트 .

Brachylog , 16 6 5 바이트 (비경쟁)

:Ac.r

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

초기 답변을 게시했을 때 여전히 Java의 이전 구현에있었습니다. Prolog에서 모든 것을 다시 프로그래밍했기 때문에 이제는 처음부터 그대로 작동합니다.

설명

(?):Ac.        Output is the concatenation of Input with another unknown string A
      .r(.)    The reverse of the Output is the Output

역 전파를 사용하면 첫 번째 유효한 값 A이 입력에 연결되어 회문으로 만들 수있는 가장 짧은 값 이됩니다.

대체 솔루션, 5 바이트

~@[.r

이것은 "출력은 입력을 문자열과 연결하는 것"을 말하는 대신 "출력은 A입력이 출력의 접두사 인 문자열 " 이라는 것을 제외하고는 위의 답변과 거의 동일합니다 .

자바 스크립트 (ES6), 92 바이트

(s,a=[...s],r=a.reverse().join``)=>s.slice(0,a.findIndex((_,i)=>r.startsWith(s.slice(i))))+r

원래 문자열과 반전 사이의 겹침을 계산하고 슬라이스합니다.

망막, 29 25

$
¶$_
O^#r`.\G
(.+)¶\1
$1

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

11 바이트 절약 된 Martin 에게 큰 감사를드립니다 !

이렇게하면 문자열의 역 복사본이 만들어지고 함께 매끄럽게됩니다. 이것의 유일한 멋진 부분은 반전 방법입니다 : O^#r`.\G정렬 모드를 사용하여 수행됩니다. 우리는 두 번째 문자열의 문자를 개행 문자가 아니고 문자열 덕분에 문자열의 끝에서 연속되는 \G숫자를 숫자 값으로 정렬합니다. 이 숫자는 없기 때문에 0입니다. ^옵션 을 사용하여이 안정적인 정렬 결과의 순서 . 멋진 사용에 대한 모든 크레딧은 \GMartin 에 속합니다 :)

CJam, 18

q__,,{1$>_W%=}#<W%

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

설명:

q         read the input
__        make 2 copies
,,        convert the last one to a range [0 … length-1]
{…}#      find the first index that satisfies the condition:
  1$>     copy the input string and take the suffix from that position
  _W%=    duplicate, reverse and compare (palindrome check)
<         take the prefix before the found index
W%        reverse that prefix
          at the end, the stack contains the input string and that reversed prefix

루아, 89 88 바이트

나는 자바 스크립트를 이겼다! \ o / @LeakyNun 덕분에 1 바이트가 절약되었습니다 ^^

그것은 완전한 프로그램이며, 입력을 명령 행 인수로 사용합니다.

i=1s=...r=s:reverse()while s:sub(i)~=r:sub(0,#r-i+1)do i=i+1 end print(s..r:sub(#r-i+2))

언 골프

i=1                             -- initialise i at 1 as string are 1-indexed in lua
s=...                           -- use s as a shorthand for the first argument
r=s:reverse()                   -- reverse the string s and save it into r
while(s:sub(i)~=r:sub(0,#r-i+1))-- iterate while the last i characters of s
do                              -- aren't equals to the first i characters of r
  i=i+1                         -- increment the number of character to skip
end
print(s..r:sub(#r-i+2))         -- output the merged string

프롤로그, 43 바이트

a(S):-append(S,_,U),reverse(U,U),writef(U).

이것은 SWI-Prolog 7과 같은 코드 문자열을 입력으로 예상합니다. a(`hello`).

설명

이것은 기본적으로 내 Brachylog 답변의 포트입니다.

a(S) :-               % S is the input string as a list of codes
    append(S,_,U),    % U is a list of codes resulting in appending an unknown list to S
    reverse(U,U),     % The reverse of U is U
    writef(U).        % Write U to STDOUT as a list of codes

옥타브, 78 75 바이트

Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ 덕분에 3 바이트를 절약했습니다!

function p=L(s)d=0;while~all(diag(s==rot90(s),d++))p=[s fliplr(s(1:d))];end

명명 된 함수에 대해서는 여전히 ideone이 실패하지만 다음 은 코드를 프로그램으로 실행하는 테스트입니다.

펄, 37 바이트

xnor의 답변을 기반으로합니다.

에 +2 포함 -lp

STDIN에서 입력으로 실행

palindromize.pl <<< bonobo

palindromize.pl:

#!/usr/bin/perl -lp
s/.//,do$0,$_=$&.$_.$&if$_!~reverse

05AB1E , 18 바이트

암호:

©gF¹ðN×®«ðñD®åi,q

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이크, 15 바이트

D_Dlhm>m+#D_q)e

여기 사용해보십시오!

J, 20 바이트

,[|.@{.~(-:|.)\.i.1:

이것은 동사입니다. 여기에서 시도하십시오. 용법:

   f =: ,[|.@{.~(-:|.)\.i.1:
   f 'race'
'racecar'

설명

S 의 palindromization 이 S + reverse (P) 라는 사실을 사용하고 있습니다 . 여기서 P 는 제거로 회문이 발생 하는 S 의 가장 짧은 접두사입니다 . J에서는 술어를 만족시키는 배열의 첫 번째 요소를 검색하는 것이 약간 복잡합니다. 따라서 인덱싱.

,[|.@{.~(-:|.)\.i.1:  Input is S.
        (    )\.      Map over suffixes of S:
         -:             Does it match
           |.           its reversal? This gives 1 for palindromic suffixes and 0 for others.
                i.1:  Take the first (0-based) index of 1 in that array.
 [   {.~              Take a prefix of S of that length: this is P.
  |.@                 Reverse of P.
,                     Concatenate it to S.

하스켈, 68 바이트

import Data.List
f i=[i++r x|x<-inits i,i++r x==x++r i]!!0
r=reverse

사용 예 : f "abcb" -> "abcba".

회문을 만들기 위해 역 추가 된 부분을 찾을 때까지 inits입력 i(예 : inits "abcb"-> ["", "a", "ab", "abc", "abcb"])을 검색하십시오 i.

MATL , 17 16 바이트

@aditsu의 CJam answer 에서 느슨하게 영감을 얻었습니다 .

`xGt@q:)PhttP=A~

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

설명

`        % Do...while loop
  x      %   Delete top of stack, which contains a not useful result from the
         %   iteration. Takes input implicitly on first iteration, and deletes it
  G      %   Push input
  t      %   Duplicate
  @q:    %   Generate range [1,...,n-1], where n is iteration index. On the  first
         %   iteration this is an empty array
  )      %   Use that as index into copy of input string: get its first n elements
  Ph     %   Flip and concatenate to input string
  t      %   Duplicate. This will be the final result, or will be deleted at the
         %   beginning of next iteration
  tP     %   Duplicate and flip
  =A~    %   Compare element-wise. Is there some element different? If so, the
         %   result is true. This is the loop condition, so go there will be a 
         %   new iteration. Else the loop is exited with the stack containing
         %   the contatenated string
         % End loop implicitly
         % Display stack contents implicitly

루비, 44 바이트

이 답변은 xnor의 Python 및 Haskell 솔루션을 기반으로 합니다.

f=->s{s.reverse==s ?s:s[0]+f[s[1..-1]]+s[0]}

Oracle SQL 11.2, 195 바이트

SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))FROM(SELECT:1||SUBSTR(REVERSE(:1),LEVEL+1)p FROM DUAL WHERE SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)CONNECT BY LEVEL<=LENGTH(:1));

언 골프

SELECT MIN(p)KEEP(DENSE_RANK FIRST ORDER BY LENGTH(p))
FROM (
       SELECT :1||SUBSTR(REVERSE(:1),LEVEL+1)p 
       FROM   DUAL 
       WHERE  SUBSTR(:1,-LEVEL,LEVEL)=SUBSTR(REVERSE(:1),1,LEVEL)
       CONNECT BY LEVEL<=LENGTH(:1)
     );

진심으로, 34 바이트

╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.

마지막 문자는 공백이 아닙니다 (ASCII 127 또는 0x7F).

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

설명:

╩╜lur`╜╨"Σ╜+;;R=*"£M`MΣ;░p╜;;R=I.<NBSP>
╩                                        push inputs to registers (call the value in register 0 "s" for this explanation)
 ╜lur                                    push range(0, len(s)+1)
     `              `M                   map (for i in a):
      ╜╨                                   push all i-length permutations of s
        "        "£M                       map (for k in perms):
         Σ╜+                                 push s+''.join(k) (call it p)
            ;;R=                             palindrome test
                *                            multiply (push p if palindrome else '')
                      Σ                  summation (flatten lists into list of strings)
                       ;░                filter truthy values
                         p               pop first element (guaranteed to be shortest, call it x)
                          ╜;;R=I         pop x, push s if s is palindromic else x
                                .<NBSP>  print and quit

C #, 202 바이트

나는 노력했다.

class P{static void Main(string[]a){string s=Console.ReadLine(),o=new string(s.Reverse().ToArray()),w=s;for(int i=0;w!=new string(w.Reverse().ToArray());){w=s.Substring(0,i++)+o;}Console.WriteLine(w);}}

언 골프 드 :

class P
{
    static void Main(string[] a)
    {
        string s = Console.ReadLine(), o = new string(s.Reverse().ToArray()), w = s;
        for(int i = 0; w!=new string(w.Reverse().ToArray());)
        {
            w = s.Substring(0, i++) + o;
        }
        Console.WriteLine(w);
        Console.ReadKey();
    }

}

누구든지 .Reverse (). ToArray ()에 대한 두 호출을 그룹화하는 아이디어를 제공 할 수 있습니까? 별도의 방법은 더 많은 바이트입니다.

QBIC , 41 바이트

;_FA|C=A{a=a+1~C=_fC||_XC\C=A+right$(B,a)

설명:

;_FA|    Read A$ from the cmd line, then flip it to create B$
C=A      Set C$ to be A$
{        Start an infinite DO-loop
a=a+1    Increment a (not to be confused with A$...)
~C=_fC|  If C$ is equal to its own reversed version
|_XC     THEN end, printing C$
\C=A+    ELSE, C$ is reset to the base A$, with
right$(B the right part of its own reversal
,a)      for length a (remember, we increment this each iteration
         DO and IF implicitly closed at EOF

하스켈, 46 바이트

f l|l==reverse l=l|(h:t)<-l=l!!0:(f$tail l)++[l!!0]

괄호를 제거하는 방법이 있는지 궁금합니다 (f$tail l)++[l!!0]...