쿠즈 네 초프의 순서

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

어떤 수를 감안할 때 n > 0, LET r수의 역을 나타냅니다 n. 최종 결과가 0이 될 때까지 반복하고 아래 작업을 수행하여 각 반복의 결과를 재귀 또는 선택한 방법을 사용하여 함수로 다시 전달하십시오.

• 만약 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다음 라운드 를 위해 다시 저장 합니다. 결과가 0 인 경우, 그 수단이 !($n...)될 것입니다 $true, 우리는 그렇게 exit하는 대신 $n. 숫자는 파이프 라인에 남겨지고 (암시 적으로) 배열로 반환되지만 캡슐화 파이프 라인이 없거나 결과를 변수에 저장하지 않으면 기본값 Write-Output이 줄 바꿈을 유지합니다.

온라인으로 사용해보십시오! (예, 매우 심각합니다.)
이제 PowerShell이 ​​TIO에 있습니다! PowerShell을 시작으로 짐승이기 때문에 당신은 그것을 두 번째 또는 두 가지를 줘,하지만 지금은, 그래 당신은 , 당신의 브라우저에서 PowerShell을 코드 권리를 확인할 수 있습니다!

펄, 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)

피스, 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 바이트

,ṚḌṢṚ%/
ÇÇпḊ

TryItOnline

어떻게?

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

파이썬 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 에게 감사드립니다 .FixedPointListNestWhileList

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

원래 솔루션을 얻을 수있는 가장 짧은 시간 FixedPointList은 73 바이트였습니다.

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

자바 스크립트, 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 bytes : Spread 연산자가 문자열 연결을 기다립니다.

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=""))))를 뒤집는 것은 꽤 장황합니다. 휴식은 매우 쉽습니다. 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반전을위한 임시입니다. 내부 루프 시프트r 1 자리 왼쪽으로 이동하고 t끝날 때까지 마지막 자리를 추가합니다 . 출력은 첫 번째 반복 이후이며 첫 번째 항목과 마지막 항목이 표시되지 않도록 0이 아닌 경우에만 해당됩니다.

언 골프 및 사용법 :

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)