Ecrivez un programme court pour 196 algorithmes . L'algorithme commence à un entier, puis ajoute son inverse jusqu'à atteindre un palindrome.

par exemple

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

Contribution

un entier, qui n'est pas un nombre de lyrchrel (c'est-à-dire qu'il finit par donner un palindrome sous cet algorithme, plutôt que de continuer indéfiniment)

Sortie

le palindrome atteint.

APL (22 caractères)

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

Cela fonctionne dans Dyalog APL. Voici une explication, de droite à gauche:

• { ... }⍞: Récupère les entrées de l'utilisateur sous forme de caractères ( ⍞) et les envoie à notre fonction ( { ... }).
• Dans la fonction directe ( ⋄instructions séparées, nous les regardons de gauche à droite):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Evaluate ( ⍎) l'argument de droite ( ⍵) reverse ( ⌽), et l'ajoute à la version évaluée de l'argument de droite lui-même. Ensuite, formatez le résultat ( ⍕; c’est-à-dire donnez la représentation de son caractère), attribuez ( ←) celle à la variable a, et enfin, testez si al’inverse est équivalent à a(c’est- à -dire qu’il s’agit d’ aun palindrome?). Si cela est vrai, retournez a; autrement...
  • ∇a: Feed aback dans notre fonction ( ∇est auto-référence implicite).

Exemple:

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

GolfScript, 29 caractères

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

Commentaire sélectionné

La viande du programme est la doboucle, bien sûr. Donc, je vais juste couvrir cela.

1. .` copie le nombre et le stratifié.
2. .-1% copie cette version de chaîne et l’inverse.
3. .@ copie la version inversée et place la version originale non inversée au premier plan.

Ainsi, par exemple, le nombre est 5280. A ce stade, la pile est: 5280 "0825" "0825" "5280". La scène est prête pour la comparaison. (Après la comparaison, la pile sera laissée à 5280 "0825"n'importe quoi --- les éléments à comparer ont été supprimés.)

1. Si la chaîne et l'inverse sont identiques, nous ne nous intéressons pas à la chaîne inversée, il suffit donc de la supprimer ( ;) et de renvoyer 0 (pour terminer la doboucle).
2. S'ils ne correspondent pas, alors évaluez ( ~) la chaîne inversée (pour en faire un nombre), ajoutez ( +) celle-ci au nombre d'origine et renvoyez 1 (pour continuer la doboucle).

Python 2, 55 octets

Suite à la suggestion 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 caractères

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

Juste exercer mes compétences en Pyth, pas un concurrent sérieux.

Pyth, 16 octets

L?bqb_by`+vbi_bTyz

Équivalent à 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 octets

CJam a été créé après que cette question a été posée, donc techniquement, c'est une soumission invalide. Mais j'ai trouvé la question intéressante, alors voici:

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

Explication:

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 logique de base est que dans chaque itération while-do, vous vérifiez d'abord si le palindrome est atteint ou non. Sinon, ajoutez l'inverse au numéro. Quasiment ce que l'algorithme est!

Essayez-le en ligne ici

C’est un véritable prétendant, puisque J existe depuis des décennies.

J (16 octets)

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

Ceci est un verbe, il peut donc être assigné à une variable dans une session J et utilisé comme ceci:

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

Comment ça marche:

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

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

Ne pas se disputer , juste acquérir de l'expérience avec ma langue
Attend un numéro de stdin

T~d{DddgCi+dgdC=n}uSP

Explication

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 octets (non concurrents)

Non compétitif , car la langue post-date le défi.

Code:

[DÂQ#Â+

Explication:

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

Utilise le codage CP-1252 . Essayez-le en ligne! .

Brachylog , 8 octets

↔?|↔;?+↰

Essayez-le en ligne!

Un peu similaire à l'un des premiers programmes Brachylog que j'ai vus et qui m'a intrigué, à partir de la vidéo d'introduction 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 caractères

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

Tester:

$ php 196.php <<< 5280
23232

Bash (64)

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

Appelez avec: bash <nomfichier> <numéro>

C # - 103 99 caractères

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

C # ne fait jamais très bien dans le golf. Élégant, mais prolixe.

En Q (39 caractères)

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

Exemple d'utilisation:

q)f 5280
23232

Modifier:

Jusqu'à 34 maintenant, même utilisation:

{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ée , 9 octets (non en compétition)

Une réponse très simple, juste pour le défi de coder en langage ésotérique.

ṚḌ+µŒḂ¬$¿

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

Essayez-le en ligne!

Si cette réponse n’est pas claire ou erronée à quelque niveau que ce soit, n’hésitez pas à la signaler.

Merci à Dennis de m'avoir aidé avec ce premier petit code.

Python. 85 caractères:

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 vous ne voulez pas de sortie à chaque itération:

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 personnage de moins)

Windows PowerShell (63)

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

Je déteste toujours qu'il n'y a pas de moyen facile d'inverser une chaîne.

Haskell 89 87 caractères

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

Version assez lisible:

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 version golfée a été créée manuellement en ajoutant et en renommant les fonctions restantes en noms à un seul caractère.

befunge, 57 bytes

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

bien que le code soit placé dans une grille 4x19, appelez-le 76.

• la première ligne est en cours d'initialisation et en lecture du numéro d'entrée
• deuxième ligne inverser le premier nombre dans la pile et le placer dans la deuxième position de pile.
• et la troisième ligne vérifie si un nombre est palindrome.

TMP C ++ (256 caractères)

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

Cette version pourrait être un peu raccourcie, mais il est difficile de laisser passer une réponse de 256 caractères. Voici une version non-golfée:

#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 octets (sans compétition)

D`_b]D$XIsr)h

Essayez-le ici!

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

Ajouter ++ , 57 octets

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

Essayez-le en ligne!

Comment ça marche

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 octets

-1 octet grâce à @AdmBorkBork

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

Script de test:

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

&$f 5280

GNU dc, 46 octets

Nécessite GNU dc, version min 1.4 (pour la Rcommande).

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

L'entrée et la sortie sont en haut de la pile, comme d'habitude. Il faut une quantité surprenante de code pour inverser les chiffres en courant continu (à moins que quelque chose ne me manque, ce qui est loin d'être impossible). Il a la plage numérique pour bien se comporter avec des entrées telles que celles-ci (qui débordent l'arithmétique 32 bits non signée, par exemple):

• 89 ⇒ 8 813 200 023 188
• 8997 ⇒ 16 668 488 486 661
• 10677 ⇒ 4 668 731 596 684 224 866 951 378 664

Explication

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

-84 octets grâce à Giuseppe! -4 byes grâce à JayCe!

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

Essayez-le en ligne!