The urut juggler digambarkan sebagai berikut. Dimulai dengan input a ₁ , istilah berikutnya didefinisikan oleh relasi perulangan

Urutan berakhir ketika mencapai 1, karena semua istilah selanjutnya akan menjadi 1.

Tugas

Diberikan input nlebih besar dari atau sama dengan 2, tulis program / fungsi / generator / dll. yang menampilkan / mengembalikan urutan juggler masing-masing. Outputnya bisa dalam bentuk apa pun yang masuk akal. Anda tidak boleh menggunakan built-in yang menghitung urutan juggler, atau built-in yang secara langsung menghasilkan hasilnya. Anda dapat mengasumsikan bahwa urutan berakhir pada 1.

Uji Kasus

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

Ini adalah kode golf. Kode terpendek dalam byte menang.

Jelly , 12 11 10 byte

*BṪ×½Ḟµ’п

Terima kasih kepada @ Sp3000 untuk bermain golf 1 byte!

Cobalah online!

Bagaimana itu bekerja

*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 byte

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

Ini adalah fungsi rekursif yang menerima integer dan mengembalikan array float.

Kami membangun array dengan menggabungkan input dengan istilah urutan berikutnya, dihitung sebagai x dengan kekuatan paritasnya ditambah 1/2. Ini memberi kita x ^1/2 atau x ^{1 + 1/2} = x ^3/2 . Divisi integer dengan 1 mendapatkan lantai. Ketika kondisi x <3 benar, elemen terakhir akan menjadi Boolean daripada nilai numerik, tetapi karena array bukan tipe Any, ini dilemparkan untuk memiliki tipe yang sama dengan sisa array.

Disimpan 14 byte berkat Dennis!

JavaScript (ES7), 45 33 byte

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

Penjelasan

Pendekatan rekursif. Mengembalikan serangkaian angka yang dipisahkan tanda koma.

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
  )

Uji

** tidak digunakan dalam uji kompatibilitas browser.

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 byte

Terima kasih kepada Martin Büttner karena menghemat 1 byte.

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

Kasus cobaan

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

Pyth, 14 12 byte

.us@*B@N2NNQ

Demonstrasi

Kita mulai dengan pengurangan kumulatif .u,, yang dalam hal ini dimulai pada input dan menerapkan fungsi sampai hasilnya berulang, pada titik mana output semua hasil antara.

Fungsi ini mengambil nilai sebelumnya sebagai N. Dimulai dengan mengambil akar kuadratnya @N2. Selanjutnya, itu membagi dua nilai itu pada perkalian dengan Ndengan *B ... N. Ini membuat daftar [N ** .5, (N ** .5) * N], hasil yang tidak dicintai untuk kasus genap dan ganjil. Selanjutnya, hasil yang tidak dicintai yang sesuai dipilih dengan mengindeks ke dalam daftar @ ... N. Karena Pyth memiliki pengindeksan modular, tidak ada kesalahan di luar batas yang dilemparkan. Akhirnya, hasilnya didasarkan pada s.

MATL, 13 12 byte

`tt2\.5+^ktq

Cobalah online!

Penjelasan

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

Terima kasih Luis telah menghemat satu byte!

Minkolang 0,15 , 25 byte

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

Coba di sini!

Penjelasan

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 byte

Masukan masuk @N:

DECLARE @N INT = 5;

Kode:

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 byte

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

Ini adalah program yang menerima integer dan mencetak output berurutan pada baris yang terpisah.

Penjelasan:

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

Cobalah online

Disimpan 8 byte berkat Dennis!

Java 7, 83 71 byte

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

Saya awalnya menggunakan forloop khas , tetapi saya harus melompat melalui lingkaran untuk membuatnya bekerja dengan benar. Setelah mencuri, meminjam ide user81655 untuk muncul kembali , saya mendapatkannya turun dua belas byte.

Haskell, 70 byte

Haskell tidak memiliki integer sqrtbuilt-in, tapi saya pikir mungkin ada sesuatu yang lebih pendek dari itu 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 byte

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;

Tidak bermain golf

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;

Menambahkan MOD (i, 2) ke .5 lebih pendek tetapi ada bug dengan POWER (2, .5):

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

memberi

2   1   1,99999999999999999999999999999999999999

R, 54 51 byte

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

Disimpan 3 byte berkat plannapus.

CJam, 18 byte

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

Uji di sini

Mirip dengan jawaban MATL David .

Python 3, 57 , 45 , 43 , 41 byte

Solusi yang lebih baik dengan saran dari @mathmandan

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

Metode ini akan mencetak setiap nomor pada baris baru

Solusi Sebelumnya: Kurangi hingga 43 byte setelah rekomendasi xnor

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

Anda dapat memanggil yang di atas dengan melakukan a(10)pengembalian apa[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Di atas akan menampilkan nilai sebagai mengapung. Jika Anda menginginkannya sebagai bilangan bulat, maka kita bisa menambahkan 2 byte tambahan untuk 43 byte:

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

TI-Basic, 30 Bytes

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

JavaScript ES6, 109 102 byte

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

Saya tahu ini bisa golf. Mengembalikan serangkaian angka yang dipisahkan koma.

C ++, 122 byte

#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 byte

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

Terinspirasi oleh @ user81655 dan @Alex A., saya menggunakan rekursi.

Retina, 144 byte

Input dan output berada di unary.

Baris ke-2 ke terakhir berisi spasi, dan dua garis tengah dan baris terakhir kosong.

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

Cobalah online

Penjelasan

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

Root kuadrat integer di Retina , oleh Digital Trauma

C, 64 63 61 byte

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

TI BASIC, 43 byte

Saya menarik Thomas Kwa dan menjawab yang ini di ponsel saya.

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

Ganti sqrtdengan simbol aktual di kalkulator Anda. Menampilkan daftar angka yang dipisahkan dengan linefeed, yang merupakan format yang masuk akal.

JavaScript ES6, 76 byte

Apakah generator bernama j. Untuk menggunakan, atur a = j(<your value>);. Untuk melihat nilai berikutnya dalam urutan, masukkan a.next().value.

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

Tidak Disatukan:

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 byte

Tidak berhenti pada 1, tetapi terus berjalan.

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

Pemakaian:

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

Versi yang benar-benar berakhir pada 1, 100 byte

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

Tidak disatukan

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 byte

33, ditambah 1 untuk -pEbukan-e

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

Penjelasan

Pertama, -psetel variabel $_sama dengan input dari stdin. Lalu kita mulai blok kode:

1. saycetakan $_.
2. $_=int$_**($_%2+.5)set $_sama dengan bagian integer { $_ke kekuatan {{ $_modulo 2} + 0,5}}, karena keajaiban urutan operasi ( prioritas operator ). Tugas ini mengembalikan nilai baru dari $_, dan
3. (...)-1&&redotes yang mengembalikan nilai, minus 1. Jika perbedaannya adalah 0, jangan lakukan apa-apa; jika tidak, ulangi blok ini.

Akhirnya, -pcetak $_.

Dengan panjang yang sama

Juga menggunakan -p.

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

Ini: mencetak $_; menugaskan seperti di atas; menguji apakah nilai pengembalian say(yaitu 1), minus nilai baru $_, adalah 0, dan mengulangi blok jika demikian; lalu cetak $_di bagian akhir.

dc, 22 21 byte

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

Dijelaskan:

[                # 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"

Ada bug: Ketika inputnya 1, output terdiri dari dua 1s.