Questo è uno specchio: |. Ho appena scoperto che puoi attaccare uno specchio nel mezzo di una stringa se la stringa può essere specchiata su se stessa! Ad esempio, la stringa abccba. Se lo tagli a metà le due metà sono immagini speculari l'una dell'altra:

abc  <-->  cba

Quindi, possiamo attaccare uno specchio nel mezzo della stringa, e la nostra nuova stringa è abc|cba. A volte, solo una parte della stringa può essere specchiata su se stessa. Ad esempio, la stringa "mirror". Le due r sono speculari, ma il resto della stringa no. Va bene, rimuoveremo solo le parti della stringa che non si rispecchiano a vicenda e otteniamo la seguente stringa:

r|r

Alcune stringhe potrebbero essere specchiate in più punti. Ad esempio, "Hello World, xyzzyx". Mi piace avere un sacco di testo riflesso nel mio specchio, quindi devi trovare il posto migliore per mettere il mio specchio. In questo caso, dovresti generare la stringa più lunga con mirroring e, proprio come il nostro ultimo esempio, rimuovere tutto il resto. Questa stringa diventa:

xyz|zyx

Alcune stringhe sembrano rispecchiarsi, ma in realtà non possono. Se una stringa non può essere specchiata da nessuna parte, non si dovrebbe produrre nulla.

La sfida:

Data una stringa contenente solo printable-ascii, trova il posto migliore dove inserire il mio mirror. In altre parole,

Trova la sottostringa palindromica di lunghezza pari più grande, quindi esegui l'output con un carattere di pipe "|" nel mezzo di esso.

L'input avrà una lunghezza di 1-50 caratteri.

Si può presumere che l'input non conterrà mirror |o newline. Oltre a ciò, tutti i personaggi stampabili-ascii sono un gioco equo. Se la sottostringa specchiata più lunga è legata tra due sottostringhe, è possibile scegliere quale produrre. Ad esempio, per la stringa "abba ollo", devi generare "ab | ba" o "ol | lo", ma non importa quale di questi hai prodotto. Le stringhe fanno distinzione tra maiuscole e minuscole, ad es. "ABba" non dovrebbe generare "AB | ba", ma dovrebbe generare una stringa vuota.

IO di esempio:

"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"

Come al solito, si tratta di code-golf, quindi si applicano scappatoie standard e vince la risposta più breve in byte!

Pyth - 19 17 15 13 byte

Grazie a @FryAmTheEggman per avermi salvato due byte.

ARRGH il caso speciale per nessuna risposta. Risolto questo!

e_I#jL\|cL2.:

Test Suite .

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 byte

Codice:

Œévy2ä'|ý©ÂQi®

Spiegazione:

Π               # 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

Utilizza la codifica CP-1252 . Provalo online! .

Python 2, 102 97 byte

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)

Piuttosto lento e inefficiente ... Verifica i casi di test più piccoli su Ideone .

JavaScript, 100 99 byte

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:""')

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 byte

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

Verifica tutti i test su Ideone.com .

Retina , 66 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online! (La prima riga consente di testare contemporaneamente diversi casi di test separati dall'alimentazione di linea.)

Hmmm, molto più a lungo di quanto vorrei ...

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

Meno golf

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

Test

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 byte

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

Volevo solo provare le regex ricorsive. Ha bisogno -pdell'opzione. Modifica: salvato (barrato 4) 7 byte grazie a @ msh210. (Il byte mancante è dovuto a un salvataggio sostituito dall'ultimo salvataggio di @ msh210.)

Python 2, 91 byte

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)

Sostituisci \x7fcon l'effettivo carattere DEL, che è ASCII 127 (credito a Dennis).

Questo segue una strategia simile alla risposta di Dennis sull'uso maxe la ramificazione ricorsiva per trovare l'intervallo palindromo più lungo. Ma, invece, trova la metà sinistra, verificando che la corrispondente metà destra specchiata venga subito dopo con un inizio fatto da sé .

La funzione indovina se il primo personaggio si trova nella metà sinistra specchiata. In caso contrario, lo lascia cadere e ricorre sul resto. Se lo è, viene aggiunto alla pila pdi personaggi invertiti. Se la stringa inizia mai con lo stack, la stringa mirror viene generata e considerata come un mirror più lungo possibile. Per evitare |come output, vengono considerati solo stack non vuoti.

Gelatina , 17 byte

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

Provalo online!

Fatto con l'aiuto di Mr. Xcoder e DJMcMayhem in chat

Come funziona

ẆŒḂÐ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, 126 111 byte

(!)=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 byte

Ho codificato la lunghezza massima di 99 byte, questo ha salvato i byte ma lo ha reso più lento. Ha comunque prestazioni decenti.

golfed:

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

Ungolfed:

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

Violino

Python 2, 149 byte

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]

Provalo online

Questo programma trova la prima metà della sottostringa palindromica più grande di lunghezza pari e stampa quella stringa, seguita da una |, seguita da quella stringa invertita. Se non esiste una stringa adatta, tsarà la stringa vuota e '|'*(L(t)>0)verrà valutata come stringa vuota.

Java 8, 294 283 232 byte

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):"";}

Spiegazione:

Provalo qui.

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