introduction

Une fermeture palindromique d'une chaîne d'entrée est le palindrome le plus court qui peut être construit à partir de la chaîne d'entrée où le palindrome final commence par la chaîne d'entrée.

Pour ce défi, nous envisagerons une fermeture palindromique bidirectionnelle telle que

• La fermeture palindromique gauche d'une chaîne d'entrée est le palindrome le plus court possible qui commence par la chaîne d'entrée.
• Palindromique droit La fermeture d'une chaîne d'entrée est le palindrome le plus court possible qui se termine par la chaîne d'entrée.
• La fermeture palindromique bidirectionnelle d'une chaîne d'entrée est la plus courte de la fermeture palindromique gauche ou droite de la chaîne d'entrée.

Tâche

Votre tâche est simple. Étant donné une chaîne (composée uniquement d'ASCII imprimables, de nouvelles lignes et d'espaces blancs), affichez la fermeture palindromique bidirectionnelle de cette chaîne. En cas d'égalité, les fermetures palindromiques gauche ou droite sont une sortie valide.

Vous pouvez écrire un programme ou une fonction, en saisissant les données via STDIN (ou l'alternative la plus proche), l'argument de ligne de commande ou l'argument de la fonction, et en imprimant le résultat dans STDOUT (ou l'alternative la plus proche) ou en le renvoyant sous forme de chaîne.

Vous pouvez supposer que l'entrée ne sera jamais une chaîne vide.

Quelques exemples:

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

Le crédit de l'idée initiale revient à VisualMelon, idée finale avec l'aide de Martin et Zgarb

Les termes fermeture palindromique, fermeture pallindromique gauche et fermeture palindromique droite ont d'abord été utilisés et définis par cet article .

Pyth, 22 19

hfq_TTsm,+z_d+_dzyz

Essayez-le en ligne .

Explication

La fermeture palindromique bidirectionnelle est de la forme AXou XA, où Xest la chaîne d'entrée et Aest une sous-chaîne de X. Je dois en fait être une sous-chaîne contiguë de X, un préfixe pour une forme, un suffixe pour l'autre forme. Mais je me fiche de ces échecs. Une sous-chaîne (contiguë ou non) est tout ce dont j'ai besoin en 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

modifier

L'ancienne version commandait les chaînes après filtrage par longueur .olN.... Je viens de réaliser que cela yrenvoie les sous-chaînes ordonnées par longueur. Ces palindromes sont donc déjà triés.

Clip , 40

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

Exemple

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

Explication

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

J'espérais vraiment voir une réponse CJam maintenant .. Alors voilà: P

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

Je déteste vraiment ce {,}$bloc là-dedans, mais j'obtiens une liste non ordonnée de palindromes possibles en raison de l'algorithme de génération que j'utilise.

Explication du code

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

Essayez-le en ligne ici

Python 2, 115 113 109 105 96 octets

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]

J'espère pouvoir continuer à jouer au golf. Bits peut-être dignes de mention:

• utiliser la somme pour deux compréhensions de liste en une
• construction de termes dans un ordre trié pour éviter d'avoir besoin de min (suggéré par @Jakube)

Mathematica, 96 octets

Il doit y avoir une manière plus élégante que ça ...

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

Cela définit une fonction sans nom qui prend une chaîne et renvoie le résultat.

L'idée de base est de

• Divisez la chaîne en Characters.
• Formez un tableau avec cette liste et son inverse.

• Utilisez la correspondance de motifs pour trouver le bon palindromique de chacun d'eux:

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

  Notez que cela ne retourne pas réellement une liste plate. Par exemple pour {a,b,c}vous

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

• Triez les deux résultats par longueur.

• Choisissez le plus court et rejoignez-le en une chaîne avec ""<>#&@@.

Brachylog (2), 6 octets, défi de postdates de langue

~{↔?a}

Essayez-le en ligne!

Comme d'habitude pour Brachylog, c'est une fonction, pas un programme complet.

Explication

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

Pour autant que je sache (ce n'est pas ma langue, mais cela semble peu probable), an'a pas été ajouté à Brachylog pour ce défi, mais il est très pratique ici. Nous utilisons la méthode «inverse et affirmons qu'elle n'a pas changé» pour affirmer que la valeur que nous trouvons est un palindrome.

Quant à savoir pourquoi cela produit le palindrome le plus court , l'ordre d'évaluation de Prolog (et donc de Brachylog) est fortement influencé par la première chose qu'il évalue. Dans ce cas, il s'agit d'une commande "inverse" et (comme la plupart des opérations de liste), elle définit un ordre d'évaluation qui vise à minimiser la taille de la liste résultante. Comme c'est la même chose que la taille de la sortie, le programme finit heureusement par minimiser exactement la bonne chose par hasard, ce qui signifie que je n'avais pas besoin d'ajouter d'indications explicites.

Rubis, 76 + 2 = 78

Avec des drapeaux de ligne de commande -pl(le lpeut ne pas être nécessaire selon la façon dont vous effectuez la saisie), exécutez

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

Étant donné une chaîne 'abaa', génère les chaînes 'cbca 0 acbc' et 'acbc 0 cbca', où 0 est le caractère non imprimable avec le code ascii 0. Il supprime ensuite une copie de la plus longue chaîne de trame répétée 0 qu'il trouve dans chacune, «a» dans le premier et «cbc» dans le second, pour obtenir les deux fermetures. Il produit ensuite le résultat le plus court.

La seule chose vraiment bizarre à propos du code golfé est qu'il raccourcit les chaînes en place tout en les triant, ce que nous pouvons éviter car min_byil n'exécute le bloc qu'une fois par élément comparé (à la fois parce qu'il s'agit d'une transformation schwartzienne et parce qu'il n'y en a que deux éléments à comparer).

Python 3, 107 octets

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]

Tester:

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

Haskell, 107 octets

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]

Tester:

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

J, 66 62 octets

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

Assez simple. Les deux astuces que j'utilise:

La fermeture palindromique droite est la fermeture palindromique gauche de la chaîne inversée.

Trouver la longueur de la chaîne avec une longueur et une palindromité minimales avec l'expression min (is_palindrome / length).

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

   f 'lama'
lamal

Essayez-le en ligne ici.