요술쟁이 시퀀스는 다음과 같이 설명한다. 입력 a _1로 시작 하여 다음 항은 반복 관계에 의해 정의됩니다.

모든 후속 항은 1이되므로 순서가 1에 도달하면 종료됩니다.

직무

입력 n이 2보다 크거나 같으면 프로그램 / 함수 / 제너레이터 등을 작성하십시오. 각 저글러 시퀀스를 출력 / 반환합니다. 출력은 합리적인 형태 일 수 있습니다. 저글러 시퀀스를 계산하는 내장 또는 직접 결과를 산출하는 내장을 사용할 수 없습니다. 시퀀스가에서 끝났다고 가정 할 수 있습니다 1.

테스트 사례

Input: output
2: 2, 1
3: 3, 5, 11, 36, 6, 2, 1
4: 4, 2, 1
5: 5, 11, 36, 6, 2, 1

이것은 코드 골프입니다. 바이트 단위의 최단 코드가 이깁니다.

젤리 , 12 11 10 바이트

*BṪ×½Ḟµ’п

1 바이트로 골프를 치는 @ Sp3000에 감사합니다!

온라인으로 사용해보십시오!

작동 원리

*BṪ×½Ḟµ’п    Main link. Input: n

*B            Elevate n to all of its digits in base 2.
  Ṫ           Extract the last power.
              This yields n ** (n % 2).
   ×½         Multiply with sqrt(n). This yields n ** (n % 2 + 0.5).
     Ḟ        Floor.

      µ       Push the previous chain on the stack and begin a new, monadic chain.
        п    Repeat the previous chain while...
       ’        n - 1 is non-zero.
              Collect all intermediate results in an array.

Julia, 64 50 48 42 32 30 바이트

g(x)=[x;x<3||g(x^(x%2+.5)÷1)]

정수를 받아들이고 float 배열을 반환하는 재귀 함수입니다.

우리는 입력을 시퀀스의 다음 항에 연결하여 패리티의 제곱에 1/2을 더한 x 로 계산하여 배열을 만듭니다. 이것은 우리에게 x ^1/2 또는 x ^{1 + 1 / 2} = x ^{3/2를 제공} 합니다. 1의 정수 나누기는 바닥을 얻습니다. 조건 x <3이 true 인 경우 최종 요소는 숫자 값이 아닌 부울이되지만 배열이 유형이 아니기 Any때문에 나머지 배열과 동일한 유형으로 캐스트됩니다.

Dennis 덕분에 14 바이트를 절약했습니다!

자바 스크립트 (ES7), 45 33 바이트

f=n=>n<2?n:n+","+f(n**(.5+n%2)|0)

설명

재귀 적 접근. 쉼표로 구분 된 숫자 문자열을 반환합니다.

f=n=>
  n<2?n:          // stop when n == 1
  n               // return n at the start of the list
  +","+f(         // add the rest of the sequence to the list
    n**(.5+n%2)|0 // juggler algorithm
  )

테스트

** 브라우저 호환성 테스트에는 사용되지 않습니다.

f=n=>n<2?n:n+","+f(Math.pow(n,.5+n%2)|0)

<input type="number" oninput="result.textContent=f(+this.value)" />
<pre id="result"></pre>

수학, 40 39 바이트

1 바이트를 절약 한 Martin Büttner에게 감사합니다.

NestWhileList[⌊#^.5#^#~Mod~2⌋&,#,#>1&]&

테스트 사례

%[5]
(* {5,11,36,6,2,1} *)

Pyth, 14 12 바이트

.us@*B@N2NNQ

데모

우리는 누적 감소로 시작합니다. .u 시작합니다.이 경우 입력에서 시작하여 결과가 반복 될 때까지 함수를 적용하여 모든 중간 결과를 출력합니다.

이 함수는 이전 값을로 사용 N합니다. 로 시작하여 제곱근을 시작합니다 @N2. 다음에, 그 곱셈에 해당 값을 두 갈래 N로 *B ... N. 그러면 [N ** .5, (N ** .5) * N]짝수 및 홀수 사례에 대한 플로어되지 않은 결과 인 목록이 생성 됩니다. 다음으로로 목록에 색인을 생성하여 적절한 플로어링되지 않은 결과를 선택합니다 @ ... N. Pyth에는 모듈 식 인덱싱이 있으므로 범위를 벗어난 오류는 발생하지 않습니다. 마지막으로 결과는로 표시 s됩니다.

MATL, 13 12 바이트

`tt2\.5+^ktq

온라인으로 사용해보십시오!

설명

`     % do...while loop
tt   % duplicate top of stack twice, takes implicit input on first iteration
2\    % take a_k mod 2
.5+^  % adds 0.5, to give 1.5 if odd, 0.5 if even, and takes a_k^(0.5 or 1.5)
kt    % Rounds down, and duplicates
q     % Decrement by 1 and use for termination condition---if it is 0, loop will finish

바이트를 저장해 준 Luis에게 감사합니다!

Minkolang 0.15 , 25 바이트

ndN(d$7;r2%2*1+;YdNd1=,).

여기 사용해보십시오!

설명

n                            Take number from input => n
 dN                          Duplicate and output as number
   (                         Open while loop
    d                        Duplicate top of stack => n, n
     $7                      Push 0.5
       ;                     Pop b,a and push a**b => n, sqrt(n)
        r                    Reverse stack => sqrt(n), n
         2%                  Modulo by 2
           2*                Multiply by 2
             1+              Add 1 => sqrt(n), [1 if even, 3 if odd]
               ;             Pop b,a and push a**b => sqrt(n)**{1,3}
                Y            Floor top of stack
                 dN          Duplicate and output as number
                   d1=,      Duplicate and => 0 if 1, 1 otherwise
                       ).    Pop top of stack and end while loop if 0, then stop.

TSQL, 89 바이트

입력은 다음과 @N같습니다.

DECLARE @N INT = 5;

암호:

WITH N AS(SELECT @N N UNION ALL SELECT POWER(N,N%2+.5) N FROM N WHERE N>1)SELECT * FROM N

APL, 28 24 16 바이트

{⌊⍵*.5+2|⎕←⍵}⍣=⎕

정수를 받아들이고 연속 된 출력을 별도의 줄에 인쇄하는 프로그램입니다.

설명:

{           }⍣=⎕   ⍝ Apply the function until the result is the input
 ⌊⍵*.5+2|⎕←⍵       ⍝ Print the input, compute floor(input^(input % 2 + 0.5))

온라인으로 사용해보십시오

Dennis 덕분에 8 바이트가 절약되었습니다!

자바 7, 83 71 바이트

void g(int a){System.out.println(a);if(a>1)g((int)Math.pow(a,a%2+.5));}

원래 일반적인 for루프를 사용했지만 제대로 작동하려면 후프를 뛰어 넘어야했습니다. 대신 빌리는 user81655의 아이디어 를 훔친 후 12 바이트를 줄였습니다.

하스켈, 70 바이트

Haskell에는 정수가 sqrt내장되어 있지 않지만 보다 짧은 것이 있다고 생각 floor.sqrt.fromInteger합니다.

s=floor.sqrt.fromInteger
f n|odd n=s$n^3|1<2=s n
g 1=[1]
g n=n:g(f n) 

Oracle SQL 11.2, 128 바이트

WITH v(i)AS(SELECT :1 FROM DUAL UNION ALL SELECT FLOOR(DECODE(MOD(i,2),0,SQRT(i),POWER(i,1.5)))FROM v WHERE i>1)SELECT i FROM v;

언 골프

WITH v(i) AS
(
  SELECT :1 FROM DUAL
  UNION ALL
--  SELECT FLOOR(POWER(i,0.5+MOD(i,2))) FROM v WHERE i>1
  SELECT FLOOR(DECODE(MOD(i,2),0,SQRT(i),POWER(i,1.5))) FROM v WHERE i>1 
)
SELECT * FROM v;

.5에 MOD (i, 2)를 추가하는 것이 더 짧지 만 POWER (2, .5)에 버그가 있습니다.

SELECT POWER(4,.5), FLOOR(POWER(4,.5)), TO_CHAR(POWER(4,.5)) FROM DUAL

준다

2   1   1,99999999999999999999999999999999999999

R, 54 51 바이트

z=n=scan();while(n>1){n=n^(.5+n%%2)%/%1;z=c(z,n)};z

plannapus 덕분에 3 바이트를 절약했습니다.

CJam, 18 바이트

ri{__2%.5+#i_(}g]p

여기에서 테스트

David의 MATL 답변과 유사합니다 .

파이썬 3, 57 , 45 , 43 , 41 바이트

@mathmandan의 제안으로 더 나은 솔루션

def a(n):print(n);n<2or a(n**(.5+n%2)//1)

이 방법은 각 번호를 새 줄에 인쇄합니다

이전 솔루션 : xnor의 권장 사항 후에 43 바이트로 줄였습니다.

a=lambda n:[n][:n<2]or[n]+a(n**(n%2+.5)//1)

당신은 수행하여 위를 호출 할 수 a(10)있는 수익을[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

위의 값은 float로 출력됩니다. 정수로 원한다면 43 바이트에 2 바이트를 더 추가 할 수 있습니다.

def a(n):print(n);n<2or a(int(n**(.5+n%2)))

TI 기본, 30 바이트

Prompt A
Repeat A=1
Disp A
int(A^(remainder(A,2)+.5->A
End
1

자바 스크립트 ES6, 109 102 바이트

s=>(f=n=>n==1?n:n%2?Math.pow(n,3/2)|0:Math.sqrt(n)|0,a=[s],eval("while(f(s)-1)a.push(s=f(s))"),a+",1")

내가 알고있는 이 golfed 할 수 있습니다. 쉼표로 구분 된 숫자의 문자열을 반환합니다.

C ++, 122 바이트

#include <iostream>
void f(int n){int i;while(n^1){std::cout<<n<<',';for(i=n*n;i*i>(n%2?n*n*n:n);i--);n=i;}std::cout<<1;}

C #, 62 바이트

string f(int n)=>n+(n<2?"":","+f((int)Math.Pow(n,.5+n%2)));

@ user81655와 @Alex A.에서 영감을 받아 재귀를 사용했습니다.

레티 나, 144 바이트

입력과 출력이 단항입니다.

두 번째 줄부터 마지막 ​​줄까지는 공백이 있고 두 개의 가운데 줄과 마지막 줄은 비어 있습니다.

{`(\b|)11+$
$&¶$&
m-1=`^(?=^(11)*(1?)).*$
$&,$2
(1+),1$
$1;,
1(?=1*;)
$%_
1+;
$%_
;|,

m-1=`^
1:
+`(1+):(11\1)
1 $2:
1+:$|:1+

-1=`(1+\b)
$#1

온라인으로 사용해보십시오

설명

{`(\b|)11+$                 # Loop, Duplicate last line
$&¶$&
m-1=`^(?=^(11)*(1?)).*$     # Append ,n%2 to that line (number modulo 2)
$&,$2
(1+),1$                     # Cube that number if odd
$1;,
1(?=1*;)
$%_
1+;
$%_
;|,                         # (Last stage of cubing number)

m-1=`^                      # Integer square root of that number, 
1:                          #   borrowed and modified from another user's answer
+`(1+):(11\1)
1 $2:
1+:$|:1+

-1=`(1+\b)
$#1

Digital Trauma에 의한 Retina의 정수 제곱근

C, 64 63 61 바이트

t;q(n){for(;!t;n=pow(n,.5+n%2))printf("%d%c ",n,n^1?44:t++);}

TI 기본, 43 바이트

나는 Thomas Kwa를 뽑아 내 휴대폰에서 이것에 대답하고 있습니다.

Input N
Repeat N=1
Disp N
remainder(N,2->B
If not(B:int(sqrt(N->N
If B:int(N^1.5->N
End
1

sqrt계산기의 실제 기호로 교체하십시오 . 적절한 형식의 줄 바꿈으로 구분 된 숫자 목록을 표시합니다.

자바 스크립트 ES6, 76 바이트

라는 이름의 생성기 j입니다. 사용하려면을 설정하십시오 a = j(<your value>);. 순서에서 다음 값을 보려면을 입력하십시오 a.next().value.

function*j(N){for(yield N;N-1;)yield N=(N%2?Math.pow(N,3/2):Math.sqrt(N))|0}

언 골프 드 :

function* juggler(N){
    yield N;
    while(N!=1){
        N = Math.floor(N % 2 ? Math.pow(N,3/2) : Math.sqrt(N));
        yield N;
    }
}

F # 77 바이트

1에서 끝나지 않지만 계속 진행됩니다.

let j=Seq.unfold(fun x->Some(x,floor(match x%2. with 0.->x**0.5|1.->x**1.5)))

용법:

j 3.;;
> val it : seq<float> = seq [3.0; 5.0; 11.0; 36.0; ...]

실제로 1, 100 바이트에서 종료되는 버전

let j=Seq.unfold(fun x->if x=1. then None else Some(x,floor(match x%2. with 0.->x**0.5|1.->x**1.5)))

언 골프

let juggle input =
    let next x = 
        floor
            (match x % 2. with 
                | 0. -> x ** 0.5
                | 1. -> x ** 1.5
                | _ -> failwith "this should never happen") // addressing a compiler warning
    Seq.unfold (fun x -> if x = 1. then None else Some(x, next x)) input

펄 5, 34 바이트

33 -pE대신 1을 더한 값-e

say;($_=int$_**($_%2+.5))-1&&redo

설명

먼저 -p변수 $_를 stdin의 입력과 동일하게 설정합니다 . 그런 다음 코드 블록을 시작합니다.

1. say인쇄합니다 $_.
2. $_=int$_**($_%2+.5)세트 $_{의 정수 부분과 동일한 $_{{의 힘에 $_의한 조작 (순서 마법으로, 모듈 (2)} + 0.5}} 연산자 우선 순위 ). 이 할당은의 새로운 값을 반환 $_하고
3. (...)-1&&redo값에서 마이너스 1을 반환 한 테스트. 차이가 0이면 아무 것도 수행하지 않습니다. 그렇지 않으면이 블록을 다시 실행하십시오.

마지막으로를 -p인쇄합니다 $_.

길이가 같다

도 사용합니다 -p.

say()-($_=int$_**($_%2+.5))&&redo

이것은 : 인쇄 $_; 위와 같이 할당합니다. say새 값을 뺀 값인 1 (1) 의 반환 값 $_이 0 인지 여부를 테스트 하고 블록이 있으면 다시 실행합니다. 그런 다음 $_끝에 인쇄합니다 .

dc, 22 21 바이트

[pd2%2*1+^vd1<F]dsFxn

설명 :

[                # Begin macro definition
 p               # Peek at top of stack (print without popping, followed by newline)
 d               # Duplicate top of stack
 2%              # Mod 2: If even, 0; if odd, 1
 2*1+            # If even: 0*2+1==1; if odd: 1*2+1==3
 ^v              # Raise, then square root: equivalent to `^(0.5)' or `^(1.5)'
 d1<F            # If result is not 1, run macro again
]dsFx            # Duplicate macro, store as `F', execute
n                # Print the final "1"

버그가 있습니다 : 입력이 1인 경우 출력은 두 개의으로 구성됩니다 1.