Écrivez une fonction qui prend un nombre comme argument et en fait un palindrome en ajoutant un nombre minimum de chiffres. Le numéro sera au maximum de 100 chiffres.

Sample Inputs
12
122
232
2323
1012121
Sample Outputs
121
1221
232
23232
101212101

J, ^{50 , 32} 26 caractères!

f=:{.@(,"1(-:|.)\.#|.@}:\)

par exemple

f '12'
121 
f '232'
232   
f '2323'
23232   
f '1012121'
101212101     

Comment ça marche (par exemple)

y =: '1012121'

[\.y   NB. Sub lists of y
1012121
012121 
12121  
2121   
121    
21     
1 

|.\. y  NB> Reverses of sub lists of y
1212101
121210 
12121  
1212   
121    
12     
1  

([\. y) -:"1 (|. \. y) NB. Which of them are equal? (those are palindromes)
                       NB. ( -:"1 ) checks equality item by item
0 0 1 0 1 0 1

(-:  |.)\. y NB. Shortcut of the above
0 0 1 0 1 0 1

(0 0 1 0 1 0 1) # }:\y NB. Choose (#) the palindrome prefixes (\)
10    
1012  
101212

y, |.'10'   NB. Reverse and append the first prefix.
101212101

Perl, 32 caractères

s/((.)(?1)\2|.?)$/$&.reverse$`/e

Nécessite Perl 5.10 ou une version ultérieure pour les fonctionnalités d'expression régulière, mais pas de commutateur de ligne de commande spécial.

Exemple d'utilisation:

$ perl -pe 's/((.)(?1)\2|.?)$/$&.reverse$`/e' << EOT
> 12
> 232
> 2323
> 1012121
> EOT
121
232
23232
101212101

Utilise les extensions de regex récursives de Perl 5.10 pour correspondre au palindrome de fuite le plus long en tant que tel:

m/
    (      # paren 1 - a palindrome is either:
      (.)  # paren 2 - a character
      (?1) # a palindrome as defined in paren 1
      \2   # the same character as in paren 2
    |        # or:
      .?   # a 0- or 1-character string
    )
    $      # at end of string
/x

Il le remplace ensuite par lui-même ( $&) et ajoute tout ce que la chaîne a commencé par ( $`), inversé.

Brachylog 2, 8 octets, défi de postdates de langue

ẹ;AcB↔Bc

Essayez-le en ligne! La question demande une fonction, alors j'en ai fourni une; le lien TIO prend un argument qui exécute une fonction comme un programme complet.

Explication

ẹ;AcB↔Bc
ẹ          Split {the input} into digits
 ;Ac       Append {the shortest possible} list
    B↔B    to produce a palindrome
       c   then concatenate the resulting list of digits back into a number

Python, 88 caractères

def f(x):
 x,y=list(str(x)),[]
 while x!=x[::-1]:y+=x.pop(0)
 return''.join(y+x+y[::-1])

Python ( 101 96)

edit: raccourci basé sur la solution de @ gnibbler

def p(n):s=str(n);r=s[::-1];l=len(s);return[int(s+r[l-i:])for i in range(l)if s[i:]==r[:l-i]][0] 

Original:

def p(n):
 s=str(n);r=s[::-1];l=len(s)
 for i in range(l):
  if s[i:]==r[:l-i]:return int(s+r[l-i:])

Python - 98 caractères

Basé sur la réponse de Hoa :)

def p(n):s=str(n);r=s[::-1];l=len(s);return next(int(s+r[l-i:])for i in range(l)if s[i:]==r[:l-i])

Golfscript - 32 caractères

{`:s-1%:r,,{s<r+..-1%=*}%{}?~}:f

Haskell, 85

En utilisant le même algorithme que la plupart des autres:

import List
r=reverse
f s=s++(r.snd.head.filter g.zip(tails s)$inits s)
g(s,_)=s==r s

Exemples de description du problème:

*Main> map (f.show) [12,232,2323,1012121]
["121","232","23232","101212101"]

Ruby 1.9, 72 caractères

f=->x{x=x.to_s.split'';99.times{|i|x.insert~i,x[i]if x!=x.reverse};x*''}

Rubis , 70 octets

f=->x{x=x.to_s.chars;99.times{|i|x.insert~i,x[i]if x!=x.reverse};x*''}

Essayez-le en ligne!

Basé sur la réponse de VOUS , avec des caractères au lieu de .split '' pour gagner 2 caractères. Et je suis sûr qu'il y a moyen de presser un peu plus> <

JavaScript (ES6), 145 126 caractères

 p=a=>{S=x=>x.split``.reverse();for(s=String(a),i=0;i<s.length;i++)if(x=s+S(s.substring(0,i)).join``,x==S(x).join``)return x}

Commenté:

function palindrome(n){
  s = String(n);
  for(i=0;i<s.length;i++)
  {
    x=s+s.substring(0,i).split("").reverse().join("") //take first n characters, reverse and append to the end
    if(x==x.split("").reverse().join("")) //is the number a palindrome?
      return x;
  }
}

Java, 174 octets

x->{Function<String,String>r=t->new StringBuilder(t).reverse().toString();String y=r.apply(x),z=x;int m=x.length();while(!z.equals(r.apply(z)))z=x+y.substring(--m);return z;}

Non golfé:

x -> {
        Function<String, String> r = t -> new StringBuilder(t).reverse().toString();
        String y = r.apply(x), z=x;
        int m = x.length();
        while (!z.equals(r.apply(z))) z = x+y.substring(--m);
        return z;
    }

J'ai le sentiment que cela pourrait être beaucoup plus serré, mais je ne sais pas immédiatement comment. La fonction mange beaucoup d'espace mais j'en avais besoin à deux endroits.

Cela fonctionne pour n'importe quelle chaîne, pas seulement pour les nombres, et cela peut avoir n'importe quelle longueur.

PHP, 64 octets

for(;strrev($p=$argn.strrev(substr($argn,0,$i++)))!=$p;);echo$p;

Essayez-le en ligne!