介绍

对于那些不知道的人来说，回文是指字符串等于字符串向后的字符串（插补，空格等除外）。回文的一个例子是：

abcdcba

如果您扭转这种情况，最终将得到：

abcdcba

都一样 因此，我们称这为回文。为了使事情更平淡，让我们看一个字符串示例：

adbcb

这不是回文。为了做到这一点，我们需要将反向字符串合并到初始字符串右侧的初始字符串中，而两个版本均保持不变。越短越好。

我们可以尝试的第一件事如下：

adbcb
bcbda
^^ ^^

并非所有字符都匹配，因此这不是反转字符串的正确位置。我们向右走了一步：

adbcb
 bcbda
 ^^^^

这也不是所有字符都匹配。我们向右再走一步：

adbcb
  bcbda

这次，所有字符都匹配。我们可以合并两个完整的字符串。最终结果是：

adbcbda

这是回文字符串。

任务

给定一个仅包含小写字母的字符串（至少包含一个字符）（如果更合适，则使用大写字母），输出经过palindromized的字符串。

测试用例

Input     Output

abcb      abcba
hello     hellolleh
bonobo    bonobonob
radar     radar
hex       hexeh

这是代码高尔夫球，因此以最少的字节提交为准！

果冻，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（commit b93a874），11个字节

.VkI_IJ+zbB

测试套件

该代码利用了Pyth当前版本中的一个错误，即提交b93a874。的错误是_IJ+zb被解析，如果它是q_J+zbJ+zb，这相当于_I+zb+zb，当它应（由Pyth的设计意图）被解析为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.

Python，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

Haskell，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将是您可以连接到Input使其成为回文的最短值。

备用解决方案，5字节

~@[.r

这与上面的答案大致相同，除了声明“输出是输入与字符串的连接A”之外，我们声明“输出是输入是输出的前缀的字符串”。

JavaScript（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

在线尝试！

非常感谢Martin节省了11个字节！

这只是创建字符串的反向副本并将其平滑在一起。唯一真正喜欢的部分是反转方法：O^#r`.\G，这是通过使用排序模式完成的。我们用数字值对第二个字符串的字母（不是换行符，并且从字符串末尾开始连续的字母\G）按它们的数值排序，由于没有数字，所以它们为0。然后反转该^选项的稳定排序结果的顺序。花式用法的全部功劳\G归Martin :)

18岁的CJam

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

Lua，89 88字节

我击败了Javascript！\ 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

Prolog，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仍然不能解决命名的功能，但这里是代码作为程序的运行测试。

Perl，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编码。在线尝试！

Pyke，15个字节

D_Dlhm>m+#D_q)e

在这里尝试！

J，20个字节

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

这是一元动词。在这里尝试。用法：

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

说明

我使用的事实是，S的回文化是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.

Haskell，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答案中得到了宽松的启发。

`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

Ruby，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

Haskell，46个字节

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

我想知道是否有一种方法可以删除(f$tail l)++[l!!0]... 中的括号