Encontre o número palíndrico mais próximo

22

Dado um número N , dê saída / retorne X para que N + X seja um palíndromo, onde | X | tem que ser o menor possível.

Palíndromo: Um número é um palíndromo, se sua sequência de dígitos for a mesma ao lê-los da esquerda para a direita e ao ler da direita para a esquerda.
95359e 6548456são simétricos, 123e 2424não são. Números com zeros à esquerda, como 020não são um palíndromo.

A entrada é um número inteiro positivo menor que 10 15 . Leia-o no stdin, como um parâmetro-método, qualquer que seja.

A saída deve ser um número inteiro (positivo ou negativo) e deve ser 0 se a entrada já for um palíndromo. Você pode gravar sua saída no stdout, retorná-la de uma função ou o que quiser. Se houver 2 números (por exemplo, 2e -2) que atendam aos requisitos, imprima apenas um deles.

Exemplos:

Input             Output
3                 0
234               -2
1299931           -10
126               5 or -5 (only one of them)
CommonGuy
fonte
Presumivelmente, se um número estiver a meio caminho entre os dois palíndromos mais próximos, será uma saída aceitável? Por exemplo, para N=10a saída pode ser X=-1ou X=1?
Peter Taylor
@ PeterTaylor Sim, só precisa ser o menor possível.
usar o seguinte comando

Respostas:

9

Pyth , 26 20

Lnb_bWP`+QZ=Z-g0ZZ)Z

Atualizado para atender às novas regras.

O programa é executado em um loop infinito, que testa todos os incrementos possíveis, na ordem 0, -1, 1, -2, -2 ...

Explicação:

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)

Exemplo de execução:

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

Isso levou 23 segundos.


Solução de bônus, mesma contagem de caracteres:

Wn`+QZ_`+QZ=Z-g0ZZ)Z
isaacg
fonte
Apenas para que você saiba, as regras foram alteradas para encontrar o palíndromo mais próximo (em qualquer direção). Mas acho que desde que você postou antes dessa alteração de regra, não há obrigação de corrigi-la.
Martin Ender
Pode salvar caracteres para fazer o loop Z através [0, 1, -1, 2, -2, ...]de uma atualização Z=-Z+(Z<0)?
xnor
Sim - eu pensei nisso de forma independente.
Isaacg
@xnor Adicionado. Enchedor.
Isaacg
OK legal. Você já pensou em colocar a negação da condição dentro de algum tempo? E talvez salvando um repr aplicando-o à entrada em P?
Xnor
7

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

Toma o número como seu único argumento de linha de comando.

Martin Ender
fonte
Que tal este site ?
usar o seguinte comando
@ Manu Obrigado não sabia disso! Minha submissão funciona até onde eu sei.
Martin Ender
6

CJam, 34 29 25 bytes

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

Experimente online.

Exemplos

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

Como funciona

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”.                                  ";
Dennis
fonte
5

Haskell - 62

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

Salve-o em um arquivo chamado golf.hse teste-o com 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> 
Raio
fonte
que tal escrever x<-[0..]>>=(\v->[n+v,n-v])? É mais curto e o torna uma linha única
proud haskeller
@proudhaskeller Thanks! Truque muito elegante com a mônada da lista.
Ray
4

Python 2.7, 98 , 81

Cria um palíndromo do número de entrada e subtrai-o da entrada para encontrar o 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

uso:

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

ungolfed e anotado:

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
Moop
fonte
Isso não dá o menor delta. f(19) = -8(palíndromo 11), onde deve ser +3feito 22.
Geobits
@Geobits Sim, os valores 10-100 vai me dar um problema com esta abordagem
Moop
Não são apenas esses. Da mesma forma, 199999 fornece -8 em vez de 3, 9911 fornece 88 em vez de -22. Apenas inverter os primeiros dígitos não funciona para obter o menor delta em muitos casos.
Geobits
bem, eu não diria muitos casos, aposto que 99,9% dos casos para os quais trabalha. Mas sim, ele precisa trabalhar para 100% dos casos
Moop
@Geobits. Claro, então 27% de taxa de erro lá. Mas quando você chega aos 100000000s, a taxa de erros cai consideravelmente. Seria interessante calcular a taxa de erro real.
Moop
4

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

Graças às sugestões de Dennis, reduzimos para 43 + -p = 44

user0721090601
fonte
1
1. -$aé menor do que $a*-1. 2. Se você usar ($a<1), não há necessidade ? :$a++. 3. Se você usar a -popção $_=<>e print$_estiver implícito, poderá soltar a primeira instrução e alterar a última para $_=$a+0.
Dennis
@Dennis Nice encontra. Esta é apenas a minha segunda tentativa de código de golfe, então aprecie o conselho!
user0721090601
É habitual contar o -pswitch como um byte extra, mas você pode recuperá-lo usando em ($a<1)-$avez de -$a+($a<1).
Dennis
@ Dennis I embora sobre usando esse método baseado na sua resposta anterior, mas o ganho se perde porque requer um espaço anteswhile
user0721090601
Se você usar em $/vez de $a, ele funcionará.
Dennis
4

05AB1E , 15 14 bytes (-1 Graças a Emigna)

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

Experimente online!


Método:

  • Pegue a primeira metade do número.
  • Espelhe a interseção se for ímpar, e não interseção se for par.
  • Diferença.
Urna de polvo mágico
fonte
Eu acho que você pode usar em 2äнvez de g;î£.
Emigna
3

Java: 127 109

Iteração básica, verificando negativo e positivo antes de passar para o próximo candidato.

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

Para entrada 123456789012345, ele retorna -1358024para igual ao palíndromo 123456787654321.

Quebras de linha:

int p(long n){
    int i=0;
    for(;!(n+i+"").equals(new StringBuilder(n+i+"").reverse()+"");i=i<1?-i+1:-i);
    return i;
}   
Geobits
fonte
Funciona n+i+""e salva os colchetes? Eu acho que a precedência deve estar correta.
Peter Taylor
@ PeterTaylor Yep, e recebeu mais alguns toString(). Obrigado :)
Geobits
1
Posso roubar tão doce i=i<1?-i+1:-i? Vou chamá-lo de "profanação".
Jacob
@Jacob Go for it;)
Geobits
3

Clojure, 92

Obtém o primeiro de uma sequência for lenta que funciona de 0 a zero e inclui apenas valores que formam palíndromos:

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

Sessão 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
YosemiteMark
fonte
2

JavaScript, 175 136 117

Direto. pretorna true se um determinado número é palíndromo, fpesquisa o mais próximo.

Edição: Eu também joguei um pouco mais, graças ao doce truque de "indecrement" por Geobits na resposta Java aqui.

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}

Uso:

f(3)
f(234)
f(1299931)
Jacob
fonte
104 no ES6: p=n=>[...s=''+n].reverse().join('')==s f=n=>{r=t=0;while(!(p(n+r++)||p(n+t--)));return p(n+r-1)?r-1:t+1}:)
William Barbosa
1
Aposto que é. functione returnsão terrivelmente longo Palavras-reservados ...
Jacob
1
Desculpe pela demora de 3 anos, mas golfed a 68 em ES6: s=>{for(i=0;[...s+i+""].reverse().join``!=s+i;i=i<0?-i:~i);r‌​eturn i}. Stack-overflow propenso a 61 f=(s,i=0)=>[...s+i+""].reverse().join``==s+i?i:f(s,i<0?-i:~i‌​)
:;
2

J - 49 char

Uma função que mapeia números inteiros para números inteiros.

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

Veja como você pode criar esse resultado, em três partes. Esta é a exibição do J REPL: linhas recuadas são entrada do usuário e linhas desatualizadas são saída REPL. E sim, J escreve o sinal negativo com um sublinhado _.

   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

Exemplos:

   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

Você também pode fazer com que o golfe prefira a solução positiva sobre a negativa quando iguais, alterando _1 1para 1 _1.

algoritmshark
fonte
2

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}

Este é o meu primeiro desafio de codegolf. Espero que esta solução seja aceitável.

ungolfed: n => { s = (n + '').split(''); for (i = 0, j = s.length - 1; i < j; i++,j--) s[j] = s[i]; return s.join('') - n } Explicação:
Converta a entrada n em String e divida.
Itere nos dois lados da matriz resultante e copie o dígito em s [i] a s [j] até i <j. Isso resultará em nosso palíndromo desejado.
Junte a matriz novamente e subtraia n para obter x

Beldraith
fonte
Bem-vindo ao PPCG! Essa resposta tem a estrutura correta (os envios de funções normalmente funcionam melhor em JavaScript) e parece fornecer as respostas certas também. Sua postagem pode ser aprimorada por meio de uma explicação de por que esse algoritmo funciona (não é óbvio para mim por que funciona), mas está bom no momento.
Obrigado, ive adicionado uma pequena explicação e uma versão ungolfed
Beldraith
você pode mudar s=(n+'').split('')para s=[...(n+'')]. raspar 5 bytes
Brian H.
Eu estava pensando da mesma maneira, mas 19 parece ser o primeiro contra-exemplo: f(19)=3porque 22 é o mais palindrômico mais próximo, mas a função retorna -8 para converter 19 em 11. btw [...n+'']também funcionará por mais -2 bytes
Shieru Asakoto
2

JavaScript (ES6), 84 bytes

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)

Meu primeiro desafio de golfe! Sei que a solução mais curta e elegante já foi publicada por @Brian H., mas essa é outra abordagem.

Código de teste

yetirs
fonte
1
Bem-vindo ao PPCG!
Steadybox
2

Braquilog , 8 bytes

;.≜+A↔A∧

Experimente online!

O predicado de rótulo é vital aqui, porque, ao usá-lo na saída antes que qualquer outra coisa aconteça (embora esteja realmente sendo chamado na lista que contém a entrada e a saída), seu valor absoluto é minimizado, porque, em vez de fazer algo mais inteligente com base no Restrições O programa adivinha todos os números inteiros, começando em 0, até encontrar um que funcione. Se omitido, ocorre no programa que 0 é um palíndromo muito bom e sempre emitirá o negativo da entrada.

            The input
;  +        plus
 .          the output
  ≜         which is instantiated immediately
    A       is A
     ↔      which reversed
      A     is still A
       ∧    but isn't necessarily the output.
String não relacionada
fonte
1

Groovy - 131 111 107 caracteres

Golfe:

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

execuções de amostra:

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--
}
Michael Easter
fonte
1

Python 2 - 76

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

Obtém o número de entrada e gera uma lista das diferenças entre a entrada e todos os números entre 0e 2*isomente se o número for palíndrico.

Em seguida, classifica a lista por valor absoluto e imprime o primeiro elemento.

BeetDemGuise
fonte
Não acho que o range (2 * i) funcione para entradas grandes.
Moop
Você pode usar mincom um argumento de palavra-chave em vez de classificar.
xnor
Para usar intervalos tão longos, você precisa mudar para xrange, que é um gerador, e min, que curto-circuito, para evitar sobrecarregar sua memória.
Isaacg
1

C ++ 289

A função P verifica os palíndromos usando <algorithm> método

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;
}
bacchusbeale
fonte
Será mais curto colocar tudo em uma linha.
cat
1

Mathematica 75

Provavelmente pode ser jogado mais.

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

Espaços não contados e desnecessários.

freddieknets
fonte
1

CoffeeScript: 73

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

Explicação: Isso tira vantagem do fato de que, se tivermos um número ímpar de comprimento (por exemplo, 1234567), x.slice(0, y)não incluiremos o dígito do meio, mas incluiremos x.slice(0, -y). JavaScript sliceprovavelmente não deveria funcionar dessa maneira, mas funciona.

Eu esperava que o CoffeeScript / JavaScript tivesse uma maneira melhor de reverter uma string, mas o método split / reverse / join parece ser tudo o que existe.

Justin Morgan
fonte
1

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.

Titus
fonte
1

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
Brian H.
fonte
@Beldraith hope you dont mind me porting your answer to a single statement function, i had a blast doing so :D
Brian H.
Golfable to 63: (n,s=[...n+''],j=s.length)=>s.map((v,i)=>i>--j?s[j]:v).join``-n, but also a non-obvious counterexample (19) exists ;)
Shieru Asakoto
ouch, it's not just 19, it's any number that ends with a 9 and should get a positive result
Brian H.
0

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)
RageCage
fonte
this throws an error when running (maximum recursion depth exceeded)
Moop
That's not an error in my code. It will exceed maximum recursion depth on a massive number, but it works on decently sized numbers. As there was no maximum test case in the specs, this should still be considered a valid solution.
RageCage
1
The number 123456789 causes it to fail, well below the 10^15 limit posted in the question.
Moop
1
You could easily turn the recursion into a loop and avoid this issue altogether
Moop
1
Running this in the Stackless Python implementation should avoid the recursion depth issue.
xnor
0

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
steenbergh
fonte
0

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
iBug
fonte
0

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
RosLuP
fonte
The ones had spoken again (or for the complete elimination) the use of goto for computer languages, for my humble hobby programmer prospective: Are incompetent in informatics !!!!
RosLuP
0

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
ბიმო
fonte
0

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 
RosLuP
fonte
0

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