库兹涅佐夫的序列

(I made the name up, don't bother with Wikipedia or Google)

给定任何数字n > 0，令其r代表数字的倒数n。迭代直到最终结果为零，然后使用递归或您选择的方法通过执行以下操作将每次迭代的结果传递回函数中：

• 如果r > n对于该迭代，结果为r % n。
• 如果n > r对于该迭代，结果为n % r。
• 如果n % r = 0或r % n = 0，则终止迭代。

取每个执行的中间结果，并将它们存储在数组中以得到最终答案。初始编号n不是序列的一部分，也不是0；这些示例应该使所有内容都更加明显。

让我们来看一个例子n=32452345。

54325423 % 32452345 = 21873078 # r > n, uses r % n
87037812 % 21873078 = 21418578 # r > n, uses r % n
87581412 % 21418578 = 1907100  # r > n, uses r % n
1907100 % 17091 = 9999         # n > r, uses n % r
9999 % 9999 = 0                # r % n = n % r = 0, terminated

Result: [21873078, 21418578, 1907100, 9999]     

另一个例子n=12345678：

87654321 % 12345678 = 1234575 # r > n, uses r % n
5754321 % 1234575 = 816021    # r > n, uses r % n
816021 % 120618 = 92313       # n > r, uses n % r
92313 % 31329 = 29655         # n > r, uses n % r
55692 % 29655 = 26037         # r > n, uses r % n
73062 % 26037 = 20988         # r > n, uses r % n
88902 % 20988 = 4950          # r > n, uses r % n
4950 % 594 = 198              # n > r, uses n % r
891 % 198 = 99                # r > n, uses r % n
99 % 99 = 0                   # r % n = n % r = 0, terminated

Result: [1234575, 816021, 92313, 29655, 26037, 20988, 4950, 198, 99]

最后一个例子n=11000：

11000 % 11 = 0 # n % r = 0, terminated

Result: []

这是代码高尔夫球的最低字节数获胜。

05AB1E，11个字节

[‚{R`%Ð>#,

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

PowerShell v2 +，89字节

param($n)for(){$r=-join"$n"["$n".length..0];if(!($n=(($r%$n),($n%$r))[$n-gt$r])){exit}$n}

迭代解决方案。冗长，因为没有简单的方法可以反转数组，因此我们将其字符串化并向后索引以存储到中$r。然后是伪三元组，以提取适当的模并重新存储到$n下一轮。但是，如果结果为零，则表示!($n...)将为$true，所以我们选择exit而不是$n。这些数字保留在管道上，并（作为隐式）作为数组返回，但是如果没有封装管道或将结果保存到变量中，则默认值Write-Output之间会使用换行符。

在线尝试！（是的，非常严重。）
PowerShell现在在TIO上！你总得给它一个或两个二是因为PowerShell是一个野兽来启动，但是现在的你，是你，可以在浏览器验证PowerShell代码吧！

Perl，43 38 +1 = 39字节

用-n标志跑

say while$_=($;=reverse)>$_?$;%$_:$_%$

在线尝试！ 包括两个非空示例。

说明图

-n：将整个程序包装在中while(<>){ ... ;}。这会将上面的代码转换为以下行：while(<>){say while$_=($;=reverse)>$_?$;%$_:$_%$;}。注意，分号已添加到尾部$，因此它现在成为变量的实例$;。在while循环的情况下，<>自动读取一行输入并将其保存在$_变量中。现在，让我们看一下解释器在外while循环中读取的内容：

say while$_=($;=reverse)>$_?$;%$_:$_%$;
[op][mod][         condition          ]     #While is acting as a statement modifier.
                                            #It evaluates the operation as long as the condition is truthy.
            ($;=reverse)>$_?$;%$_:$_%$;     #The meat of the program: a ternary operation
            ($;=reverse)                    #The reverse function takes $_ as a parameter by default, and reverses the value.
                                            #The value returned by reverse is stored in the variable $;
                        >$_                 #A condition asking if $% is greater than $_.  Condition of the ternary operation
                           ?$;%$_           #If true, then return $; modulo $_
                                 :$_%$;     #If false, return $_ modulo $;
         $_=                                #Assign the result of the ternary operation back into $_
                                            #If $_ is non-zero, then the condition is true, and while will evaluate the operation
say                                         #Implicitly takes the $_ variable as parameter, and outputs its contents

原始代码，为后代保存：43 +1 = 44字节

say$_=$%>$_?$%%$_:$_%$%while$_-($%=reverse)

Pyth，13 12字节

t.u|%F_S,s_`

感谢@TheBikingViking。

在线尝试：演示

我的旧代码：

W
W=Q%F_S,s_`

在线尝试：演示

说明：

t.u|%F_S,s_`NNNQ  implicit Ns and Q at the end
               Q  start with N = Q (Q = input number)
        ,         create a pair with the numbers
         s_`N        convert N to string -> reverse-> convert to int
             N       and N
       S          sort
      _           reverse
    %F            fold by modulo
   |          N   or N (if the result is zero use N instead to stop)
 .u               apply this ^ procedure until a value repeats
                  print all intermediate values
 t                except the first one (the original number)

果冻，15 14 13 字节

,ṚḌṢṚ%/
ÇÇпḊ

在线试用

怎么样？

,ṚḌṢṚ%/ - Link 1, iterative procedure: n
,       - pair n with
 Ṛ      - reverse n
  Ḍ     - undecimal (int of digit list)
   Ṣ    - sort
    Ṛ   - reverse
     %/ - reduce with mod

ÇÇпḊ - Main link: n
  п  - collect while
 Ç    - last link as a monad is truthy
Ç     -     last link as a monad
    Ḋ - dequeue (remove the input from the head of the resulting list)

果冻，13 12字节

,ṚḌṢṚ%/Ṅß$Ṡ¡

这是打印到STDOUT的单声道链接/功能。

在线尝试！

怎么运行的

,ṚḌṢṚ%/Ṅß$Ṡ¡  Monadic link. Argument: n

,Ṛ            Pair n and its reversed digit list.
  Ḍ           Convert the digit list into an integer.
   ṢṚ         Sort and reverse.
     %/       Reduce by modulo. Result: m
          Ṡ¡  Do sign(m) times:
       Ṅß$    Print with a newline and call the link recursively.

Python 2，92 87 81 73 61字节

递归解决方案：

def f(n):
    r=int(`n`[::-1]);x=min(r%n,n%r)
    if x:print x;f(x)

在线尝试

迭代解决方案：（也为61个字节）

n=input()
while n:r=int(`n`[::-1]);n=min(r%n,n%r);print n/n*n

在线尝试

MATL，16字节

`tVPUhSPZ}\tt]xx

在线尝试！

说明

`         % Do...while
  t       %   Duplicate. Takes input implicitly in the first iteration
  VPU     %   Transform the number at the top of the stack by reversing its digits
  hSPZ}   %   Concatenate the two numbers into an array, sort, reverse, split the
          %   array: this moves the smaller number to the top
  \       %   Modulo
  t       %   Duplicate. The original copy is left on the stack for displaying, 
          %   and the duplicate will be used for computing the next number
  t       %   Duplicate. This copy will be used as loop condition: exit if 0
]         % End
xx        % Delete the two zeros at the top. Implicitly display rest of the stack

PHP，78字节

function a($n){while(($r=strrev($n))&&($n=$r>$n?$r%$n:$n%$r)!=0){echo$n.' ';}}

批量140字节

@echo off
set/pn=
:l
set/am=n,l=0
:r
set/al=l*10+m%%10,m/=10
if %m% gtr 0 goto r
set/an=l%%n%%l+n%%l%%n
if %n% gtr 0 echo %n%&goto l

在STDIN上输入并在单独的行上输出序列。一批具有条件语句（这是有点繁琐），但没有条件表达式，以便更容易（尽管有引述%多个）计算r%n%r（这等于r%n如果n<r还是零，如果n>r）和n%r%n（等于n%r，如果n>r还是零，如果n<r），并添加他们在一起。

Mathematica，68个字节

感谢Greg Martin建议我使用FixedPointList而不是NestWhileList：

FixedPointList[Mod[(r=IntegerReverse@#)~Max~#,r~Min~#]&,#][[2;;-4]]&

我能得到的原始解决方案最短的时间FixedPointList是73个字节：

NestWhileList[Mod[(r=IntegerReverse@#)~Max~#,r~Min~#]&,#,#!=0&][[2;;-2]]&

JavaScript，72 70字节

f=(s,...o)=>(u=s>(z=[...s+''].reverse().join``)?s%z:z%s)?f(u,...o,u):o

console.log(...[32452345, 12345678, 11000].map(x=>f(x)))

.as-console-wrapper{max-height:100%!important}

编辑：

-2个字节：传播运算符等待字符串连接。

R，126个 117字节

x=scan();while(x){y=sort(c(x,as.double(paste(rev(el(strsplit(c(x,""),""))),collapse=""))));if(x<-y[2]%%y[1])print(x)}

可悲的是，反转数字（as.double(paste(rev(el(strsplit(c(x,""),""))),collapse="")))）非常罗word。休息很容易。用于sort间接检查哪个较高。

其余的很简单，一直循环直到x=0，并打印所有步骤。

C，87字节

t;r;f(n){while(t=n){r=0;while(t)r=10*r+t%10,t/=10;n=r>n?r%n:n%r;if(n)printf("%d ",n);}}

t是暂时的。内循环向左移动r1位数字，并添加的最后一位t直到用尽。输出是在第一次迭代之后，并且仅当它为非零值时才阻止显示第一项和最后一项。

脱胶和用法：

t;r;
f(n){
  while (t = n){
    r = 0;
    while (t)
      r = 10*r + t%10,
      t /= 10; 
    n = r>n ? r%n : n%r;
    if(n)
      printf("%d ",n);
  }
}

Mathematica，64个字节

NestWhileList[#2~If[#<=#2,Mod,#0]~#&[IntegerReverse@#,#]&,#,#>0&]&

上面的代码代表一个纯函数，该函数接受单个输入，并返回kuznetsovs序列。关于mathematica的真正美丽之处在于，您可以将纯函数逐层放置...让我解释一下代码;）

序列中的每个项本身都使用下面的函数计算，该函数接受一个输入并返回下一个项。

#2~If[#<=#2,Mod,#0]~#&[IntegerReverse@#,#]&

该代码IntegerReverse@#仅生成r，即反转的值。该代码#2~If[#<=#2,Mod,#0]~#&是一个需要两个输入并执行mod操作或反转输入并再次调用自身的函数。另一种编写方式是If[#<=#2, Mod, #0][#2, #]&，也可以将其编写为常规函数，如下所示：k[a_, b_] := If[a <= b, Mod, k][b, a]

拍子180字节

(let p((n n)(ol'()))(let*((v reverse)(o modulo)
(r(string->number(list->string(v(string->list(number->string n))))))
(m(if(> n r)(o n r)(o r n))))(if(= m 0)(v ol)(p m(cons m ol)))))

取消高尔夫：

(define (f n)
  (let loop ((n n)
             (ol '()))
    (let* ((r (string->number
               (list->string
                (reverse
                 (string->list
                  (number->string n))))))
           (m (if (> n r)
                  (modulo n r)
                  (modulo r n))))
      (if (= m 0)
          (reverse ol)
          (loop m (cons m ol))))))

测试：

(f 32452345)
(f 12345678)

输出：

'(21873078 21418578 1907100 9999)
'(1234575 816021 92313 29655 26037 20988 4950 198 99)