Schreiben Sie ein kurzes Programm für den 196-Algorithmus . Der Algorithmus beginnt mit einer Ganzzahl und fügt ihr das Gegenteil hinzu, bis ein Palindrom erreicht ist.

z.B

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

Eingang

eine Ganzzahl, die keine Lyrchrel-Zahl ist (das heißt, sie ergibt unter diesem Algorithmus letztendlich ein Palindrom, anstatt unendlich fortzufahren )

Ausgabe

das Palindrom erreichte.

APL (22 Zeichen)

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

Dies funktioniert in Dyalog APL. Hier ist eine Erklärung von rechts nach links:

• { ... }⍞: Holen Sie sich Eingaben vom Benutzer als Zeichen ( ⍞) und geben Sie diese an unsere Funktion ( { ... }) weiter.
• Innerhalb der direkten Funktion ( ⋄trennt Anweisungen, so dass wir sie von links nach rechts betrachten):
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a: Evaluiere ( ⍎) das ⍵reverse ( ) des richtigen Arguments ⌽und füge das zur evaluierten Version des richtigen Arguments hinzu. Formatieren Sie dann das Ergebnis ( ⍕dh geben Sie seine Zeichendarstellung an), weisen Sie ←es der Variablen zu ( ) a, und testen Sie schließlich, ob adie Umkehrung äquivalent ist a(dh ist es aein Palindrom?). Wenn wahr, kehre zurück a; Andernfalls...
  • ∇a: Rückmeldung ain unsere Funktion ( ∇implizite Selbstreferenz).

Beispiel:

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

GolfScript, 29 Zeichen

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

Ausgewählter Kommentar

Das Fleisch des Programms ist donatürlich die Schleife. Also werde ich mich nur darum kümmern.

1. .` kopiert die Nummer und fasst sie zusammen.
2. .-1% kopiert diese String-Version und kehrt sie um.
3. .@ kopiert die umgekehrte Version und bringt die ursprüngliche nicht umgekehrte Version nach vorne.

Also, sagen wir, ist die Zahl 5280. In diesem Stadium ist der Stapel: 5280 "0825" "0825" "5280". Die Bühne für den Vergleich ist bereit. (Nach dem Vergleich bleibt der Stapel, 5280 "0825"egal was passiert - die zu vergleichenden Objekte wurden entfernt.)

1. Wenn die Zeichenfolge und die Umkehrung gleich sind, interessiert uns die umgekehrte Zeichenfolge nicht. Legen Sie sie einfach ab ( ;) und geben Sie 0 zurück (um die doSchleife zu beenden ).
2. Wenn sie nicht übereinstimmen, werte ( ~) den umgekehrten String aus (um ihn zu einer Zahl zu machen), addiere ( +) diesen zur ursprünglichen Zahl und gib 1 zurück (um die doSchleife fortzusetzen ).

Python 2, 55 Bytes

Folgender JPvdMerwe-Vorschlag:

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 Zeichen

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

Ich trainiere nur meine Pyth-Fähigkeiten, kein ernsthafter Anwärter.

Pyth, 16 Bytes

L?bqb_by`+vbi_bTyz

Entspricht 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 wurde erstellt, nachdem diese Frage gestellt wurde. Aus technischen Gründen handelt es sich also um eine ungültige Übermittlung. Aber ich fand die Frage interessant, also hier geht:

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

Erläuterung:

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

Die Kernlogik ist, dass Sie bei jeder Wiederholung zuerst prüfen, ob Palindrom erreicht ist oder nicht. Wenn nicht, addieren Sie die Umkehrung zur Zahl. Ziemlich genau, was der Algorithmus ist!

Probieren Sie es hier online aus

Dies ist ein echter Konkurrent, da es J schon seit Jahrzehnten gibt.

J (16 Bytes)

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

Dies ist ein Verb, daher kann es in einer J-Sitzung einer Variablen zugewiesen und folgendermaßen verwendet werden:

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

Wie es funktioniert:

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

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

Nicht streiten , nur
ein bisschenErfahrung mit meiner Sprache.Erwartet eine Nummer von stdin

T~d{DddgCi+dgdC=n}uSP

Erläuterung

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 (nicht konkurrierend)

Nicht konkurrierend , da die Sprache die Herausforderung datiert.

Code:

[DÂQ#Â+

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

Brachylog , 8 Bytes

↔?|↔;?+↰

Probieren Sie es online!

Etwas ähnlich wie eines der ersten Brachylog-Programme, das mir auf dem Brachylog-Einführungsvideo aufgefallen ist und von dem ich fasziniert war .

?↔?.|↔;?+↰.  (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 Zeichen

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

Prüfung:

$ php 196.php <<< 5280
23232

Bash (64)

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

Rufen Sie mit: bash <Dateiname> <Nummer> auf

C # - 103 99 Zeichen

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

C # macht sich im Golf nie besonders gut. Elegant, aber wortreich.

In Q (39 Zeichen)

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

Beispielnutzung:

q)f 5280
23232

Bearbeiten:

Bis jetzt 34, gleiche Verwendung:

{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

Jelly , 9 Bytes (nicht konkurrierend)

Eine sehr einfache Antwort, nur für die Herausforderung der Codierung in und esoterischer Sprache.

ṚḌ+µŒḂ¬$¿

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

Probieren Sie es online!

Sollte diese Antwort auf irgendeiner Ebene unklar oder falsch sein, können Sie sie gerne darauf hinweisen.

Vielen Dank an Dennis, der mir bei diesem ersten kleinen Stück Code geholfen hat.

Python. 85 Zeichen:

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

Wenn Sie nicht bei jeder Iteration eine Ausgabe wünschen:

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

(ein Zeichen weniger)

Windows PowerShell (63)

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

Ich hasse es immer noch, dass es keine einfache Möglichkeit gibt, eine Saite umzukehren.

Haskell 89 87 Zeichen

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

Etwas lesbare Version:

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

Die Golf-Version wurde durch manuelles Inlinen und Umbenennen der restlichen Funktionen in Einzelzeichennamen erstellt.

befunge, 57 bytes

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

Obwohl sich der Code in einem 4x19-Raster befindet, könnte man ihn 76 nennen.

• Die erste Zeile wird initialisiert und die eingegebene Nummer gelesen
• Die zweite Zeile kehrt die erste Zahl im Stapel um und legt sie in die zweite Stapelposition.
• und die dritte Zeile prüft, ob eine Zahl palindrom ist.

C ++ TMP (256 Zeichen)

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

Diese Version könnte etwas gekürzt werden, aber eine 256-stellige Antwort ist schwer zu übersehen. Hier ist eine nicht golfene Version:

#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 (nicht konkurrierend)

D`_b]D$XIsr)h

Probieren Sie es hier aus!

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

Add ++ , 57 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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 dank @AdmBorkBork

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

Testskript:

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

&$f 5280

GNU DC, 46 Bytes

Benötigt GNU dc, min Version 1.4 (für RBefehl).

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

Input und Output sind wie gewohnt top of stack. Es ist erstaunlich viel Code erforderlich, um die Ziffern in dc umzukehren (es sei denn, mir fehlt etwas, was bei weitem nicht unmöglich ist). Es hat den numerischen Bereich, um sich bei Eingaben wie diesen gut zu verhalten (die beispielsweise 32-Bit-Arithmetik ohne Vorzeichen überlaufen):

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

Erläuterung

# 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 dank Giuseppe! -4 byes danke an JayCe!

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

Probieren Sie es online!