为196算法编写一个简短的程序。该算法从整数开始，然后向其加反数，直到达到回文。

例如

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

输入项

一个不是lyrchrel数的整数（也就是说，在此算法下，它最终会产生回文，而不是无限地继续）

输出量

回文达到了。

APL（22个字符）

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

这在Dyalog APL中有效。这是从右到左的解释：

• { ... }⍞：从用户那里获得字符（⍞）的输入，并将其输入到我们的函数（{ ... }）中。
• 在直接函数中（⋄分隔语句，因此我们从左到右查看它们）：
  • a≡⌽a←⍕(⍎⍵)+⍎⌽⍵ : a：评估（⍎）正确的论点（⍵）反向（⌽），并将其添加到评估的正确论点本身。然后，格式化结果（⍕；即给出其字符表示形式），将其赋给←变量a，最后测试a'reverse是否等效于a（即a回文？）。如果为true，则返回a；除此以外...
  • ∇a：反馈a到我们的函数中（∇是隐式的自引用）。

例：

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

GolfScript，29个字符

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

精选评论

do当然，程序的核心是循环。所以我只介绍一下。

1. .` 复制数字并将其字符串化。
2. .-1% 复制该字符串版本并将其反转。
3. .@ 复制反向版本，并将原始非反向版本放在最前面。

因此，数字为5280。在此阶段，堆栈为：5280 "0825" "0825" "5280"。为进行比较设置了阶段。（比较之后，5280 "0825"无论如何都将保留堆栈---弹出要比较的项目。）

1. 如果字符串和反向字符串相同，则我们不在乎反向字符串，因此只需将其弹出（;）并返回0（以结束do循环）即可。
2. 如果不匹配，则求值（~）颠倒的字符串（使其成为数字），将（+）添加到原始数字，然后返回1（继续do循环）。

Python 2，55个字节

遵循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

红宝石-56个字符

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

仅锻炼我的Pyth技能，而不是认真的竞争者。

Pyth，16个字节

L?bqb_by`+vbi_bTyz

等同于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字节

CJam是在询问此问题后创建的，因此从技术上讲，它是无效的提交。但是我发现这个问题很有趣，所以去了：

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

说明：

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

核心逻辑是，在每次执行时迭代中，您首先要检查回文是否实现。如果没有，请在数字后加上反号。算法几乎是什么！

在这里在线尝试

这是一个真正的竞争者，因为J已经存在了数十年。

J（16个字节）

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

这是一个动词，因此可以将其分配给J会话中的变量，并按如下方式使用：

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

怎么运行的：

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

蟒蛇：66

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

Perl，40个字符

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

斯卡拉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 with stdin

不竞争，只是对我的语言有所了解，
期望stdin有一个数字

T~d{DddgCi+dgdC=n}uSP

说明

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个字节（非竞争）

不竞争，因为该语言推迟了挑战。

码：

[DÂQ#Â+

说明：

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

使用CP-1252编码。在线尝试！。

Brachylog，8个字节

↔?|↔;?+↰

在线尝试！

与Brachylog简介视频中我看到并感兴趣的第一个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个字符

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

测试：

$ php 196.php <<< 5280
23232

重击（64）

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

致电：bash <文件名> <号码>

C＃-103 99个字符

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

C＃在高尔夫领域从来没有做得很好。优雅，但冗长。

Q（39个字符）

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

用法示例：

q)f 5280
23232

编辑：

现在降至34，相同用法：

{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

果冻，9个字节（非竞争）

一个非常简单的答案，仅适用于以深奥的语言编码的挑战。

ṚḌ+µŒḂ¬$¿

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

在线尝试！

如果该答案在任何级别上都不明确或错误，请随时指出。

感谢Dennis为我提供了这第一小段代码。

蟒蛇。85个字符：

s,i=str,int;rs=lambda q:s(q)[::-1];n=i(input());
while rs(n)!=s(n):n+=i(rs(n));print 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

（少一个字符）

Windows PowerShell (63)

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

I still hate it that there is no easy way to reverse a string.

Haskell 89 87 chars

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

Somewhat readable 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

The golfed version was created by manual inlining and renaming the remaining functions to single character names.

befunge, 57 bytes

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

though the code is places in a 4x19 grid, so might call it 76.

• first line is initializeing, and reading input number
• second line reverse first number in stack and put it in the second stack position.
• and the third line checks if a number is palindrome.

C++ TMP (256 characters)

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

This version could be shortened a bit, but a 256-character answer is hard to pass up. Here's an un-golfed 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 (noncompeting)

D`_b]D$XIsr)h

Try it here!

 `_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

Try it online!

How it works

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 thanks to @AdmBorkBork

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

Test script:

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

&$f 5280

GNU dc, 46 bytes

Requires GNU dc, min version 1.4 (for R command).

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

Input and output are top-of-stack, as usual. It takes a surprising amount of code to reverse digits in dc (unless I'm missing something, which is far from impossible). It does have the numeric range to behave nicely with inputs such as these (which will overflow 32-bit unsigned arithmetic, for example):

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

Explanation

# 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 thanks to Giuseppe! -4 byes thanks to JayCe!

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

Try it online!