Escriba un programa corto para el algoritmo 196 . El algoritmo comienza desde un número entero, luego le agrega su reverso hasta que se alcanza un palíndromo.

p.ej

input = 5280
5280 + 0825 = 6105
6105 + 5016 = 11121
11121 + 12111 = 23232
output = 23232

Entrada

un número entero, que no es un número de lyrchrel (es decir, eventualmente produce un palíndromo bajo este algoritmo, en lugar de continuar infinitamente)

Salida

el palíndromo alcanzó.

APL (22 caracteres)

{a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞

Esto funciona en Dyalog APL. Aquí hay una explicación, de derecha a izquierda:

• { ... }⍞: Obtenga la entrada del usuario como caracteres ( ⍞) y aliméntelo a nuestra función ( { ... }).
• Dentro de la función directa ( ⋄separa las declaraciones, por lo que las miramos de izquierda a derecha):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Evalúe ( ⍎) el argumento correcto ( ⍵) reverse ( ⌽), y agregue eso a la versión evaluada del argumento correcto en sí. Luego, formatee el resultado ( ⍕; es decir, dé su representación de caracteres), asígnele ( ←) eso a la variable a, y finalmente pruebe si ael reverso es equivalente a a(es decir, ¿es aun palíndromo?). Si es cierto, regrese a; de otra manera...
  • ∇a: Retroalimente anuestra función ( ∇es una referencia propia implícita).

Ejemplo:

      {a≡⌽a←⍕(⍎⍵)+⍎⌽⍵:a⋄∇a}⍞
412371
585585

GolfScript, 29 caracteres

~]{{.`.-1%.@={;0}{~+1}if}do}%

Comentario seleccionado

La carne del programa es el dociclo, por supuesto. Así que solo cubriré eso.

1. .` copia el número y lo stringifica.
2. .-1% copia esa versión de cadena y la invierte.
3. .@ copia la versión invertida y trae la versión original no invertida al frente.

Así, por ejemplo, el número es 5280. En esta etapa, la pila es: 5280 "0825" "0825" "5280". El escenario está preparado para la comparación. (Después de la comparación, la pila se dejará en 5280 "0825"cualquier lugar --- los elementos para comparar se han eliminado).

1. Si la cadena y el reverso son iguales, no nos importa la cadena revertida, así que simplemente desactívela ( ;) y devuelva 0 (para finalizar el dociclo).
2. Si no coinciden, evalúe ( ~) la cadena invertida (para convertirla en un número), agregue ( +) eso al número original y devuelva 1 (para continuar el dociclo).

Python 2, 55 bytes

Siguiendo la sugerencia de JPvdMerwe:

n=input()
while`n`!=`n`[::-1]:n+=int(`n`[::-1])
print n

Python 2, 62:

n=raw_input()
while n!=n[::-1]:n=`int(n)+int(n[::-1])`
print n

Ruby - 56 caracteres

x,r=gets
x="#{x.to_i+r.to_i}"until x==r=x.reverse
puts x

Solo ejercito mis habilidades de Pyth, no un contendiente serio

Pyth, 16 bytes

L?bqb_by`+vbi_bTyz

Equivalente a Python 3:

y=lambda b:b if b==b[::-1] else y(str(eval(b)+int(b[::-1],10)))
print y(input())

J 25 ^{27 31}

f=:(+g)^:(~:g=.|.&.":)^:_
e.g.
f 5280
23232

CJam, 22 21 bytes

CJam se creó después de esta pregunta, por lo que técnicamente es un envío no válido. Pero la pregunta me pareció interesante, así que aquí va:

r{__W%:X=0{~X~+s1}?}g

Explicación:

r{                 }g    "Read the input number as string and enter a while-do loop";
  __                     "Make 2 copies of the string number";
    W%:X                 "Reverse the second and store it in X";
        =                "Check if the number is already palindrome";
         0{      }?      "Put 0 on stack if it is palindrome, else, run the code block";
           ~             "Convert the string to int";
            X~           "Put the reverse string on stack and convert it to int too";
              +s         "Add the two numbers and covert back the result to string";

La lógica central es que en cada iteración while-do, primero verifica si se alcanza el palíndromo o no. Si no, agregue el reverso al número. ¡Más o menos lo que es el algoritmo!

Pruébalo en línea aquí

Este es un contendiente real, ya que J ha existido durante décadas.

J (16 bytes)

(+^:~:|.&.":)^:_

Este es un verbo, por lo que puede asignarse a una variable en una sesión J y usarse así:

   f =. (+^:~:|.&.":)^:_
   f 5280
23232

Cómo funciona:

(+^:~:|.&.":)^:_
 +^:~:           add if unequal
      |.&.":     reverse under string format
 +^:~:|.&.":     add reverse unless a palindrome
(           )^:_ repeat until unchanged

Python: 66

n=input()
while 1:
 r=int(`n`[::-1])
 if n==r:break
 n+=r
print n

Perl, 40 caracteres

$_=<>;$_+=$r while$_!=($r=reverse);print

Scala 82

def p(n:Int):Int={val s=n.toString.reverse.toInt
if(n==s)n else p(n+s)}
p(readInt)

JAGL Alpha 1.2 - 19, 21 con stdin

No contendiendo , solo obteniendo algo de experiencia con mi idioma
Espera un número de stdin

T~d{DddgCi+dgdC=n}uSP

Explicación

T~                       Get a line of input, and eval to an integer
  d                      Duplicate (for first round)
   {Ddd                  Drop last and duplicate twice
       gCi               Convert to string, reverse, and convert back to integer
          +d             Add to original and duplicate
            gdC          Convert to string, duplicate, reverse
               =n}       If it isn't a palindrome, keep going
                  uSP    Run until palindrome reached, then print output number

05AB1E , 7 bytes (no competitivos)

No competitiva , ya que el lenguaje es posterior al desafío.

Código:

[DÂQ#Â+

Explicación:

[        # Infinite loop.
 DÂ      # Duplicate and bifurcate (which duplicates it and reverses the duplicate).
   Q#    # If the number and the number reversed are equal, break.
     Â+  # Add the reversed number to the initial number.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

Brachylog , 8 bytes

↔?|↔;?+↰

Pruébalo en línea!

Algo similar a uno de los primeros programas de Brachylog que vi y que me intrigó, del video introductorio de Brachylog .

?↔?.|↔;?+↰.  (initial ? and the .s are implicit)

?↔?          % If the input and its reverse are the same,
   .         %   then the input is the output
    |↔;?+↰   % Or, add the input and its reverse, and call this predicate recursively
          .  % The result of that is the output

PHP - 54 48 caracteres

<?for($s=`cat`;$s!=$r=strrev($s);$s+=$r);echo$s;

Prueba:

$ php 196.php <<< 5280
23232

Golpe (64)

X=`rev<<<$1|sed s/^0*//`;[ $1 = $X ]&&echo $1||. $0 $(($1+$X))

Llamar con: bash <nombre de archivo> <número>

C # - 103 99 caracteres

public int P(int i)
{
    var r = int.Parse(new string(i.ToString().Reverse().ToArray())));
    return r == i ? i : P(i + r);        
}

C # nunca funciona muy bien en el golf. Elegante, pero detallado.

En Q (39 caracteres)

f:{while[x<>g:"I"$reverse -3!x;x+:g];x}

Uso de muestra:

q)f 5280
23232

Editar:

Hasta 34 ahora, mismo uso:

{while[x<>g:"I"$(|) -3!x;x+:g];x} 5280

r=input()
while 1:
    r=`r`
    if r==r[::-1]:
      break
    else:
      r=int(r)+int(r[::-1])

print r

Gelatina , 9 bytes (no competitiva)

Una respuesta muy simple, solo para el desafío de la codificación y el lenguaje esotérico.

ṚḌ+µŒḂ¬$¿

ṚḌ        : take the argument, reverse (and vectorize) it
  +µ      : add both
    ŒḂ¬$¿ : while the result isn't a palindrome

Pruébalo en línea!

Si esta respuesta no es clara o incorrecta en algún nivel, no dude en señalarla.

Gracias a Dennis por ayudarme con este primer pequeño código.

Pitón. 85 caracteres:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n));print n

Si no desea resultados en cada iteración:

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n))
print n

(un personaje menos)

Windows PowerShell (63)

for($a=+"$input";-join"$a"[99..0]-ne$a){$a+=-join"$a"[99..0]}$a

Todavía odio que no haya una manera fácil de invertir una cadena.

Haskell 89 87 caracteres

r=read.reverse.show
main=getLine>>=print.head.filter(\x->x==r x).iterate(\x->x+r x).read

Versión algo legible:

myFind p = head . filter p
rev = read . reverse . show
isPalindrome x = x == rev x
next x = x + rev x
sequence196 = iterate next
palindrome196 = myFind isPalindrome . sequence196

main = getLine >>= print . palindrome196 . read

La versión de golf fue creada mediante la incorporación manual y el cambio de nombre de las funciones restantes a nombres de caracteres individuales.

befunge, 57 bytes

"KCTS"4(&:0\v
\T\a*+\:0`jv>:a%\a/
0:+_v#-TD2$<^\
  @.<

aunque el código se coloca en una cuadrícula de 4x19, podría llamarse 76.

• la primera línea se está inicializando y leyendo el número de entrada
• la segunda línea invierte el primer número en la pila y lo coloca en la segunda posición de la pila.
• y la tercera línea verifica si un número es palíndromo.

C ++ TMP (256 caracteres)

#include<cstdio>
#define Y(A,B,C,D)template<int N>struct A<C,D>{enum{v=B};};
#define Z(A)template<int N,int M>struct A{enum{v=
#define n 5194
Z(R)R<N/10,M*10+N%10>::v};};Y(R,N,0,N)Z(S)S<N+M,R<N+M,0>::v>::v};};Y(S,N,N,N)main(){printf("%d",S<n+R<n,0>::v,0>::v);}

Esta versión podría acortarse un poco, pero es difícil dejar pasar una respuesta de 256 caracteres. Aquí hay una versión sin golf:

#include <iostream>

template<size_t N>
class Reverse
{
    template<size_t M, size_t R>
    struct Inner
    {
        enum { value = Inner<M/10, R*10 + M%10>::value };
    };

    template<size_t R>
    struct Inner<0, R>
    {
        enum { value = R };
    };

public:
    enum { value = Inner<N, 0>::value };
};

template<size_t N>
class OneNineSix
{
    template<size_t M, size_t R=Reverse<M>::value>
    struct Inner
    {
        enum { value = OneNineSix<M + R>::value };
    };

    template<size_t M>
    struct Inner<M, M>
    {
        enum { value = M };
    };

public:
    enum { value = Inner<N + Reverse<N>::value>::value };
};

int main()
{
    const size_t N = 4123;

    std::cout << OneNineSix<N>::value << std::endl;
}

Pyke, 13 bytes (sin competencia)

D`_b]D$XIsr)h

Pruébalo aquí!

 `_b          -     int(reversed(str(num))
D   ]         -    [num, ^]
     D        -   _ = ^
      $       -  delta(^)
       XI     - if ^:
         s    -  num = sum(_)
          r   -  goto_start()
            h - _[0]

Agregar ++ , 57 bytes

L,BDbRBv
D,f,@,1]A+
D,g,@,1]A=
D,h,@,{f}A{g}Q{h}
L,{h}2/i

Pruébalo en línea!

Cómo funciona

L,	; Create a function 'lambda 1'
	; Example argument:   [5280]
    BD	; Digits;     STACK = [[5 2 8 0]]
    bR	; Reverse;    STACK = [[0 8 2 5]]
    Bv	; Undigits;   STACK = [825]

D,f,@,	; Define a monadic function 'f'
	; Example argument:         [5280]
    1]	; Call 'lambda 1';  STACK = [825]
    A+	; Add the argument; STACK = [6105]

D,g,@,	; Define a monadic function 'g'
	; Example argument:          [5280]
    1]	; Call 'lambda 1';   STACK = [825]
    A=	; Equal to argument; STACK = [0]

D,h,@,	; Define a monadic function 'h'
	; Example argument:  [5280]
   {f}	; Call 'f';  STACK = [6105]
   A{g}	; If 'g'...
   Q	;   Return
   {h}	; Else call 'h'

L,	; Define a function, 'lambda 2'
	; Example argument: [5280]
   {h}	; Call 'h'; STACK = [46464]
   2/i	; Halve;    STACK = [23232]

Powershell, 63 62 bytes

-1 byte gracias a @AdmBorkBork

param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s

Script de prueba:

$f = {
param($m)for(;$m-$s;$m=-join"$s"[-1..-"$s".Length]){$s+=$m};$s
}

&$f 5280

GNU dc, 46 bytes

Requiere GNU dc, min versión 1.4 (para Rcomando).

[O~3RO*+rd0<R]sR[+lfx]sg[ddO~rd0<R+d3R!=g]dsfx

La entrada y la salida son las mejores, como de costumbre. Se necesita una cantidad sorprendente de código para invertir los dígitos en CC (a menos que me falte algo, lo que está lejos de ser imposible). Tiene el rango numérico para comportarse bien con entradas como estas (que desbordarán la aritmética sin signo de 32 bits, por ejemplo):

• 89 ⇒ 8.813.200.023.188
• 8997 ⇒ 16,668,488,486,661
• 10677 ⇒ 4,668,731,596,684,224,866,951,378,664

Explicación

# Reverse digits, starting after first digit extracted
[O~3RO*+r d0<R]sR

# Recursion helper - add and recurse
[+ lfx]sg

# Main recursive function
[dd O~r d0<R+ d3R !=g]dsfx

R , 193 109 105 bytes

-84 bytes gracias a Giuseppe! -4 adios gracias a JayCe!

function(x){"-"=utf8ToInt
S=strtoi
"!"=rev
while({z=paste(S(x)+S(intToUtf8(!-x),10));any(-z!=!-z)})x=z
z}

Pruébalo en línea!