Kusnezows Sequenz

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

Gegeben eine beliebige Zahl n > 0, lassen Sie rdie Rückseite der Zahl darstellen n. Iterieren Sie, bis das Endergebnis Null ist, und geben Sie das Ergebnis jeder Iteration mithilfe einer Rekursion oder einer Methode Ihrer Wahl in die Funktion zurück, indem Sie die folgende Operation ausführen:

• Wenn r > nfür diese Iteration das Ergebnis ist r % n.
• Wenn n > rfür diese Iteration das Ergebnis ist n % r.
• Wenn n % r = 0oder r % n = 0, brechen Sie die Iteration ab.

Nehmen Sie das Zwischenergebnis jeder Ausführung und speichern Sie sie in einem Array für die endgültige Antwort. Die anfängliche Nummer nist weder Teil der Sequenz noch 0; Die Beispiele sollten alles ein wenig offensichtlicher machen.

Gehen wir ein Beispiel durch, wo 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]     

Ein weiteres Beispiel 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]

Ein letztes Beispiel n=11000:

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

Result: []

Dies ist Code-Golf mit der niedrigsten Anzahl an Bytes.

05AB1E , 11 Bytes

[‚{R`%Ð>#,

Verwendet die CP-1252- Codierung. Probieren Sie es online!

PowerShell v2 +, 89 Byte

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

Iterative Lösung. Langwierig, da es keine einfache Möglichkeit gibt, ein Array umzukehren. Wir fassen es zusammen und indizieren es rückwärts, um es zu speichern $r. Dann ein Pseudoternär, um das entsprechende Modulo herauszuziehen und $nfür die nächste Runde neu zu speichern . Wenn das Ergebnis jedoch Null ist, bedeutet dies, dass der !($n...)Wille ist $true, also wir exitstatt $n. Die Zahlen Write-Outputverbleiben in der Pipeline und werden (implizit) als Array zurückgegeben. Ohne die Kapselung einer Pipeline oder das Speichern der Ergebnisse in einer Variablen wird jedoch standardmäßig eine neue Zeile dazwischen eingefügt.

Probieren Sie es online! (Ja, todernst.)
PowerShell ist jetzt auf TIO! Du musst es geben ein oder zwei Sekunden, da Powershell ein Tier Startup ist, aber jetzt Sie, ja Sie können Powershell - Code direkt in Ihrem Browser überprüfen!

Perl, 43 38 + 1 = 39 Bytes

Laufen Sie mit der -nFlagge

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

Probieren Sie es online! Enthält die beiden nicht leeren Beispiele.

Erklärungstabelle

-n: Wickelt das gesamte Programm ein while(<>){ ... ;}. Dadurch wird der obige Code in die folgende Zeile: while(<>){say while$_=($;=reverse)>$_?$;%$_:$_%$;}. Beachten Sie, dass am Ende ein Semikolon hinzugefügt wurde $, sodass es jetzt zu einer Instanz der Variablen wird $;. Liest im Zustand einer whileSchleife <>automatisch eine Eingabezeile und speichert sie in der $_Variablen. Schauen wir uns nun an, was der Interpreter in der äußeren whileSchleife liest :

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

Originalcode, für die Nachwelt gespeichert: 43 + 1 = 44 Bytes

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

Pyth, 13 12 Bytes

t.u|%F_S,s_`

Vielen Dank an @TheBikingViking.

Probieren Sie es online aus: Demonstration

Mein alter Code:

W
W=Q%F_S,s_`

Probieren Sie es online aus: Demonstration

Erläuterung:

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)

Jelly , 15 14 13 Bytes

,ṚḌṢṚ%/
ÇÇпḊ

TryItOnline

Wie?

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

Jelly , 13-12 Bytes

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

Dies ist eine monadische Verknüpfung / Funktion, die auf STDOUT gedruckt wird.

Probieren Sie es online!

Wie es funktioniert

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

Rekursive Lösung:

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

Probieren Sie es online aus

Iterative Lösung: (auch 61 Bytes )

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

Probieren Sie es online aus

MATL , 16 Bytes

`tVPUhSPZ}\tt]xx

Probieren Sie es online!

Erläuterung

`         % 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.' ';}}

Batch, 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

Übernimmt die Eingabe für STDIN und gibt die Sequenz in separaten Zeilen aus. Batch hat bedingte Anweisungen (die etwas weitschweifig sind) , jedoch keine bedingte Ausdrücke so ist es einfacher (trotz der zitieren %s) zu berechnen r%n%r(die gleich ist , r%nwenn n<roder Null , wenn n>r) und n%r%n(was gleich , n%rob n>roder Null , wenn n<r) und Add Sie zusammen.

Mathematica, 68 Bytes

Vielen Dank an Greg Martin, der vorgeschlagen hat, dass ich FixedPointListeher verwende als NestWhileList:

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

Das kürzeste, mit dem ich meine ursprüngliche Lösung erhalten konnte, FixedPointListwar 73 Byte:

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

JavaScript, 72-70 Byte

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}

Bearbeitet:

-2 Byte : Der Spread-Operator wartet auf die Verkettung der Zeichenfolgen.

R 126 117 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)}

Leider ist das Umkehren einer Zahl ( as.double(paste(rev(el(strsplit(c(x,""),""))),collapse="")))) ziemlich wortreich. Ruhe ist ziemlich einfach. Verwendet, sortum indirekt zu überprüfen, welche höher ist.

Der Rest ist unkompliziert, läuft weiter bis x=0und druckt alle Schritte.

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

tist vorübergehend für die Umkehrung. Die innere Schleife verschiebt sichr Stelle nach links und fügt die letzte Stelle hinzu, tbis sie erschöpft ist. Die Ausgabe erfolgt nach der ersten Iteration und nur dann, wenn sie nicht Null ist, um zu verhindern, dass das erste und das letzte Element angezeigt werden.

Ungolfed und Nutzung:

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&]&

Der obige Code stellt eine reine Funktion dar, die eine einzelne Eingabe akzeptiert und die kuznetsovs-Sequenz zurückgibt. Das wirklich Schöne an Mathematica ist, dass man eine Ebene über eine Ebene reiner Funktionen legen kann ... Erlauben Sie mir, den Code zu erklären;)

Jeder Term in der Sequenz selbst wird mit der folgenden Funktion berechnet, die eine Eingabe annimmt und den nächsten Term zurückgibt.

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

Der Code IntegerReverse@#generiert nur r, den umgekehrten Wert. Der Code #2~If[#<=#2,Mod,#0]~#&ist eine Funktion, die zwei Eingaben übernimmt und entweder die Mod-Operation ausführt oder die Eingaben umkehrt und sich selbst erneut aufruft. Eine andere Art zu schreiben ist If[#<=#2, Mod, #0][#2, #]&, oder es könnte als reguläre Funktion wie folgt geschrieben werden:k[a_, b_] := If[a <= b, Mod, k][b, a]

Schläger 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)))))

Ungolfed:

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

Testen:

(f 32452345)
(f 12345678)

Ausgang:

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