introduzione

Una chiusura palindromica di una stringa di input è il palindromo più corto che può essere costruito dalla stringa di input in cui il palindromo finale inizia con la stringa di input.

Per questa sfida, considereremo una chiusura palindromica a due vie tale che

• La chiusura palindromica sinistra di una stringa di input è il palindromo più breve possibile che inizia con la stringa di input.
• La chiusura palindromica destra di una stringa di input è il palindromo più breve possibile che termina con la stringa di input.
• La chiusura palindromica bidirezionale di una stringa di input è la più breve tra la chiusura palindromica sinistra o destra della stringa di input.

Compito

Il tuo compito è semplice. Data una stringa (composta solo da ASCII stampabile, nuove linee e spazi bianchi), genera la chiusura palindromica bidirezionale di quella stringa. In caso di pareggio, le chiusure palindromiche sinistra o destra sono valide.

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e stampando il risultato su STDOUT (o l'alternativa più vicina) o restituendolo come stringa.

Si può presumere che l'input non sarà mai una stringa vuota.

Alcuni esempi:

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

Il credito iniziale dell'idea va a VisualMelon, idea finale con l'aiuto di Martin e Zgarb

I termini chiusura palindromica, chiusura pallindromica sinistra e chiusura palindromica destra sono stati inizialmente utilizzati e definiti da questo documento .

Pyth, 22 19

hfq_TTsm,+z_d+_dzyz

Provalo online .

Spiegazione

La chiusura palindromica a due vie è della forma AXo XA, dove si Xtrova la stringa di input ed Aè una sottostringa di X. In realtà devo essere una sottostringa contigua di X, un prefisso per una forma, un suffisso per l'altra forma. Ma non mi interessa di queste defails. Una sottostringa (contigua o no) è tutto ciò di cui ho bisogno in 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

modificare

La vecchia versione ordinava le stringhe dopo averle filtrate per lunghezza .olN.... Appena realizzato, yrestituisce le sottostringhe ordinate per lunghezza. Quindi questi palindromi sono già ordinati.

Clip , 40

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

Esempio

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

Spiegazione

(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 byte

Speravo davvero di vedere una risposta CJam ormai .. Quindi eccola qui: P

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

Odio davvero quel {,}$blocco lì dentro, ma ottengo un elenco non ordinato di possibili palindromi a causa dell'algoritmo di generazione che sto usando.

Spiegazione del codice

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

Provalo online qui

Python 2, 115 113 109 105 96 byte

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]

Si spera che possa golf ulteriormente. Bit forse degni di nota:

• usando la somma per due comprensioni in una
• costruzione di termini in ordine ordinato per evitare la necessità di min (suggerito da @Jakube)

Mathematica, 96 byte

Deve esserci un modo più elegante di questo ...

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

Questo definisce una funzione senza nome che accetta una stringa e restituisce il risultato.

L'idea di base è

• Dividi la stringa in Characters.
• Forma un array con questo elenco e il suo contrario.

• Usa il pattern matching per trovare il giusto palindromico di ognuno di essi:

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

  Si noti che questo in realtà non restituisce un elenco semplice. Ad esempio per {a,b,c}te

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

• Ordina i due risultati per lunghezza.

• Scegli il più corto e uniscilo nuovamente in una stringa con ""<>#&@@.

Brachylog (2), 6 byte, sfida postdatati in lingua

~{↔?a}

Provalo online!

Come al solito per Brachylog, questa è una funzione, non un programma completo.

Spiegazione

~{↔?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.

Per quanto ne so (non è la mia lingua, ma sembra improbabile), anon è stato aggiunto a Brachylog per questa sfida, ma qui è molto utile. Usiamo il metodo "reverse, e affermiamo che non è cambiato" per affermare che il valore che troviamo è un palindromo.

Per quanto riguarda il motivo per cui questo produce il palindromo più corto , l'ordine di valutazione di Prolog (e quindi di Brachylog) è fortemente influenzato dalla prima cosa che valuta. In questo caso, si tratta di un comando "inverso" e (come la maggior parte delle operazioni dell'elenco) imposta un ordine di valutazione che mira a ridurre al minimo le dimensioni dell'elenco risultante. Dato che è uguale alla dimensione dell'output, il programma finisce felicemente per minimizzare esattamente la cosa giusta per caso, il che significa che non ho bisogno di aggiungere alcun suggerimento esplicito.

Rubino, 76 + 2 = 78

Con i flag della riga di comando -pl( lpotrebbe non essere necessario a seconda di come stai facendo l'input), esegui

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

Data una stringa 'ABAA', genera le stringhe 'CBCA 0 ACBC' e 'ACBC 0 CBCA', dove 0 è il carattere non stampabile con codice ASCII 0. Quindi, elimina una copia dei più lunghi ripetuti stringa di inquadratura 0 che trova in ogni, 'a' nel primo e 'cbc' nel secondo, per ottenere le due chiusure. Emette quindi il risultato più breve.

L'unica cosa davvero strana del codice golfed è che accorcia le stringhe mentre le ordina, il che possiamo cavartela perché min_byesegue il blocco solo una volta per elemento confrontato (sia perché è una trasformazione di Schwartz che perché ci sono solo due elementi da confrontare).

Python 3, 107 byte

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]

Testare:

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

Haskell, 107 byte

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]

Test:

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

J, 66 62 byte

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

Abbastanza semplice. I due trucchi che uso:

La chiusura palindromica destra è la chiusura palindromica sinistra della corda invertita.

Trovare la lunghezza della stringa con lunghezza minima e palindromia con l'espressione min (is_palindrome / length).

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

   f 'lama'
lamal

Provalo online qui.