Scrivi una funzione che accetta un numero come argomento e lo rende un palindromo aggiungendo il numero minimo di cifre. Il numero sarà composto da un massimo di 100 cifre.

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

J, ^{50 , 32} 26 caratteri!

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

per esempio

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

Come funziona (per esempio)

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 caratteri

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

Richiede Perl 5.10 o versioni successive per le funzionalità regex, ma nessuna opzione speciale da riga di comando.

Esempio di utilizzo:

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

Utilizza le estensioni regex ricorsive di Perl 5.10 per abbinare il palindromo finale più lungo in quanto tale:

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

Quindi lo sostituisce con se stesso ( $&) e aggiunge qualsiasi cosa la stringa iniziata con ( $`), invertita.

Brachylog 2, 8 byte, sfida postdatati in lingua

ẹ;AcB↔Bc

Provalo online! La domanda richiede una funzione, quindi ne ho fornita una; il collegamento TIO accetta un argomento che esegue una funzione come un programma completo.

Spiegazione

ẹ;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 caratteri

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)

modifica: abbreviato in base alla soluzione di @ 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] 

Originale:

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 caratteri

Basato sulla risposta di 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 caratteri

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

Haskell, 85

Utilizzando lo stesso algoritmo della maggior parte degli altri:

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

Esempi dalla descrizione del problema:

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

Ruby 1.9, 72 caratteri

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

Rubino , 70 byte

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

Provalo online!

Basato sulla risposta di TE , con i caratteri anziché .split '' per ottenere 2 caratteri. E sono sicuro che c'è modo di spremere un po 'di più> <

JavaScript (ES6), 145 126 caratteri

 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}

ha commentato:

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 byte

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

Ungolfed:

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

Ho la sensazione che potrebbe essere molto più stretto, ma non è immediatamente ovvio per me come. La funzione occupa molto spazio ma ne avevo bisogno in due punti.

Funziona con qualsiasi stringa, non solo con numeri, e può essere di qualsiasi lunghezza.

PHP, 64 byte

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

Provalo online!