Secuencia de Kuznetsov

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

Dado cualquier número n > 0, vamos a rrepresentar el reverso del número n. Itere hasta que el resultado final sea cero, transfiriendo el resultado de cada iteración a la función utilizando la recursión o una metodología de su elección al realizar la siguiente operación:

• Si r > npara esa iteración el resultado es r % n.
• Si n > rpara esa iteración el resultado es n % r.
• Si n % r = 0o r % n = 0, termina la iteración.

Tome el resultado intermedio de cada ejecución y guárdelos en una matriz para la respuesta final. El número inicial nno es parte de la secuencia, ni lo es 0; Los ejemplos deberían hacer que todo sea un poco más obvio.

Veamos un ejemplo donde 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]     

Otro ejemplo 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]

Un último ejemplo n=11000:

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

Result: []

Este es el código de golf más bajo de conteo de bytes gana.

05AB1E , 11 bytes

[‚{R`%Ð>#,

Utiliza la codificación CP-1252 . Pruébalo en línea!

PowerShell v2 +, 89 bytes

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

Solución iterativa. Largo porque no hay una manera fácil de revertir una matriz, por lo que la encadenamos y la indexamos hacia atrás para almacenarla $r. Luego, un pseudoternario para extraer el módulo apropiado y volver a almacenarlo $npara la siguiente ronda. Sin embargo, si el resultado es cero, eso significa !($n...)que será $true, así que en exitlugar de $n. Los números se dejan en la tubería y (implícitamente) se devuelven como una matriz, pero sin una tubería encapsulada o guardando los resultados en una variable, el valor predeterminado Write-Outputfija una nueva línea entre ellos.

Pruébalo en línea! (Sí, muy en serio.) ¡
PowerShell ahora está en TIO! Hay que darle un segundo o dos, porque PowerShell es una bestia de inicio, pero ahora, si usted , puede verificar el código de PowerShell directamente en su navegador!

Perl, 43 38 + 1 = 39 bytes

Corre con la -nbandera

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

Pruébalo en línea! Incluye los dos ejemplos no vacíos.

Tabla de explicaciones

-n: Envuelve todo el programa en while(<>){ ... ;}. Esto convierte el código anterior en la siguiente línea: while(<>){say while$_=($;=reverse)>$_?$;%$_:$_%$;}. Observe que se ha agregado un punto y coma al final $, por lo que ahora se convierte en una instancia de la variable $;. En la condición de un whilebucle, <>lee automáticamente una línea de entrada y la guarda en la $_variable. Así que ahora veamos qué lee el intérprete dentro del whilebucle externo :

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

Código original, guardado para la posteridad: 43 + 1 = 44 bytes

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

Pyth, 13 12 bytes

t.u|%F_S,s_`

Gracias a @TheBikingViking.

Pruébelo en línea: demostración

Mi antiguo código

W
W=Q%F_S,s_`

Pruébelo en línea: demostración

Explicación:

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)

Jalea , 15 14 13 bytes

,ṚḌṢṚ%/
ÇÇпḊ

TryItOnline

¿Cómo?

,ṚḌṢṚ%/ - 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)

Jalea , 13 12 bytes

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

Este es un enlace / función monádico que se imprime en STDOUT.

Pruébalo en línea!

Cómo funciona

,ṚḌṢṚ%/Ṅß$Ṡ¡  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 bytes

Solución recursiva:

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

Pruébalo en línea

Solución iterativa: (también 61 bytes )

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

Pruébalo en línea

MATL , 16 bytes

`tVPUhSPZ}\tt]xx

Pruébalo en línea!

Explicación

`         % 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 bytes

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

Lote, 140 bytes

@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

Toma entrada en STDIN y emite la secuencia en líneas separadas. Batch tiene declaraciones condicionales (que son algo detalladas) pero no tiene expresiones condicionales, por lo que es más fácil (a pesar de tener que citar las %s) para calcular r%n%r(que es igual ar%n if n<ro zero if n>r) y n%r%n(que es igual a n%rif n>ro zero if n<r) y agrega ellos juntos.

Mathematica, 68 bytes

Gracias a Greg Martin por sugerir que useFixedPointList lugar de NestWhileList:

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

El más corto con el que pude obtener mi solución original FixedPointListfue de 73 bytes:

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

JavaScript, 72 70 bytes

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}

Editado:

-2 bytes : el operador extendido espera la concatenación de cadenas.

R, 126117 bytes

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

Lamentablemente, invertir un número ( as.double(paste(rev(el(strsplit(c(x,""),""))),collapse="")))) es bastante prolijo. Descansar es bastante fácil. Utiliza sortpara verificar indirectamente cuál es mayor.

El resto es sencillo, sigue en bucle hasta x=0e imprime todos los pasos.

C, 87 bytes

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

tEs temporal para revertir. El bucle interno cambiar 1 dígito a la izquierda y agrega el último dígito thasta que se agota. La salida es posterior a la primera iteración y solo si no es cero para evitar que se muestren el primer y el último elemento.

Sin golf y uso:

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 bytes

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

El código anterior representa una función pura que toma una sola entrada y devuelve la secuencia kuznetsovs. Lo realmente hermoso de Mathica es que puedes poner capa sobre capa de funciones puras ... Permíteme explicarte el código;)

Cada término en la secuencia misma se calcula con la siguiente función, que toma una entrada y devuelve el siguiente término.

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

El código IntegerReverse@#solo genera r, el valor invertido. El código #2~If[#<=#2,Mod,#0]~#&es una función que toma dos entradas y realiza la operación mod, o invierte las entradas y se llama a sí mismo nuevamente. Otra forma de escribirlo es If[#<=#2, Mod, #0][#2, #]&, o podría escribirse como una función regular como esta:k[a_, b_] := If[a <= b, Mod, k][b, a]

Raqueta 180 bytes

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

Sin golf:

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

Pruebas:

(f 32452345)
(f 12345678)

Ouput:

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