La séquence de Kuznetsov

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

Étant donné n'importe quel nombre n > 0, rreprésentons l'inverse du nombre n. Itérer jusqu'à ce que le résultat final soit nul, en passant le résultat de chaque itération dans la fonction en utilisant la récursivité ou une méthodologie de votre choix en effectuant l'opération ci-dessous:

• Si r > npour cette itération le résultat est r % n.
• Si n > rpour cette itération le résultat est n % r.
• Si n % r = 0ou r % n = 0, vous mettez fin à l'itération.

Prenez le résultat intermédiaire de chaque exécution et stockez-les dans un tableau pour la réponse finale. Le nombre initial nne fait pas partie de la séquence, pas plus 0; les exemples devraient rendre tout un peu plus évident.

Permet de parcourir un exemple où 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]     

Un autre exemple 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 dernier exemple n=11000:

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

Result: []

Il s'agit du nombre de victoires par nombre d'octets le plus bas du code-golf .

05AB1E , 11 octets

[‚{R`%Ð>#,

Utilise l' encodage CP-1252 . Essayez-le en ligne!

PowerShell v2 +, 89 octets

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

Solution itérative. Longue car il n'y a pas de moyen facile d'inverser un tableau, nous le stringifions et l'indexons à l'envers pour le stocker $r. Ensuite, un pseudo-ternaire pour retirer le modulo approprié et le ré-stocker $npour le prochain tour. Cependant, si le résultat est nul, cela signifie que le !($n...)sera $true, donc nous exitau lieu de $n. Les nombres sont laissés sur le pipeline et (implicitement) retournés sous forme de tableau, mais sans pipeline d'encapsulation ni enregistrement des résultats dans une variable, la valeur par défautWrite-Output colle une nouvelle ligne entre.

Essayez-le en ligne! (Oui, très sérieux.)
PowerShell est maintenant sur TIO! Vous devez lui donner une seconde ou deux, car PowerShell est une bête au démarrage, mais maintenant vous, oui vous , pouvez vérifier le code PowerShell directement dans votre navigateur!

Perl, 43 38 + 1 = 39 octets

Courir avec le -ndrapeau

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

Essayez-le en ligne! Comprend les deux exemples non vides.

Tableau explicatif

-n: Encapsule l'intégralité du programme while(<>){ ... ;}. Cela transforme le code ci - dessus dans la ligne suivante: while(<>){say while$_=($;=reverse)>$_?$;%$_:$_%$;}. Notez qu'un point-virgule a été ajouté à la fin $, il devient donc une instance de la variable $;. Dans l'état d'une whileboucle, <>lit automatiquement une ligne d'entrée et l'enregistre dans la $_variable. Voyons maintenant ce que l'interprète lit à l'intérieur de la whileboucle externe :

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

Code original, enregistré pour la postérité: 43 + 1 = 44 octets

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

Pyth, 13 12 octets

t.u|%F_S,s_`

Merci à @TheBikingViking.

Essayez-le en ligne: Démonstration

Mon ancien code:

W
W=Q%F_S,s_`

Essayez-le en ligne: Démonstration

Explication:

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)

Gelée , 15 14 13 octets

,ṚḌṢṚ%/
ÇÇпḊ

TryItOnline

Comment?

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

Gelée , 13 12 octets

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

Il s'agit d'un lien / fonction monadique qui s'imprime sur STDOUT.

Essayez-le en ligne!

Comment ça fonctionne

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

Solution récursive:

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

Essayez-le en ligne

Solution itérative: (également 61 octets )

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

Essayez-le en ligne

MATL , 16 octets

`tVPUhSPZ}\tt]xx

Essayez-le en ligne!

Explication

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

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

Lot, 140 octets

@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

Prend l'entrée sur STDIN et sort la séquence sur des lignes séparées. Batch a des instructions conditionnelles (qui sont quelque peu verbeuses) mais pas d'expressions conditionnelles, il est donc plus facile (malgré la citation du %s) de calculer r%n%r(qui est égal à r%nif n<rou zéro if n>r) et n%r%n(qui est égal à n%rif n>rou zero if n<r) et d'ajouter eux autres ensemble.

Mathematica, 68 octets

Merci à Greg Martin d' avoir suggéré d'utiliser FixedPointListplutôt que NestWhileList:

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

Le plus court avec lequel j'ai pu obtenir ma solution d'origine FixedPointListétait de 73 octets:

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

JavaScript, 72 70 octets

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}

Édité:

-2 octets : l'opérateur d'étalement attend la concaténation de chaînes.

R, 126 117 octets

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

Malheureusement, inverser un nombre ( as.double(paste(rev(el(strsplit(c(x,""),""))),collapse="")))) est assez verbeux. Le repos est assez facile. Permet sortde vérifier indirectement ce qui est le plus élevé.

Le reste est simple, il continue de boucler jusqu'à x=0et imprime toutes les étapes.

C, 87 octets

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

test temporaire pour inverser. La boucle intérieure décale r1 chiffre vers la gauche et ajoute le dernier chiffre det jusqu'à ce qu'il soit épuisé. La sortie est après la première itération et uniquement si elle est différente de zéro pour empêcher l'affichage du premier et du dernier élément.

Non golfé et utilisation:

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 octets

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

Le code ci-dessus représente une fonction pure qui prend une seule entrée et retourne la séquence kuznetsovs. La chose vraiment belle à propos de mathématique est que vous pouvez mettre couche sur couche de fonctions pures ... Permettez-moi d'expliquer le code;)

Chaque terme de la séquence elle-même est calculé avec la fonction ci-dessous, qui prend une entrée et renvoie le terme suivant.

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

Le code IntegerReverse@#génère juste r, la valeur inversée. Le code #2~If[#<=#2,Mod,#0]~#&est une fonction qui prend deux entrées et effectue l'opération de modification, ou inverse les entrées et se rappelle. Une autre façon de l'écrire est If[#<=#2, Mod, #0][#2, #]&, ou elle pourrait être écrite comme une fonction régulière comme celle-ci:k[a_, b_] := If[a <= b, Mod, k][b, a]

Raquette 180 octets

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

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

Essai:

(f 32452345)
(f 12345678)

Sortie:

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