Scrivi un breve programma per l' algoritmo 196 . L'algoritmo inizia da un numero intero, quindi aggiunge il suo contrario fino a raggiungere un palindromo.

per esempio

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

Ingresso

un numero intero, che non è un numero di lyrchrel (ovvero, alla fine produce un palindromo sotto questo algoritmo, piuttosto che continuare all'infinito)

Produzione

raggiunto il palindromo.

APL (22 caratteri)

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

Questo funziona in Dyalog APL. Ecco una spiegazione, da destra a sinistra:

• { ... }⍞: Ottieni input dall'utente come caratteri ( ⍞) e invialo alla nostra funzione ({ ... } ).
• All'interno della funzione diretta ( ⋄separa le istruzioni, quindi le guardiamo da sinistra a destra):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Evaluate ( ⍎) l'argomento giusto ( ⍵) reverse ( ⌽), e aggiungilo alla versione valutata dell'argomento giusto stesso. Quindi, formatta il risultato ( ⍕; cioè, dai la sua rappresentazione del carattere), assegna ( ←) quello alla variabile ae infine verifica se ail contrario è equivalente a a(cioè, è aun palindromo?). Se vero, ritorna a; altrimenti...
  • ∇a: aRitorna alla nostra funzione ( ∇è autorevole riferimento implicito).

Esempio:

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

GolfScript, 29 caratteri

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

Commento selezionato

La carne del programma è il dociclo, ovviamente. Quindi lo coprirò e basta.

1. .` copia il numero e lo stringe.
2. .-1% copia quella versione di stringa e la inverte.
3. .@ copia la versione invertita e porta in primo piano la versione originale non invertita.

Così, per esempio, il numero è 5280. In questa fase, lo stack è: 5280 "0825" "0825" "5280". Il palcoscenico è pronto per il confronto. (Dopo il confronto, la pila rimarrà a 5280 "0825"prescindere da cosa --- gli oggetti da confrontare sono stati saltati fuori.)

1. Se la stringa e il contrario sono uguali, non ci importa della stringa invertita, quindi basta aprirla ( ;) e restituire 0 (per terminare il dociclo).
2. Se non corrispondono, quindi valuta ( ~) la stringa invertita (per renderla un numero), aggiungi ( +) quella al numero originale e restituisci 1 (per continuare il dociclo).

Python 2, 55 byte

Seguendo il suggerimento di 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

Rubino - 56 caratteri

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

Sto solo esercitando le mie abilità in Pyth, non un serio contendente.

Pyth, 16 byte

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 byte

CJam è stato creato dopo che questa domanda è stata posta, quindi tecnicamente si tratta di un invio non valido. Ma ho trovato la domanda interessante, quindi ecco qui:

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

Spiegazione:

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 logica di base è che in ogni iterazione mentre si fa, si controlla innanzitutto se il palindromo viene raggiunto o meno. In caso contrario, aggiungere il numero inverso al numero. Praticamente qual è l'algoritmo!

Provalo online qui

Questo è un vero contendente, dato che J esiste da decenni.

J (16 byte)

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

Questo è un verbo, quindi può essere assegnato a una variabile in una sessione J e utilizzato in questo modo:

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

Come funziona:

(+^:~:|.&.":)^:_
 +^:~:           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 caratteri

$_=<>;$_+=$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

Non contendere , sto solo facendo esperienza con la mia lingua. Si
aspetta un numero dallo stdin

T~d{DddgCi+dgdC=n}uSP

Spiegazione

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 byte (non concorrenti)

Non competitiva , poiché la lingua postdatizza la sfida.

Codice:

[DÂQ#Â+

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! .

Brachylog , 8 byte

↔?|↔;?+↰

Provalo online!

Un po 'simile a uno dei primi programmi di Brachylog che ho visto ed è stato incuriosito dal video introduttivo di 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 caratteri

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

Test:

$ php 196.php <<< 5280
23232

Bash (64)

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

Chiama con: bash <nomefile> <numero>

C # - 103 99 caratteri

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

C # non fa mai molto bene nel golf. Elegante, ma prolisso.

In Q (39 caratteri)

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

Esempio di utilizzo:

q)f 5280
23232

Modificare:

Fino a 34 ora, stesso utilizzo:

{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 byte (non competitiva)

Una risposta molto semplice, solo per la sfida della codifica e del linguaggio esoterico.

ṚḌ+µŒḂ¬$¿

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

Provalo online!

Se questa risposta non fosse chiara o sbagliata a qualsiasi livello, sentitevi liberi di segnalarla.

Grazie a Dennis per avermi aiutato con questo primo piccolo pezzo di codice.

Pitone. 85 caratteri:

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 non si desidera output su ogni iterazione:

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 personaggio in meno)

Windows PowerShell (63)

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

Lo odio ancora che non esiste un modo semplice per invertire una stringa.

Haskell 89 87 caratteri

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

Versione un po 'leggibile:

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 versione giocata a golf è stata creata inserendo manualmente e rinominando le restanti funzioni con nomi di singoli personaggi.

befunge, 57 byte

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

sebbene il codice sia inserito in una griglia 4x19, quindi potrebbe chiamarlo 76.

• la prima riga è l'inizializzazione e la lettura del numero di input
• la seconda riga inverte il primo numero nello stack e lo mette nella seconda posizione dello stack.
• e la terza riga controlla se un numero è palindromo.

C ++ TMP (256 caratteri)

#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);}

Questa versione potrebbe essere abbreviata un po ', ma è difficile passare una risposta di 256 caratteri. Ecco una versione senza 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 byte (non competitivo)

D`_b]D$XIsr)h

Provalo qui!

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

Aggiungi ++ , 57 byte

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

Provalo online!

Come funziona

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 byte

-1 byte grazie a @AdmBorkBork

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

Script di prova:

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

&$f 5280

GNU cc, 46 byte

Richiede GNU dc, versione minima 1.4 (per Rcomando).

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

Input e output sono al top, come al solito. Ci vuole una quantità sorprendente di codice per invertire le cifre in cc (a meno che non mi manchi qualcosa, il che è tutt'altro che impossibile). Ha un intervallo numerico per comportarsi bene con input come questi (che traboccerà, ad esempio, l'aritmetica senza segno a 32 bit):

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

Spiegazione

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

-84 byte grazie a Giuseppe! -4 ciao grazie a JayCe!

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

Provalo online!