挑战说明

让我们取一个正整数n，反转其数字以获得rev(n)并获得这两个数字之差的绝对值：（|n - rev(n)|或abs(n - rev(n))）。

例：

n = 5067 
rev(n) = 7605
|n - rev(n)| = |5067 - 7605| = |-2538| = 2538

重复多次此操作后，大多数数字将变为 0（从而终止循环）...

5067 -> 2538 -> 5814 -> 1629 -> 7632 -> 5265 -> 360 -> 297 -> 495 -> 99 -> 0

...虽然有些数字（例如 1584）陷入了无限循环：

1584 -> 3267 -> 4356 -> 2178 -> 6534 -> 2178 -> 6534 -> 2178 -> 6534 -> ...
                        ^ infinite loop starts here

您的工作是确定给定的整数是否陷入无限循环。

输入说明

一个正整数。

输出说明

如果数字陷入无限循环，则为真值（True，1），否则为假值（False，0），否则。

笔记

• 尾随零应被忽略。即rev(5020) = 205。
• 请记住，这是代码高尔夫，所以请使代码尽可能短！
• 相关序列：A072140

Pyth，5个字节

4字节归功于FryAmTheEggman

uas_`

测试套件。

真实值是循环中的数字之一。

假值是0。

说明

uas_`      Input:Q
uas_`GGQ   Implicit filling of variables.

u      Q   Set G as Q: do this repeatedly until result seen before: Set G as
 a             the absolute difference of
     G             G
    `              convert to string
   _               reverse
  s                convert to integer
      G        and G

Mathematica，39 37字节

Nest[Abs[#-IntegerReverse@#]&,#,#]<1&

只需将逆/减变换n时间应用于输入n，然后检查结果是否为0。10n达到循环绝不会花多于几步的时间，因为转换不能增加位数，并且少于10n位数的位数少于n。请参阅Dennis的证明以了解如何减少此约束n。

果冻，6 5 字节

ṚḌạµ¡

在线尝试！

背景

它使用@ MartinEnder上界的10N迭代和以下意见。

1. 有9×10 ^k-1个具有k位数字的正整数n。

2. 数字和它的反向的差始终是9的倍数，因此在第一次迭代之后只能出现10 ^k-1个数字。

3. 在倍数中，超过 1/10的数字将在下一次迭代中丢失（对于初学者，所有以相同数字开头和结尾的数字，如果第一个数字既不是1也不是9，则大约是其两倍），因此进入循环或丢失数字最多需要9×10 ^k-2。

4. 将相同的推理应用于最终得到的k-1位整数，依此类推，最多需要9×10 ^k-2 + 9×10 ^k-2 +…≤10 ^k- 1≤n次迭代才能进入循环或达到0。

怎么运行的

ṚḌạµ¡  Main link. Argument: n

   µ¡  Iteratively apply the chain to the left n times.
Ṛ      Reverse n (casts to digits).
 Ḍ     Undecimal; convert from base 10 to integer.
  ạ    Take the absolute difference of the result and the argument.

Oracle SQL 11.2，136字节

WITH v(n)AS(SELECT :1 FROM DUAL UNION ALL SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0)CYCLE n SET c TO 0 DEFAULT 1 SELECT MIN(c)FROM v;

未打高尔夫球

WITH v(n) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
  SELECT ABS(n-REVERSE(n||''))FROM v WHERE n>0 
) CYCLE n SET c TO 0 DEFAULT 1
SELECT MIN(c)FROM v

APL，26个字符

0∘{⍵∊⍺:×⍵⋄(⍺,⍵)∇|⍵-⍎⌽⍕⍵}

我们使用left参数作为我们已经看到的值的累加器。我们将其初始化为“ 0”，这是两个终止条件之一。警卫的意思⍵∊⍺:×⍵是：“正确的参数是我们已经看到的（并且包括零）吗？如果是，则返回数字的符号，即1或0”。否则，在将当前值连接到左参数之后，通过减去的绝对值来调用自己，从而递归。

马丁·恩德（Martin Ender）对Mathematica解决方案的重铸将花费21个字符：

 {×{|⍵-⍎⌽⍕⍵}⍣(10×⍵)⊣⍵}

内容为：“应用所需的10n次后，结果的符号是什么？”？

Python 2，50个字节

n=input()
exec'n=abs(n-int(`n`[::-1]));'*n
print n

在Ideone上进行测试。

背景

它使用@ MartinEnder上界的10N迭代和以下意见。

1. 有9×10 ^k-1个具有k位数字的正整数n。

2. 数字和它的反向的差始终是9的倍数，因此在第一次迭代之后只能出现10 ^k-1个数字。

3. 在倍数中，超过 1/10的数字将在下一次迭代中丢失（对于初学者，所有以相同数字开头和结尾的数字，如果第一个数字既不是1也不是9，则大约是其两倍），因此进入循环或丢失数字最多需要9×10 ^k-2。

4. 将相同的推理应用于最终的k-1位整数等，以此类推，最多需要9×10 ^k-2 + 9×10 ^k-2 +…≤10 ^k- 1≤n次迭代才能进入循环或达到0。

CJam，15 13字节

ri_{_sW%i-z}*

在这里测试。

与我的Mathematica答案相同。

Python中，129 120 96字节

如果捕获到异常（由于无限递归，此函数通常会抛出的唯一异常是RuntimeError），则打印1。否则，打印结果0。

def r(n):a=abs(n-int(str(n)[::-1]));return a and r(a)
try:print(r(int(input())))
except:print(1)

感谢@LeakyNun
感谢@shooqie

Python，101 98字节

乌龟和野兔算法。

真值是循环中的任何值，假值是0。

g=lambda n:abs(n-int(str(n)[::-1]))
def r(n):
    t=g(n);h=g(t)
    while t-h:h=g(g(h));t=g(t)
    return h

伊迪恩！

Python 2，85 84 83字节

L=[]
def f(n,L=L):
    if n<1or n in L:print n<1
    else:L+=[n];f(abs(n-int(`n`[::-1])))

另一个Python答案。它将为每个迭代将n添加到列表中，如果n已经在列表中，则输出False。否则，它将降低到0。

感谢@NonlinearFruit一个字节。

05AB1E，11 8 6字节

DFÂï-Ä

讲解

DF          # input number of times do
  Â         # push current number and its reverse
   ï-       # convert reverse to int and subtract
     Ä      # absolute value
            # implicitly print after loop ends

真实值是循环中的数字。
虚假值为0。

在线尝试

使用Dennis的果冻答案中解释的上限

@Adnan节省了2个字节

在05AB1E的7.9版中，按@Adnan所述，以下5字节解决方案有效

DFÂ-Ä

Java 7，161字节

这需要导入，但是我将其编写为函数。如果在这种情况下首选完整程序，请在评论中对我大喊。如果存在无限循环，则输出1；如果值变为0，则输出0。

import java.util.*;int z(int a){int o,r,c=a;Set s=new HashSet();while(c!=0){for(r=0,o=c;o!=0;r=r*10+o%10,o/=10);c=Math.abs(c-r);if(!s.add(c))return 1;}return 0;}

Brachylog，49 32 23字节

:10*N,?:N:{r:?-+.}itT'0

返回true无限循环，false否则返回。

这是Martin Ender算法的无耻修改。

上一个答案，32个字节

g{tTr:T-+U(0!\;?:ImU;?:[U]c:1&)}

先前答案的解释

g{                             } Call predicate with [Input] as input
  tT                             T is the last element of Input
    r:T-                         Subtract T from the reverse of T
        +U                       U is the absolute value of T
          (0!\                   If U is 0, return false
              ;                  Or
               ?:ImU             If U is in Input, return true
                    ;            Or
                     ?:[U]c:1&)  Recursive call with U concatenated to the Input

PowerShell v2 +，94个字节

param($n)for($a=,0;){if(($n=[math]::Abs($n-(-join"$n"["$n".length..0])))-in$a){$n;exit}$a+=$n}

接受input $n，开始一个无限for循环，$a=,0其初始条件为（使用逗号运算符将其设置$a为一个元素的数组0）。这$a是我们已经看到的值的数组。

每次循环迭代时，我们都会检查一个if。该条件首先设置$n使用字符串反转和[math]::Abs.NET调用的下一个值，并检查该值是否已经-in $a。如果是这样，我们输出$n和exit。否则，我们将该值添加到数组并继续循环。

输出0不会进入无限循环的输入值（在PowerShell中为false），否则将输出遇到循环的值（非零整数为true）。例如，输入2178的输出1584。

Haskell，65个字节

_#0=0
a#n|elem n a=1|1<2=(n:a)#abs(n-(read$reverse$show n))
([]#)

返回0False和1True。用法示例：([]#) 1584 -> 1。

最明显的方法是：列出到目前为止已看到的所有结果。计算下一个数字，直到0或它在列表中。

JavaScript（ES6），75个字节

f=(n,...a)=>a.includes(n=n<0?-n:n)?n:f([...n+``].reverse().join``-n,n,...a)

n<0?n=-n:n并且n*=n>0||-1还工作。尽管这是递归公式，但算法在某种程度上类似于PowerShell的答案。

Ruby，57个字节

->n,*h{h[n]=n=(n-"#{n}".reverse.to_i).abs until h[n];n>0}

最初为空的数组将h跟踪先前命中的值。我们迭代该数字，直到达到前一个值，然后在最后一次迭代中检查该值。由于0是一个1的周期，因此，当且仅当没有更大的周期时，它才会为0。我花了额外的2个字节将其转换为布尔值，因为在Ruby中0是正确的。

Perl 6  58 53 33  30字节

sub {$/=%;$^a,{return ?1 if $/{$_}++;abs $_-.flip}...0;?0}
{$/=%;?($_,{last if $/{$_}++;abs $_-.flip}...0)[*-1]}
{?($_,{abs $_-.flip}...0)[10**$_]}

{?($_,{abs $_-.flip}...0)[$_]}

说明：

{ # block lambda with implicit parameter $_

  # coerce the following to Bool
  # ( False for Nil or 0, True otherwise )
  ?

  (

    $_, # start a sequence with the input

    # block lambda with implicit parameter $_
    # subtracts the previous value in the sequence and its reverse
    # ( .flip is short for $_.flip where a term is expected )
    { abs $_ - .flip } 

    ... # repeat that lambda
    0   # until you get 0

  # get the element indexed with the block's input
  # may be 0, Nil, or a number that is part of a repeating sequence
  )[ $_ ]
}

（根据之前的观察，您最多只需要执行此转换n）

Perl 5中，31 29个字节

perl -pe'for$x(1..$_){$_=abs$_-reverse}'

perl -pe'eval"\$_=abs\$_-reverse;"x$_'

迭代 n=|n-rev(n)| n次，因此如果没有循环，则输出为0，否则为> 0。丹尼斯已经证明这足够了。

新版本使用eval和x重复运算符而不是for循环。

Matlab，89 84字节

n=input('');z=n;while n
z=abs(z-str2num(fliplr(num2str(z))));n=[n z]*all(n~=z);end
z

简单方法-堆叠所有数字并检查数字是否出现在前面。

说明

n=input('');z=n;  -- take input, initiate z
while n           -- n is said to be positive
z=abs(z-str2num(fliplr(num2str(z)))) -- calculate the "reverse and substract"
n=[n z]           -- put the value at the end of the vector
       *all(n~=z) -- make the n all zeroes if z is previously in the vector (break the loop)
end
z                 -- print z (0 when not entered loop, >0 otherwise)