这是一面镜子：|。我刚刚发现，如果字符串可以自身镜像，则可以在字符串中间粘贴一个镜像！例如，字符串abccba。如果将其切成两半，则它们是彼此的镜像：

abc  <-->  cba

因此，我们可以在字符串中间插入一个镜像，新字符串为abc|cba。有时，仅字符串的一部分可以自身镜像。例如，字符串“ mirror”。两个r被镜像，但是字符串的其余部分不是。没关系，我们将删除字符串中彼此不镜像的部分，然后得到以下字符串：

r|r

某些字符串可以在多个位置进行镜像。例如，“ Hello World，xyzzyx”。我喜欢镜子上反射很多文字，因此您需要找到放置镜子的最佳位置。在这种情况下，您应该输出更长的镜像字符串，就像我们上一个示例一样，删除其他所有内容。该字符串变为：

xyz|zyx

有些字符串看起来像它们可以被镜像，但实际上不能。如果字符串无法在任何地方进行镜像，则不应输出任何内容。

挑战：

给定仅包含printable-ascii的字符串，找到放置镜子的最佳位置。换一种说法，

找到最大的等长回文子字符串，然后用竖线字符“ |”输出 在它的中间。

输入长度为1至50个字符。

您可以假定输入将不包含镜像|或换行符。除此之外，所有可打印的ASCII字符都是公平的游戏。如果最长的镜像子字符串绑在两个子字符串之间，则可以选择输出哪个。例如，对于字符串“ abba ollo”，必须输出“ ab | ba”或“ ol | lo”，但是输出哪一个都没有关系。字符串是大小写敏感的，例如，“利群”应该没有输出“AB | BA”，它应该输出空字符串。

样本IO：

"Hello World"     --> "l|l"
"Programming Puzzles and Code-Golf"     --> Either "m|m" or "z|z"
"abcba"           --> ""
"Hulluh"          --> "ul|lu"
"abcdefggfedcba"  --> "abcdefg|gfedcba"
"abcdefggfabc"    --> "fg|gf"
"AbbA"            --> "Ab|bA"
"This input is a lot like the last one, but with more characters that don't change the output. AbbA" --> "Ab|bA"

像往常一样，这是代码高尔夫球，因此存在标准漏洞，而最短答案以字节为单位！

Pyth- 19 17 15 13字节

感谢@FryAmTheEggman为我节省了两个字节。

ARRGH特殊情况下无人接听。解决了！

e_I#jL\|cL2.:

测试套件。

e                Last element in list, this works out to longest one
  _I             Invariance under reverse, this detect palindrome
   #             Filter
   jL            Map join
    \|           By "|"
    cL2          Map chop in two pieces
     .:Q)        Substrings. Implicit Q). ) makes it do all substrings.

05AB1E，19 17 14字节

码：

Œévy2ä'|ý©ÂQi®

说明：

Π               # Get all substrings of the input
 é               # Sort by length (shortest first)
  vy             # For each element...
    2ä           # Split into two pieces
      '|ý        # Join by "|"
         ©       # Copy this into the register
          Â      # Bifurcate, pushing a and reversed a
           Q     # Check if it's a palindrome
            i®   # If so, push that string again
                 # Implicit, the top element is outputted

使用CP-1252编码。在线尝试！。

Python 2，102 97字节

def f(s):h=len(s)/2;r=s[:h]+'|'+s[h:];return s and max(r*(r==r[::-1]),f(s[1:]),f(s[:-1]),key=len)

相当缓慢且效率低下...在Ideone上验证较小的测试用例。

JavaScript，100 99字节

s=>eval('for(O=i=0;s[i++];O=O[j+j]?O:o)for(o="|",j=0;(S=s[i-1-j])&&S==s[i+j++];o=S+o+S);O[1]?O:""')

要么

s=>eval('for(O="",i=0;s[i++];O=O[j+j]||j<2?O:o)for(o="|",j=0;(S=s[i-1-j])&&S==s[i+j++];o=S+o+S);O')

Lua，133个字节

s=...for i=#s,1,-1 do for j=1,#s-i do m=j+i/2-i%2/2t=s:sub(j,m).."|"..s:sub(m+1,i+j)if t==t.reverse(t)then print(t)return end end end

在Ideone.com上验证所有测试用例。

视网膜，66字节

字节数假定为ISO 8859-1编码。

M!&`(.)+(?<-1>\1)+(?(1)¶)
O$#`.+
$.&
A-2`
^(.)+?(?=(?<-1>.)+$)
$&|

在线尝试！（第一行可同时测试多个换行分隔的测试用例。）

嗯，比我想要的长得多...

JavaScript（ES6），91

s=>[...s].map((d,i)=>{for(a='|',j=0;d=s[i-j],d&&d==s[i-~j];r=r[j+++j]?r:a)a=d+a+d},r='')&&r

少打高尔夫球

f=s=>
  [...s].map(
    (d,i) => {
    for(a='|', j=0; d=s[i-j], d&&d==s[i-~j]; r = r[j++ +j]? r : a)
      a = d+a+d
    }, r=''
  ) && r

测试

F=
s=>[...s].map((d,i)=>{for(a='|',j=0;d=s[i-j],d&&d==s[i-~j];r=r[j+++j]?r:a)a=d+a+d},r='')&&r

;[["Hello World", "l|l"]
,["Programming Puzzles and Code-Golf", "m|m"]
,["abcba", ""]
,["Hulluh", "ul|lu"]
,["abcdefggfedcba", "abcdefg|gfedcba"]
,["abcdefggfabc", "fg|gf"]
,["AbbA", "Ab|bA"]
,["This input is a lot like the last one, but with more characters that don't change the output. AbbA", "Ab|bA"]]
.forEach(t=>{
  var i=t[0],k=t[1],r=F(i)
  console.log(k==r?'OK ':'KO ',i+' -> '+r,k!=r?'(check '+k+')':'')
})  

Perl 5中，105 100 98 + 1 = 106个 101 99个字节

/(?=((.)(?1)?\2)(?{[push@_,$1})(?!))/;($_)=sort{length$b<=>length$a}@_;substr($_,length>>1,0)='|'if$_

我只是想尝试一下递归正则表达式。需要-p选项。编辑：由于@ msh210，已保存（划掉4个）7个字节。（丢失的字节是由于保存已被@ msh210的最新保存所取代。）

Python 2，91个字节

f=lambda s,p='':s and max((''<p<=s<p+'\x7f')*(p[::-1]+'|'+p),f(s[1:]),f(s[1:],s[0]+p),key=len)

替换\x7f为实际字符DEL，该字符为ASCII 127（贷给Dennis）。

这遵循与Dennis相似的策略，即使用max并递归分支以找到最长的回文间隔。但是，相反，它找到左半部分，并用自制的startwith检查相应的镜像右半部分是否紧随其后。

该函数猜测第一个字符是否在镜像的左半部分中。如果没有，它将丢弃它并在其余部分上递归。如果是这样，它将被添加到p反向字符堆栈中。如果该字符串从堆栈开始，则生成镜像字符串，并将其视为最长的镜像。为了避免|作为输出，仅考虑非空堆栈。

果冻，17个字节

ẆŒḂÐfṪœs2j”|µẋLḂ$

在线尝试！

在聊天室Xcoder 先生和DJMcMayhem的帮助下完成

怎么运行的

ẆŒḂÐfṪœs2j”|µẋLḂ$ - Main link. Argument s  e.g.    ; 'AbbA'

Ẇ                 - All contiguous sublists
   Ðf             - Keep elements that are...
 ŒḂ               -  Palindromic                   ; [['A'], ['b'], ['b'], ['A'], ['bb'], ['AbbA']]
     Ṫ            - Final element                  ; 'AbbA'
      œs2         - Split into 2 chunks            ; ['Ab', 'bA']
         j”|      - Join with "|"                  ; 'Ab|bA'
            µ     - New link with ^ as argument
              LḂ$ - Is the length odd?             ; 1
             ẋ    - Repeat the string ^ many times ; 'Ab|bA'

Haskell，126111字节

(!)=drop
f s|n<-length s=last$"":[a++'|':b|k<-[1..n],t<-map(!s)[1..n-k],let[a,b]=take k<$>[t,k!t],a==reverse b]

TSQL 227 223个字节

我将长度硬编码为最大99个字节，这节省了字节，但速度变慢了。虽然它仍然有不错的表现。

打高尔夫球：

DECLARE @t varchar(99)='AbccbA'

,@z char(99)='',@a INT=0,@ INT=0WHILE @a<LEN(@t)SELECT
@z=IIF(LEN(x)>LEN(@z)/2and @t LIKE'%'+x+REVERSE(x)+'%'COLLATE
Thai_bin,x+'|'+REVERSE(x),@z),@=IIF(@=50,1,@+1),@a+=IIF(@=1,1,0)FROM(SELECT
SUBSTRING(@t,@a,@)x)x PRINT @z

取消高尔夫：

DECLARE @t varchar(99)='AbccbA'

,@z char(99)='',
@a INT=0,
@ INT=0
WHILE @a<LEN(@t)
  SELECT
    @z=IIF(LEN(x)>LEN(@z)/2and @t LIKE'%'+x+REVERSE(x)+'%'COLLATE Thai_bin,x+'|'
       +REVERSE(x),@z),
    @=IIF(@=99,1,@+1),
    @a+=IIF(@=1,1,0)
  FROM
    (SELECT SUBSTRING(@t,@a,@)x)x

PRINT @z

小提琴

Python 2，149字节

R,L,s=range,len,input()
t=max([s[i:j/2+i/2]for i in R(L(s))for j in R(L(s)+1)if s[i:j]==s[i:j][::-1]and(j-i)%2<1],key=L)
print t+'|'*(L(t)>0)+t[::-1]

在线尝试

该程序找到长度相等的最大回文子字符串的前半部分，并打印该字符串，然后打印一个|，然后反转该字符串。如果没有合适的字符串，t将为空字符串，'|'*(L(t)>0)并将计算为空字符串。

爪哇8，294个 283 232字节

s->{int l=s.length(),i=0,j,z,y=0;String a,b="";for(;i<l;i++)for(j=0;j<=l-i;)if((a=s.substring(i,i+j++)).equals(new StringBuffer(a).reverse()+"")&(z=a.length())%2<1&z>y){y=z;b=a;}return y>0?b.substring(0,y/=2)+"|"+b.substring(y):"";}

说明：

在这里尝试。

s->{                               // Method with String as both parameter and return-type
  int l=s.length(),                //  Length of the input-String
      i=0,j,                       //  Index-integers
      z,y=0;                       //  Temp-integers
  String a,b="";                   //  Temp-Strings
  for(;i<l;i++)                    //  Loop (1) from 0 to `l` (exclusive)
    for(j=0;j<=l-i;                //   Inner loop (2) from 0 to `l-i` (inclusive)
      if((a=s.substring(i,i+j++))  //    Set the current substring to `a`
          .equals(new StringBuffer(a).reverse()+"")
                                   //    If `a` is a palindrome
         &(z=a.length())%2<1       //    And the length of `a` is even
         &z>y){                    //    And the length of `a` is larger than `y`
        y=z;                       //     Change `y` to `z`
        b=a;}                      //     Change `b` to `a`
                                   //   End of inner loop (2) (implicit / single-line body)
                                   //  End of loop (1) (implicit / single-line body)
  return y>0?                      //  If the result-length is not 0:
    b.substring(0,y/=2)+"|"+b.substring(y)
                                   //   Return the result
   :                               //  Else:
    "";                            //   Return an empty String
}                                  // End of method