介绍

输入字符串的回文式闭合是可以从输入字符串中构造的最短回文，其中最终回文以输入字符串开头。

对于这一挑战，我们将考虑双向回文封闭

• 输入字符串的左回文闭合是从输入字符串开始的最短回文。
• 输入字符串的正确回文闭合是以输入字符串结尾的最短回文。
• 输入字符串的双向回文闭合是输入字符串的左回合或右回文中的较短者。

任务

您的任务很简单。给定一个字符串（仅由可打印的ASCII，换行和空白组成），输出该字符串的双向回文式闭包。如果打成平局，则左或右回文式封条都是有效输出。

您可以编写程序或函数，通过STDIN（或最接近的替代方案），命令行自变量或函数自变量获取输入，然后将结果打印到STDOUT（或最接近的替代方案）或将其作为字符串返回。

您可以假定输入永远不会是空字符串。

几个例子：

<Input>   -> <Output>
"abcdef"  -> "abcdefedcba"  (or "fedcbabcdef")
"abcba"   -> "abcba"
"abcb"    -> "abcba"
"cbca"    -> "acbca"

最初的想法归功于VisualMelon，最后的想法归功于Martin和Zgarb

本文首先使用并定义了回文封闭，左回文封闭和右回文封闭这两个术语。

佩斯，22 19

hfq_TTsm,+z_d+_dzyz

在线尝试。

说明

双向回文式闭合格式为AX或XA，其中X输入字符串A是的子字符串X。实际上，我必须是一个连续的子字符串X，一种形式的前缀，另一种形式的后缀。但是我不在乎这些失败。我在Pyth中只需要一个子字符串（连续或不连续）。

                        Implicit: z = raw_input() // Read a string
                 yz     A list with all substrings (contiguous or not) of z
       m                For each of these substrings d, build
        ,                  a pair of two strings:
         +z_d              ( z + inveres(d) ,
             +_dz            inverse(d) + z )
      s                 Sum (put all created pairs into a list)
 fq_TT                  filter elements T, where inverse(T) == T (Palindrom)
h                          Take the first element

编辑

旧版本按长度过滤后对字符串进行排序.olN...。刚意识到，它y返回按长度排序的子字符串。因此，这些回文已被分类。

夹子，40

(sl`f[a=ava}+m[i+v+ixx}Rlxm[i+xvu0ix}Rlx

例

Documents>java -jar Clip4.jar palindrome.clip
abcb
abcba

说明

(sl`                                        .- The shortest                     -.
    f[a=ava}                                .- palindrome                       -.
            +                               .- among the following two sets:    -.
             m[i      }Rlx                  .- For each number up to length(x)  -.
                +                           .- combine                          -.
                 v+ix                       .- the last i chars of x, reversed  -.
                     x                      .- and x.                           -.
                          m[i       }Rlx    .- For each number up to length(x)  -.
                             +              .- combine                          -.
                              x             .- x and                            -.
                               vu0ix        .- the first i chars of x, reversed.-.

CJam，30个字节

我真的很希望现在能看到CJam的答案。

q:Q,{)QW%/(Q+Q@+s}%{,}${_W%=}=

我真的很讨厌{,}$那里的那个区块，但是由于我使用的生成算法，我得到了可能的回文的无序列表。

代码说明

q:Q,{            }%             "Read the input string, store in Q, take length and";
                                "run the code block that many times";
     )QW%                       "Increment the iteration index and Put reversed Q on stack";
         /                      "Split reversed Q into parts of incremented iteration index";
          (Q+                   "Take out the first part and prepend it to Q";
             Q@+s               "Take the rest of the parts and append them to Q";
                   {,}$         "At this point, we have all possible prepended and appended";
                                "sequences of the input string. Sort them by length";
                       {_W%=}=  "Take the first sequence which is a palindrome";

在这里在线尝试

Python 2 115 113 109 105 96字节

f=lambda x:[x for x in sum([[x[:~i:-1]+x,x+x[i::-1]]for i in range(len(x))],[])if x==x[::-1]][0]

希望可以进一步打下去。可能值得注意的一点：

• 将总和用于两个列表推导
• 以排序的方式构造术语，以避免需要分钟（由@Jakube建议）

Mathematica，96个字节

肯定有比这更优雅的方式...

""<>#&@@SortBy[r=Reverse;#/.{b___,a__/;r@{a}=={a}}:>{b,r@{b,a}}&/@{r@#,#}&@Characters@#,Length]&

这定义了一个未命名的函数，该函数采用字符串并返回结果。

基本思想是

• 将字符串拆分为Characters。
• 用此列表及其反向来形成数组。

• 使用模式匹配来找到它们各自的正确回文：

  {b___,a__/;r@{a}=={a}}:>{b,r@{b,a}}
  

  请注意，这实际上并不返回平面列表。例如，{a,b,c}你会得到

  {a,b,{c,b,a}}
  

• 按长度对两个结果进行排序。

• 选择较短的部分，然后将其重新连接成字符串""<>#&@@。

Brachylog（2），6个字节，语言发布日期质询

~{↔?a}

在线尝试！

与Brachylog一样，这是一个功能，而不是完整的程序。

说明

~{↔?a}
~{   }   Find a value that produces {the input} upon doing the following:
  ↔        reversing it;
   ?       asserting that we still have the same value;
    a      and taking either a prefix, or a suffix.

据我所知（这不是我的语言，但似乎不太可能），a并没有加入Brachylog来应对这一挑战，但这确实很方便。我们使用“反向并断言它没有改变”方法断言我们发现的值是回文。

至于为什么产生最短回文的原因，Prolog（以及Brachylog）的评估顺序受其评估的第一件事的影响很大。在这种情况下，这是一个“反向”命令​​，并且（像大多数列表操作一样）它设置了一个评估顺序，旨在最小化结果列表的大小。由于这与输出的大小相同，因此该程序很高兴最终偶然地将正确的事情最小化，这意味着我不需要添加任何显式的提示。

红宝石，76 + 2 = 78

使用命令行标志-pl（l可能不需要，具体取决于您的输入方式），运行

$_=[[$_,r=$_.reverse]*"\0",r+"\0#$_"].min_by{|s|s.sub!(/(.*)\0\1/){$1}.size}

给定字符串'abaa'，生成字符串'cbca 0 acbc”和“ acbc 0 cbca”，其中0是具有ascii代码0的不可打印字符。然后，它将删除在每个字符串中找到的最长重复字符串框架0的一个副本，第一个为“ a”，第二个为“ cbc”，以得到两个闭包。然后输出最短的结果。

关于高尔夫球代码的唯一真正奇怪的事情是，它在排序字符串时缩短了字符串的位置，我们可以避免这种情况，因为min_by每个被比较的元素只执行一次块（两者都是因为 Schwartzian变换，并且因为只有两个要比较的元素）。

Python 3，107个字节

f=lambda a:[i for i in[a[:i:-1]*j+a+a[-1-i::-1]*(1-j)for i in range(len(a))for j in(0,1)]if i==i[::-1]][-1]

去测试：

>>> print("\n".join(map(f, ["abcdef", "abcba", "abcb", "cbca"])))
abcdefedcba
abcba
abcba
acbca

Haskell，107个字节

import Data.List
r=reverse
f s=snd$minimum[(length x,x)|x<-map(s++)(tails$r s)++map(++s)(inits$r s),x==r x]

测试：

*Main> mapM_ (putStrLn.f) ["abcdef", "abcba", "abcb", "cbca"]
abcdefedcba
abcba
abcba
acbca

J，66 62字节

3 :'>({~[:(i.>./)(#%~[-:|.)@>),(<@([,|.@{.~)"#:i.@#"1)y,:|.y'

非常简单。我使用的两个技巧：

右回文闭合是反向弦的左回文闭合。

用表达式min（is_palindrome / length）查找具有最小长度和回文率的字符串的长度。

   f=.3 :'>({~[:(i.>./)(#%~[-:|.)@>),(<@([,|.@{.~)"#:i.@#"1)y,:|.y'

   f 'lama'
lamal

在这里在线尝试。