Étant donné un nombre N , afficher / renvoyer X de telle sorte que N + X soit un palindrome, où | X | doit être aussi petit que possible.

Palindrome: Un nombre est un palindrome, si sa séquence de chiffres est la même lors de la lecture de gauche à droite que lors de la lecture de droite à gauche.
95359et 6548456sont symétriques, 123et 2424ne le sont pas. Les nombres avec des zéros 020non significatifs comme ne sont pas un palindrome.

L'entrée est un entier positif inférieur à 10 ¹⁵ . Lisez-le depuis stdin, comme paramètre de méthode, peu importe.

La sortie doit être un entier (positif ou négatif) et doit être 0 si l'entrée est déjà un palindrom. Vous pouvez écrire votre sortie sur stdout, la renvoyer depuis une fonction ou ce que vous voulez. S'il y a 2 nombres (par exemple 2et -2) qui satisfont aux exigences, sortez un seul d'entre eux.

Exemples:

Input             Output
3                 0
234               -2
1299931           -10
126               5 or -5 (only one of them)

Pyth , 26 20

Lnb_bWP`+QZ=Z-g0ZZ)Z

Mis à jour pour répondre aux nouvelles règles.

Le programme s'exécute dans une boucle infinie qui teste chaque incrément possible, dans l'ordre 0, -1, 1, -2, -2 ...

Explication:

Q=eval(input())     implicit
Z=0                 implicit
Lnb_b               def P(b): return b != rev(b)
WP`+QZ              while P(repr(Q+Z)):
=Z-g0ZZ             Z=(0>=Z)-Z
)                   <end while>
Z                   print(Z)

Exemple d'exécution:

python3 pyth.py programs/palin.pyth <<< 965376457643450
-2969881

Cela a pris 23 secondes.

Solution bonus, même nombre de caractères:

Wn`+QZ_`+QZ=Z-g0ZZ)Z

Rubis, 111 84 octets

i=$*[j=-1].to_i
r=->j{s=(i+j).to_s
abort(j.to_s)if s==s.reverse}
loop{r[j+=1]
r[-j]}

Prend le nombre comme seul argument de ligne de commande.

CJam, 34 29 25 octets

q~:I!{:R1<R-RI+`_W%=!}g;R

Essayez-le en ligne.

Exemples

$ cjam palfind.cjam <<< 120; echo
1
$ cjam palfind.cjam <<< 121; echo
0
$ cjam palfind.cjam <<< 122; echo
-1

Comment ça marche

q~:I    " Read from STDIN, evaluate and save the result in “I”.                           ";
!       " Compute the logical NOT (0 since the integer is positive).                      ";
{       "                                                                                 ";
  :R    " Save the topmost integer in “R”.                                                ";
  1<R-  " Compute (R < 1) - R. This produces the sequence 0 → 1 → -1 → 2 → -2 → … .       ";
  RI+   " Push I + R.                                                                     ";
  `_    " Cast to string and push a copy.                                                 ";
  W%=!  " Check if the reversed copy matches the original.                                ";
}g      " If it doesn't, repeat the loop.                                                 ";
;R      " Discard the integer on the stack and push “R”.                                  ";

Haskell - 62

f n=[x-n|x<-[0..]>>= \v->[n+v,n-v],show x==(reverse.show)x]!!0

Enregistrez-le dans un fichier nommé golf.hspuis testez-le avec ghci:

*Main> :l golf
[1 of 1] Compiling Main             ( golf.hs, interpreted )
Ok, modules loaded: Main.
*Main> map f [1000..1050]
[-1,0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18,-19,-20,-21,-22,-23,-24,-25,-26,-27,-28,-29,-30,-31,-32,-33,-34,-35,-36,-37,-38,-39,-40,-41,-42,-43,-44,-45,-46,-47,-48,-49]
*Main> 

Python 2.7, 98 , 81

Crée un palindrome à partir du numéro d'entrée, puis le soustrait de l'entrée pour trouver le delta.

def f(n):
    m=map(int,str(n));l=len(m)/2;m[-l:]=m[l-1::-1];return int(`m`[1::3])-n

usage:

print f(3)          # 0
print f(234)        # -2
print f(2342)       # -10
print f(129931)     # -10
print f(100000)     # 1

non golfé et annoté:

def f(n):                      # take a integer n
    m=map(int,str(n));         # convert n into array of ints
    l=len(m)/2;                # get half the length of the array of ints
    m[-l:]=m[l-1::-1];         # replace the last elements with the first elements reversed
    return int(`m`[1::3])-n    # convert array of ints backinto single int and subtract the original number to find the delta

Perl 5, 93 89 88 87 75 63 44

$/=($/<1)-$/while$_+$/-reverse$_+$/;$_=$/+0

Non golfé:

while($input + $adjustment - reverse($input + $adjustment)) {
    $adjustment = ($adjustment < 1) - $adjustment;   
}
$input = $adjustment + 0;  ## gives 0 if $adj is undefined (when $input is a palindrome)
print $input;  ## implicit

Grâce aux suggestions de Dennis, il est descendu à 43 + -p = 44

05AB1E , 15 14 octets (-1 Merci à Emigna)

2äнsgÈi∞ë.∞}s-

Essayez-le en ligne!

Méthode:

• Prenez la première moitié du nombre.
• Miroir, il est intersecté s'il est impair, non intersecté s'il est pair.
• Différence.

Java: 127 109

Itération de base, vérification à la fois négative et positive avant de passer au candidat suivant.

int p(long n){int i=0;for(;!(n+i+"").equals(new StringBuilder(n+i+"").reverse()+"");i=i<1?-i+1:-i);return i;}

Pour entrée 123456789012345 , il revient -1358024, à égal palindrome123456787654321 .

Sauts de ligne:

int p(long n){
    int i=0;
    for(;!(n+i+"").equals(new StringBuilder(n+i+"").reverse()+"");i=i<1?-i+1:-i);
    return i;
}   

Clojure, 92

Prend le premier d'une séquence paresseuse qui fonctionne à partir de 0 et n'inclut que des valeurs qui font des palindromes:

(defn p[x](first(for[i(range)j[1 -1]k[(* i j)]s[(str(+ x k))]:when(=(seq s)(reverse s))]k)))

Session REPL-LPER:

golf-flog> (p 3)
0
golf-flog> (p 10)
1
golf-flog> (p 234)
-2
golf-flog> (p 1299931)
-10
golf-flog> (p (bigint 1e15))
1

JavaScript, 175 136 117

Simple. prenvoie vrai si un nombre donné est palindrome, frecherche le plus proche.

EDIT: Je l'ai également joué un peu plus au golf grâce à la douce astuce "indécrémentation" de Geobits dans la réponse Java ici.

p=function(n){return (s=''+n).split('').reverse().join('')==s}
f=function(n){for(i=0;!p(n+i);i=i<1?-i+1:-i);return i}

Usage:

f(3)
f(234)
f(1299931)

J - 49 car

Une fonction mappant des entiers à des entiers.

((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0)

Voici comment vous pourriez construire ce résultat, en trois parties. Voici l'affichage du J REPL: les lignes en retrait sont des entrées utilisateur et celles en retrait sont des sorties REPL. Et oui, J épelle le signe négatif avec un trait de soulignement _.

   236 (_1 1*]) 4                          NB. -ve and +ve of right arg
_4 4
   236 (f=._1 1*]) 4                       NB. name it f
_4 4
   236 (+f=._1 1*]) 4                      NB. add left to each
232 240
   236 (":@+f=._1 1*]) 4                   NB. conv each to string
232
240
   236 ((-:|.)@":@+f=._1 1*]) 4            NB. palindrome? on each
1 0
   236 (g=.(-:|.)@":@+f=._1 1*]) 4         NB. name it g
1 0
   236 (+:/@g=.(-:|.)@":@+f=._1 1*]) 4     NB. logical NOR (result 1 if both=0)
0
   palin =: (+:/@g=.(-:|.)@":@+f=._1 1*])


   236 (>:@]) 0                            NB. increment right
1
   236 (>:@]^:2) 0                         NB. functional power
2
   236 (>:@]^:(236 palin 3)) 3             NB. power 1 if no palindromes
4
   236 (>:@]^:(236 palin 4)) 4             NB. power 0 if has palindrome
4
   236 (>:@]^:palin) 4                     NB. syntactic sugar
4
   236 (>:@]^:palin^:_) 0                  NB. increment until palindrome, start with 0
4
   (>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0) 236    NB. bind 0
4
   delta =: >:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0


   ((f) delta) 236       NB. f=: -ve and +ve
_4 4
   ((g) delta) 236       NB. g=: which are palindromes
1 0
   ((g#f) delta) 236     NB. select the palindromes
_4
   ((g#f) delta) 126     NB. what if both are equal?
_5 5
   ((0{g#f) delta) 126   NB. take the first element
_5
   ((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0) 236   NB. it works!
_4

Exemples:

   pal =: ((0{g#f)>:@]^:(+:/@g=.(-:|.)@":@+f=._1 1*])^:_&0)
   pal 3
0
   pal every 234 1299931 126
_2 _10 _5
   pal 2424
18
   2424 + pal 2424
2442

Vous pouvez également faire en sorte que le golf préfère la solution positive au négatif quand elles sont égales, en changeant _1 1en 1 _1.

Javascript 86

n=>{s=(n+'').split('');for(i=0,j=s.length-1;i<j;i++,j--)s[j]=s[i];return s.join('')-n}

Ceci est mon premier défi de codegolf. J'espère que cette solution est acceptable.

ungolfed: n => { s = (n + '').split(''); for (i = 0, j = s.length - 1; i < j; i++,j--) s[j] = s[i]; return s.join('') - n } Explication:
Convertissez l'entrée n en chaîne et divisez.
Itérer sur les deux côtés du tableau résultant et copier le chiffre sur s [i] vers s [j] jusqu'à i <j. Cela se traduira par notre palindrome souhaité.
Regroupez le tableau et soustrayez n pour obtenir x

JavaScript (ES6), 84 octets

n=>[...(''+n)].reduce((p,c,i,s,m=s.length-1)=>i<m/2?p+(c-s[m-i])*Math.pow(10,i):p,0)

Mon premier défi de golf! Je sais que la solution plus courte et plus élégante a déjà été publiée par @Brian H., mais c'est une autre approche.

Code de test

const t =
n=>[...(''+n)].reduce((p,c,i,s,m=s.length-1)=>i<m/2?p+(c-s[m-i])*Math.pow(10,i):p,0)
;

console.log('t(3) =', t(3)); // expected: 0
console.log('t(234) =', t(234)); // expected: -2
console.log('t(1299931) =', t(1299931)); // expected: -10
console.log('t(126) =', t(126)); // expected: -5

Brachylog , 8 octets

;.≜+A↔A∧

Essayez-le en ligne!

Le prédicat d'étiquette ≜est vital ici, car en l'utilisant sur la sortie avant toute autre chose (bien qu'il soit vraiment invoqué sur la liste contenant l'entrée et la sortie), sa valeur absolue est minimisée, car au lieu de faire quelque chose de plus intelligent basé sur le contraintes, le programme devine chaque entier à partir de 0 jusqu'à ce qu'il puisse en trouver un qui fonctionne. Si ≜est omis, il apparaît au programme que 0 est un très joli palindrome, et il affichera toujours le négatif de l'entrée.

            The input
;  +        plus
 .          the output
  ≜         which is instantiated immediately
    A       is A
     ↔      which reversed
      A     is still A
       ∧    but isn't necessarily the output.

Groovy - 131 111 107 caractères

Golfé:

n=args[0] as long;a=n;b=n;f={if("$it"=="$it".reverse()){println it-n;System.exit 0}};while(1){f a++;f b--}

échantillons:

bash-2.02$ groovy P.groovy  0
0
bash-2.02$ groovy P.groovy  234
-2
bash-2.02$ groovy P.groovy  1299931
-10
bash-2.02$ groovy P.groovy  123456789012345
-1358024

Non golfé:

n=args[0] as long
a=n
b=n
f={ if("$it"=="$it".reverse()) {
       println it-n
       System.exit 0
    }
}

while(1) {
    f a++
    f b--
}

Python 2 - 76

i=input()
print sorted([r-i for r in range(2*i)if`r`==`r`[::-1]],key=abs)[0]

Obtient le numéro d'entrée et génère une liste des différences entre l'entrée et chaque nombre entre 0et 2*iuniquement si le nombre est palindromique.

Il trie ensuite la liste par valeur absolue et imprime le premier élément.

C ++ 289

La fonction P vérifie les palindromes en utilisant la <algorithm>méthode.

Non golfé:

bool P(int32_t i)
{
string a,b;
stringstream ss;
ss<<i;
ss>>a;
b=a;
reverse_copy(b.begin(),b.end(),b.begin());
int k=a.compare(b);
return (k==0);
}
int main()
{
int32_t n; cin>>n;
int32_t x=0,y=n,z=n,ans=x;
while(1)
{
if(P(y)){ans=x; break;}
if(P(z)){ans=-1*x; break;}
x++;
y+=x;
z-=x;
}
cout<<ans<<endl;
return 0;
}

Mathematica 75

Peut probablement être joué au golf plus ..

p = (j=0; b=#; While[a=IntegerDigits[b]; b += ++j(-1)^j; a!=Reverse[a]]; #-b+(-1)^j) &

Espaces non comptés et non nécessaires.

CoffeeScript: 73

(x)->(x+="")[0...(y=x.length/2)]+x[0...-y].split("").reverse().join("")-x

Explanation: This takes advantage of the fact that if we have a number of odd length (say 1234567), x.slice(0, y) won't include the middle digit but x.slice(0, -y) will. JavaScript's slice probably shouldn't work this way, but it does.

I was expecting CoffeeScript/JavaScript to have a better way to reverse a string, but the split/reverse/join method seems to be all there is.

PHP, 56 bytes

for(;strrev($i+$n=$argv[1])-$n-$i;$i=($i<1)-$i);echo+$i;

takes input from command line argument; run with -nr.

javascript 68 bytes

(n,s=[...(''+n)],j=s.length)=>s.map((v,i,)=>i>--j?s[j]:v).join('')-n

HUGE props to @Beldraith for the algorithm, i'm posting this as an answer though, because it took me quite the time to get it to work in a single statement.

Any tips are welcome ;)

ungolfed

(
    n, // input
    s=[...(''+n)], // input split to array of chars
    j=s.length, // highest available index in s
)=> 
s.map( // this will return a new array, without modifying s
    (
        v, // value of current iteration
        i, // index of current iteration
    )=> i > --j ? s[j] : v
).join('') - n

Python, 109

def q(x,z):
 r=lambda s:int(str(s)[::-1])
 if x+z==r(x+z):return z
 if x-z==r(x-z):return -z
 return q(x,z+1)

QBIC, 38 bytes, nc

:{[-1,1,2|A=!a+b*c$~A=_fA||_xb*c]c=c+1

Explanation:

The code reads an input, and then applies a modifier. It then tests to see if the number + modifier is a palindrome. Then, it flips the sigh on the modifier, re-applies that and tests again.

:{        Read the input value, start a DO-loop
[-1,1,2|  FOR (b = -1; b <= 1; b+=2 )
A=!a+b*c$ Get a string from the input number, 
            plus modifier c (which is 0 at the start of QBIC)
            times -1 or 1, depending on b's iteration.
~A=_fA|   if that string is equal to it's own reversed version
|_xb*c]   then Quit, printing the modifier * sign
c=c+1     Increment the modifoer and DO-LOOP again.
          The DO-loop is implicitly closed by QBIC at EOF

Bash, 73 bytes

i=$1;x=$i;while((x-10#$(rev<<<$x)));do ((r=(1>r)-r,x=r+i));done;echo $x

Input goes to the 1st command line argument:

foo.sh 123456789

Axiom, 720 594 412 bytes

R(x)==>return x;p(r,a)==(n:=#(a::String);if r<0 then(a=0=>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2));if r>0 then(n=1 and a<9=>R(a+1);a=10^n-1=>R(a+2));r=0 and n=1=>1;v:=a quo 10^(n quo 2);repeat(c:=v;w:=(n rem 2>0=>v quo 10;v);repeat(c:=10*c+w rem 10;w:=w quo 10;w=0=>break);r<0=>(c<a=>R c;v:=v-1);r>0=>(c>a=>R c;v:=v+1);R(c=a=>1;0));c)
D(a:NNI):INT==(p(0,a)=1=>0;w:=p(-1,a);s:=p(1,a);a-w<s-a=>w-a;s-a)

The byte count it is again this, but the algo it would be O(log(n)) because it would dipend only from the digit lenght of its input (and log10(n) would be near the lenght of the decimal digits of n). ungolfed and results

-- Ritorna il precedente numero palidrome rispetto ad 'a' NNI, se r<0
--                               ha la particolarita' palpn(-1,0) = 0
-- Ritorna il successivo numero palidrome rispetto ad 'a' NNI, se r>0
-- Se r=0 ritorna 1 se 'a' e' palindrome, 0 se 'a' non e' palindrome
R(x)==>return x
palpn(r,a)==
    n:=#(a::String) -- n la lunghezza in cifre di base 10 di a
    if r<0 then(a=0        =>R a;n=1 or a=10^(n-1)=>R(a-1);a=10^(n-1)+1=>R(a-2))
    if r>0 then(n=1 and a<9=>R(a+1);    a=10^n-1  =>R(a+2))
    r=0  and n=1=>1
    v:=a quo 10^(n quo 2)
    repeat -- because here not there is a goto instruction i have to use repeat
        c:=v;w:=(n rem 2>0=>v quo 10;v)
        repeat
          c:=10*c+w rem 10
          w:=w quo 10
          w=0=>break
        r<0=>(c<a=>R c;v:=v-1)
        r>0=>(c>a=>R c;v:=v+1)
        R(c=a=>1;0) -- for r==0
    c

-- Ritorna la distanza minima tra l'input 'a' e una palindrome:
--        0 se 'a' e' una palindrome
--        r numero con segno negativo se tale palindrome precede 'a'
--        r numero con segno positivo se tale palindrome e' successiva ad 'a'
palDistance(a:NNI):INT==
    palpn(0,a)=1=>0
    p:=palpn(-1,a);s:=palpn(1,a)
    a-p<s-a=>p-a
    s-a

--------------------------------------

(3) -> [[i,D(i)] for i in [3,10,234,1299931,126]]
   (3)  [[3,0],[10,1],[234,- 2],[1299931,- 10],[126,5]]
                                                  Type: List List Integer
(4) -> D 7978986575546463645758676970789089064235234524548028408198401348930489104890184018410
   (4)  - 199223418598327604580355025458434427119613
                                                            Type: Integer
(5) ->  p(0,7978986575546463645758676970789089064235234524548028408198401348930489104890184018410+%)
   (5)  1
                                                    Type: PositiveInteger
(6) -> 7978986575546463645758676970789089064235234524548028408198401348930489104890184018410+%%(-2)
   (6)
       7978986575546463645758676970789089064235234325324609809870796768575463646455756898797
                                                    Type: PositiveInteger

Husk, 16 12 9 bytes

ḟoS=↔+⁰İZ

Thanks @H.PWiz for -4 bytes!

Try it online!

Explanation

ḟ(S=↔+⁰)İZ  -- input ⁰ a number, for example: 126
        İZ  -- built-in integers: [0,1,-1,2,-2...]
ḟ(     )    -- first element that satisfies the following (eg. 5):
     +⁰     --   add element to input: 131
  S=        --   is it equal to itself..
    ↔       --   ..reversed: 131 == 131

APL NARS 47 chars

r←s a;b
r←0
A:b←⍕a+r⋄→0×⍳b≡⌽b⋄r←-r⋄→A×⍳r<0⋄r+←1⋄→A

this above search but algo can not be fast and right as the g below...

This

A:b←⍕a+r⋄→0×⍳b≡⌽b⋄r←-r⋄→A×⍳r<0⋄r+←1⋄→A

is a simple loop exit only when it find b≡⌽b so b is a string palindrome

  s¨3,10,234,1299931,126
0 1 ¯2 ¯10 5 

∇r←g w;n;a;y;t;o;h;v
         r←0J1
   →0×⍳0≠⍴⍴w⋄→0×⍳''≡0↑w ⍝ if arg is not scalar int>=0→0J1
   →0×⍳(w<0)∨w≠⌊w
   h←{z←⍕⍺⋄q←⍕⍵⋄⍎(z,⌽q)}⍝ h return as digit ⍺⌽⍵
   n←⍴⍕w⋄r← 0
   →0×⍳n≤1              ⍝ arg one digit return r←0
   a←10*⌊n÷2
B: v←a⋄→C×⍳∼2∣n⋄v←a×10
C: t←⌊w÷v ⋄y←⌊w÷a
   o←y h t⋄r←(y+1)h t+1
   →D×⍳∼(∣r-w)<∣o-w⋄r←r-w⋄→0
D: r←o-w
∇

  g¨3,10,234,1299931,126
0 1 ¯2 ¯10 ¯5 

Python 2, 55 54 bytes

l=lambda n,d=0:`n+d`!=`n+d`[::-1]and l(n,~d+(d<0))or d

Try it online!

Japt, 8 bytes

nȥsw}cU

Try it

nȥsw}cU     :Implicit input of integer U
      cU     :Get the first number in the sequence [U,U-1,U+1,U-2,U+2,...,U-n,U+n]
 È           :That returns true when passed the the following function
  ¥          :  Test for equality with
   s         :  Convert to string
    w        :  Reverse
     }       :End function
n            :Subtract U from the result