Escreva um programa curto para o algoritmo 196 . O algoritmo inicia a partir de um número inteiro e adiciona seu reverso até que um palíndromo seja atingido.

por exemplo

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

Entrada

um número inteiro, que não é um número lyrchrel (ou seja, acaba produzindo um palíndromo sob esse algoritmo, em vez de continuar infinitamente)

Saída

o palíndromo chegou.

APL (22 caracteres)

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

Isso funciona no Dyalog APL. Aqui está uma explicação, da direita para a esquerda:

• { ... }⍞: Obtenha a entrada do usuário como caracteres ( ⍞) e alimente-a em nossa função ( { ... }).
• Dentro da função direta ( ⋄separa as instruções, então as olhamos da esquerda para a direita):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Avalie ( ⍎) o argumento correto ( ⍵) reverse ( ⌽) e adicione-o à versão avaliada do próprio argumento correto. Em seguida, formate o resultado ( ⍕; ou seja, forneça sua representação de caractere), atribua ( ←) isso à variável ae finalmente teste se ao inverso é equivalente a a(ou seja, é aum palíndromo?). Se verdadeiro, retorne a; de outra forma...
  • ∇a: Retroalimenta anossa função ( ∇é auto-referência implícita).

Exemplo:

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

GolfScript, 29 caracteres

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

Comentário selecionado

A carne do programa é o dolaço, é claro. Então, eu vou cobrir isso.

1. .` copia o número e o estrita.
2. .-1% copia essa versão da string e a reverte.
3. .@ copia a versão invertida e traz a versão não invertida original para a frente.

Assim, por exemplo, o número é 5280. Nesta fase, a pilha é: 5280 "0825" "0825" "5280". O cenário está pronto para a comparação. (Após a comparação, a pilha será deixada, 5280 "0825"independentemente do que --- os itens a serem comparados foram removidos.)

1. Se a string e o reverso forem os mesmos, não nos importamos com a string invertida, então apenas desative-a ( ;) e retorne 0 (para finalizar o doloop).
2. Se eles não corresponderem, avalie ( ~) a string invertida (para torná-la um número), adicione ( +) isso ao número original e retorne 1 (para continuar o doloop).

Python 2, 55 bytes

Seguindo a sugestão do 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

Apenas exercitando minhas habilidades de Pyth, não um candidato sério.

Pitão, 16 bytes

L?bqb_by`+vbi_bTyz

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

O CJam foi criado depois que essa pergunta foi feita, portanto, tecnicamente, é um envio inválido. Mas achei a pergunta interessante, então aqui vai:

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

Explicação:

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

A lógica principal é que, em cada iteração while-do, verifique primeiro se o palíndromo foi atingido ou não. Caso contrário, adicione o inverso ao número. Praticamente qual é o algoritmo!

Experimente online aqui

Este é um candidato real, já que J existe há décadas.

J (16 bytes)

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

Este é um verbo, portanto pode ser atribuído a uma variável em uma sessão J e usado da seguinte forma:

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

Como 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 com stdin

Não contendo , apenas obtendo alguma experiência com meu idioma
Espera um número de stdin

T~d{DddgCi+dgdC=n}uSP

Explicação

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 (não concorrente)

Não concorrente , uma vez que o idioma adia o desafio.

Código:

[DÂQ#Â+

Explicação:

[        # 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.

Usa a codificação CP-1252 . Experimente online! .

Braquilog , 8 bytes

↔?|↔;?+↰

Experimente online!

Um pouco semelhante a um dos primeiros programas Brachylog que eu vi e fiquei intrigado com, no vídeo de introdução do 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;

Teste:

$ php 196.php <<< 5280
23232

Festança (64)

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

Ligue com: bash <nome do arquivo> <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 se sai muito bem no golfe. Elegante, mas detalhado.

Em Q (39 caracteres)

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

Uso da amostra:

q)f 5280
23232

Editar:

Até 34 agora, o mesmo 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

Geléia , 9 bytes (não competindo)

Uma resposta muito simples, apenas para o desafio de codificação e linguagem esotérica.

ṚḌ+µŒḂ¬$¿

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

Experimente online!

Se esta resposta não estiver clara ou errada em qualquer nível, fique à vontade para apontá-la.

Agradeço ao Dennis por me ajudar com este primeiro pequeno pedaço de código.

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

Se você não deseja saída em cada iteração:

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

(menos um caractere)

Windows PowerShell (63)

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

Eu ainda odeio que não haja uma maneira fácil de reverter uma string.

Haskell 89 87 chars

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

Versão um pouco legível:

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

A versão para golfe foi criada inserindo manualmente e renomeando as funções restantes para nomes de caracteres únicos.

befunge, 57 bytes

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

embora o código esteja em uma grade 4x19, pode chamá-lo de 76.

• a primeira linha está inicializando e lendo o número de entrada
• segunda linha inverta o primeiro número na pilha e coloque-o na segunda posição da pilha.
• e a terceira linha verifica se um número é 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 versão pode ser um pouco reduzida, mas é difícil deixar uma resposta de 256 caracteres. Aqui está uma versão sem golfe:

#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 (não-competitivo)

D`_b]D$XIsr)h

Experimente aqui!

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

Adicionar ++ , 57 bytes

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

Experimente online!

Como 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 graças a @AdmBorkBork

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

Script de teste:

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

&$f 5280

GNU dc, 46 bytes

Requer GNU dc, versão mínima 1.4 (para Rcomando).

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

Entrada e saída estão no topo da pilha, como de costume. É preciso uma quantidade surpreendente de código para inverter dígitos em dc (a menos que esteja faltando alguma coisa, o que está longe de ser impossível). Ele possui o intervalo numérico para se comportar bem com entradas como essas (que excederão a aritmética não assinada de 32 bits, por exemplo):

• 89 ⇒ 8.813.200.023.188
• 8997 ⇒ 16.668.488.486.661
• 10677 ⇒ 4.668.731.596.684.224.866.951.378.664

Explicação

# 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 graças a Giuseppe! -4 byes graças a JayCe!

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

Experimente online!