ลำดับเล่นกลอธิบายไว้ดังนี้ เริ่มต้นด้วยอินพุตa ₁คำถัดไปจะถูกกำหนดโดยความสัมพันธ์ที่เกิดซ้ำ

ลำดับจะสิ้นสุดลงเมื่อมันมาถึง 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Ṫ×½Ḟµ’п

ขอบคุณ @ Sp3000 สำหรับการตีกอล์ฟ 1 ไบต์!

ลองออนไลน์!

มันทำงานอย่างไร

*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)]

นี่เป็นฟังก์ชันแบบเรียกซ้ำที่ยอมรับจำนวนเต็มและส่งกลับอาร์เรย์แบบลอย

เราสร้างอาร์เรย์โดยเชื่อมโยงอินพุตกับคำถัดไปของลำดับซึ่งคำนวณเป็นxถึงกำลังของพาริตีบวก 1/2 นี้จะช่วยให้เราทั้งx ^1/2หรือx ^{1 + 1/2} = x 3/2 การหารจำนวนเต็มด้วย 1 จะทำให้พื้น เมื่อเงื่อนไขx <3 เป็นจริงองค์ประกอบสุดท้ายจะเป็นบูลีนแทนที่จะเป็นค่าตัวเลข แต่เนื่องจากอาร์เรย์ไม่ได้เป็นประเภทAnyจึงมีการส่งแบบเดียวกันกับส่วนที่เหลือของอาร์เรย์

บันทึก 14 ไบต์ขอบคุณ Dennis!

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

Mathematica, 40 39 ไบต์

ขอบคุณ Martin Büttnerที่ช่วยประหยัด 1 ไบต์

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

กรณีทดสอบ

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

Pyth, 14 12 ไบต์

.us@*B@N2NNQ

สาธิต

เราเริ่มต้นด้วยการลดการสะสม.uซึ่งในกรณีนี้เริ่มต้นที่อินพุทและใช้ฟังก์ชั่นจนกว่าผลลัพธ์จะเกิดซ้ำซึ่ง ณ จุดนั้นมันจะออกผลลัพธ์กลางทั้งหมด

Nฟังก์ชั่นใช้เวลาค่าก่อนหน้าเป็น @N2มันเริ่มต้นโดยการใช้รากของมันด้วย ถัดไปก็ bifurcates ค่าที่คูณโดยมีN *B ... Nสิ่งนี้จะสร้างรายการ[N ** .5, (N ** .5) * N]ผลลัพธ์ที่ไม่ได้รับการตรวจสอบสำหรับกรณีคู่ ถัดไปผล unfloored @ ... 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))

ลองออนไลน์

บันทึก 8 ไบต์ขอบคุณเดนนิส!

Java 7, 83 71 ไบต์

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

ตอนแรกฉันใช้forวงทั่วไปแต่ฉันต้องกระโดดผ่านห่วงเพื่อให้มันทำงานได้ถูกต้อง หลังจากขโมยความคิดของผู้ใช้ในการกู้คืนมาแทนฉันได้รับสิบสองไบต์

Haskell, 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;

การเพิ่ม MOD (i, 2) to .5 นั้นสั้นลง แต่มีข้อผิดพลาดกับ 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

บันทึกแล้ว 3 ไบต์ขอบคุณ plannapus

CJam, 18 ไบต์

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

ทดสอบที่นี่

คล้ายกับคำตอบ MATL ของดาวิด

Python 3, 57 , 45 , 43 , 41 ไบต์

โซลูชันที่ดีกว่าพร้อมคำแนะนำจาก @mathmandan

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

วิธีนี้จะพิมพ์แต่ละหมายเลขในบรรทัดใหม่

โซลูชันก่อนหน้า: ลดลงถึง 43 ไบต์หลังจากคำแนะนำของ xnor

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]

ข้างต้นจะส่งออกค่าเป็นลอย หากคุณต้องการให้มันเป็นจำนวนเต็มเราสามารถเพิ่ม 2 ไบต์พิเศษได้ 43 ไบต์:

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

TI-Basic, 30 ไบต์

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

JavaScript 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")

ฉันรู้ว่านี่สามารถเล่นกอล์ฟได้ ส่งคืนสตริงของตัวเลขคั่นด้วยเครื่องหมายจุลภาค

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 ไบต์

อินพุตและเอาต์พุตอยู่ในสภาวะเดียวกัน

บรรทัดที่ 2 ถึงสุดท้ายมีช่องว่างและบรรทัดกลางสองบรรทัดและบรรทัดสุดท้ายว่างเปล่า

{`(\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

รากที่สองจำนวนเต็มใน Retinaโดย Digital Trauma

C, 64 63 61 ไบต์

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

TI BASIC ขนาด 43 ไบต์

ฉันดึงโทมัสควาและตอบคำถามนี้ทางมือถือ

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ด้วยสัญลักษณ์จริงบนเครื่องคิดเลขของคุณ แสดงรายการหมายเลขที่คั่นด้วย linefeed ซึ่งเป็นรูปแบบที่เหมาะสม

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

Ungolfed:

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

Ungolfed

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

Perl 5, 34 ไบต์

33, บวก 1 สำหรับ -pEแทน-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) ลบค่าใหม่ของ$_เป็น 0 หรือไม่และทำซ้ำบล็อกหากมี จากนั้นพิมพ์$_ที่ส่วนท้าย

กระแสตรง, 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เอาท์พุทประกอบด้วยสอง1s