Bei einer gegebenen Zahl N wird X ausgegeben / zurückgegeben, so dass N + X ein Palindrom ist, wobei | X | muss so klein wie möglich sein.

Palindrom: Eine Zahl ist ein Palindrom, wenn die Ziffernfolge beim Lesen von links nach rechts gleich ist wie beim Lesen von rechts nach links.
95359und 6548456sind symmetrisch 123und 2424nicht. Zahlen mit führenden Nullen wie 020sind kein Palindrom.

Die Eingabe ist eine positive Ganzzahl kleiner als 10 ¹⁵ . Lies es aus stdin, als Methodenparameter, was auch immer.

Die Ausgabe muss eine Ganzzahl (positiv oder negativ) sein und sollte 0 sein, wenn die Eingabe bereits ein Palindrom ist. Sie können Ihre Ausgabe auf stdout schreiben, von einer Funktion zurückgeben oder was auch immer Sie möchten. Wenn 2 Zahlen (z. B. 2und -2) vorhanden sind, die die Anforderungen erfüllen, geben Sie nur eine davon aus.

Beispiele:

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

Aktualisiert, um den neuen Regeln zu entsprechen.

Das Programm läuft in einer Endlosschleife, die jedes mögliche Inkrement testet, in der Reihenfolge 0, -1, 1, -2, -2 ...

Erläuterung:

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)

Beispiellauf:

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

Dies dauerte 23 Sekunden.

Bonuslösung, gleiche Zeichenanzahl:

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

Ruby, 111 84 Bytes

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

Nimmt die Zahl als einziges Befehlszeilenargument.

CJam, 34 29 25 Bytes

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

Probieren Sie es online aus.

Beispiele

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

Wie es funktioniert

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

Speichern Sie es in einer Datei mit dem Namen golf.hsund testen Sie es dann mit 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

Erstellt ein Palindrom aus der Eingangsnummer und subtrahiert dieses dann von der Eingabe, um das Delta zu finden.

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

Verwendung:

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

ungolfed und kommentiert:

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

Ungolfed:

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

Dank Dennis 'Vorschlägen auf 43 + -p = 44 gesunken

05AB1E , 15 14 Bytes (-1 Dank an Emigna)

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

Probieren Sie es online!

Methode:

• Nimm die erste Hälfte der Zahl.
• Spiegeln Sie es geschnitten, wenn ungerade, nicht geschnitten, wenn gerade.
• Unterschied.

Java: 127 109

Grundlegende Iteration, die sowohl das Negative als auch das Positive überprüft, bevor zum nächsten Kandidaten übergegangen wird.

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

Bei der Eingabe 123456789012345kehrt es -1358024zum gleichen Palindrom zurück 123456787654321.

Zeilenumbrüche:

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

Nimmt die erste aus einer Lazy-For-Sequenz, die von 0 bis 0 arbeitet und nur Werte enthält, die Palindrome erzeugen:

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

REPL-LPER-Sitzung:

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

Einfach. pGibt true zurück, wenn eine bestimmte Zahl ein Palindrom ist, und fsucht die nächstgelegene.

EDIT: Ich habe es auch ein bisschen mehr golfen, dank des süßen "Indecrement" -Tricks von Geobits in der Java-Antwort hier.

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}

Verwendung:

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

J - 49 Zeichen

Eine Funktion, die Ganzzahlen Ganzzahlen zuordnet.

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

Hier ist, wie Sie dieses Ergebnis in drei Teilen erreichen können. Dies ist die Anzeige des J REPL: Eingezogene Zeilen sind Benutzereingaben und ausgezogene sind REPL-Ausgaben. Und ja, J schreibt das negative Vorzeichen mit einem Unterstrich _.

   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

Beispiele:

   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

Sie können auch die Golf machen die positive Lösung über die negativen bevorzugen , wenn sie gleich sind, durch eine Änderung _1 1zu 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}

Dies ist meine erste Codegolf-Herausforderung. Hoffe, diese Lösung ist akzeptabel.

ungolfed: n => { s = (n + '').split(''); for (i = 0, j = s.length - 1; i < j; i++,j--) s[j] = s[i]; return s.join('') - n } Erläuterung: Die
Eingabe n wird in String konvertiert und aufgeteilt.
Iterieren Sie über beide Seiten des resultierenden Arrays und kopieren Sie die Ziffer von s [i] nach s [j], bis i <j ist. Dies führt zu unserem gewünschten Palindrom.
Füge das Array wieder zusammen und subtrahiere n, um x zu erhalten

JavaScript (ES6), 84 Byte

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)

Meine erste Golf Challenge! Ich weiß, dass die kürzere und elegantere Lösung bereits von @Brian H. gepostet wurde, aber dies ist ein anderer Ansatz.

Code testen

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 Bytes

;.≜+A↔A∧

Probieren Sie es online!

Das Label-Prädikat ≜ist hier von entscheidender Bedeutung, da es in der Ausgabe verwendet wird, bevor irgendetwas anderes passiert (obwohl es in der Liste, die die Eingabe und die Ausgabe enthält, tatsächlich aufgerufen wird), und sein absoluter Wert minimiert wird, weil es nicht auf der Grundlage von smarter vorgeht Einschränkungen Das Programm errät jede Ganzzahl ab 0, bis es eine findet, die funktioniert. Wenn dies ≜weggelassen wird, wird dem Programm klar, dass 0 ein sehr schönes Palindrom ist, und es wird immer das Negative der Eingabe ausgegeben.

            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 Zeichen

Golf gespielt:

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

Probeläufe:

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

Ungolfed:

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]

Ruft die Eingabenummer ab und generiert eine Liste der Unterschiede zwischen der Eingabe und jeder Zahl zwischen 0und2*i nur dann, wenn die Zahl palindrom ist.

Anschließend wird die Liste nach dem absoluten Wert sortiert und das erste Element gedruckt.

C ++ 289

Funktion P prüft nach <algorithm>Methode auf Palindrome .

Ungolfed:

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

Wahrscheinlich kann mehr golfen werden ..

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

Leerzeichen werden nicht gezählt und nicht benötigt.

CoffeeScript: 73

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

Erläuterung: Dies nutzt die Tatsache aus, dass bei einer ungeraden Länge (z. B. 1234567) x.slice(0, y)die mittlere Ziffer nicht enthalten ist, dies jedoch der Fall x.slice(0, -y)ist. JavaScript sollte slicewahrscheinlich nicht so funktionieren, aber es funktioniert.

Ich hatte erwartet, dass CoffeeScript / JavaScript eine bessere Möglichkeit bietet, einen String umzukehren, aber die Methode split / reverse / join scheint alles zu sein, was es gibt.

PHP, 56 Bytes

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

Nimmt Eingaben vom Kommandozeilenargument entgegen; renn mit -nr.

Javascript 68 Bytes

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

RIESIGE Requisiten an @Beldraith für den Algorithmus, ich poste dies jedoch als Antwort, weil ich ziemlich viel Zeit gebraucht habe, um es in einer einzigen Anweisung zum Laufen zu bringen.

Irgendwelche Tipps sind willkommen;)

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

Erläuterung:

Der Code liest eine Eingabe und wendet dann einen Modifikator an. Anschließend wird geprüft, ob der Modifikator number + ein Palindrom ist. Dann wird der Seufzer auf den Modifikator geworfen, erneut angewendet und erneut getestet.

:{        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

Die Eingabe erfolgt in das erste Befehlszeilenargument:

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)

Die Byteanzahl ist es wieder, aber das Algo wäre es O (log (n)), weil es nur von der Ziffernlänge seiner Eingabe abhängt (und log10 (n) wäre nahe der Länge der Dezimalstellen von n ). ungolfed und ergebnisse

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

Schale , 16 12 9 Bytes

ḟoS=↔+⁰İZ

Danke @ H.PWiz für -4 Bytes!

Probieren Sie es online!

Erläuterung

ḟ(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 Zeichen

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

diese obige suche kann aber algo nicht schnell und richtig sein wie die g unten ...

Dies

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

ist nur dann ein einfacher Loop-Exit, wenn b≡⌽b gefunden wird, also b ein String-Palindrom ist

  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

Probieren Sie es online!

Japt , 8 Bytes

nȥsw}cU

Versuch es

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