Các chuỗi tung hứng được mô tả như sau. Bắt đầu với một đầu vào một ₁ , thuật ngữ tiếp theo được xác định bởi mối quan hệ tái phát

Trình tự kết thúc khi nó đạt 1, vì tất cả các điều khoản tiếp theo sau đó sẽ là 1.

Bài tập

Cho đầu vào nlớn hơn hoặc bằng 2, hãy viết chương trình / hàm / trình tạo / v.v. mà đầu ra / trả về trình tự tung hứng tương ứng. Đầu ra có thể ở bất kỳ hình thức hợp lý. Bạn không được sử dụng một công cụ tích hợp để tính toán trình tự tung hứng, hoặc bất kỳ công cụ tích hợp nào trực tiếp mang lại kết quả. Bạn có thể cho rằng chuỗi kết thúc trong 1.

Các trường hợp thử nghiệm

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

Đây là một mã golf. Mã ngắn nhất trong byte thắng.

Thạch , 12 11 10 byte

*BṪ×½Ḟµ’п

Cảm ơn @ Sp3000 vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đây là một hàm đệ quy chấp nhận một số nguyên và trả về một mảng float.

Chúng tôi xây dựng một mảng bằng cách nối đầu vào với số hạng tiếp theo của chuỗi, được tính là x với sức mạnh tương đương của nó cộng với 1/2. Điều này cho chúng ta x ^1/2 hoặc x ^{1 + 1/2} = x ^3/2 . Số nguyên chia cho 1 được sàn. Khi điều kiện x <3 là đúng, phần tử cuối cùng sẽ là Boolean chứ không phải là giá trị số, nhưng vì mảng không phải là kiểu Any, nên điều này được chọn để có cùng loại với phần còn lại của mảng.

Đã lưu 14 byte nhờ Dennis!

JavaScript (ES7), 45 33 byte

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

Giải trình

Phương pháp đệ quy. Trả về một chuỗi số được phân tách bằng dấu phẩy.

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
  )

Kiểm tra

** không được sử dụng trong thử nghiệm để tương thích trình duyệt.

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>

Toán học, 40 39 byte

Cảm ơn Martin Büttner vì đã tiết kiệm 1 byte.

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

Trường hợp thử nghiệm

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

Bình thường, 14 12 byte

.us@*B@N2NNQ

Trình diễn

Chúng tôi bắt đầu với việc giảm tích lũy, .u trong trường hợp này bắt đầu từ đầu vào và áp dụng một hàm cho đến khi kết quả lặp lại, tại thời điểm đó, nó đưa ra tất cả các kết quả trung gian.

Hàm lấy giá trị trước là N. Nó bắt đầu bằng cách lấy căn bậc hai của nó với @N2. Tiếp theo, nó chia đôi giá trị đó trên phép nhân Nvới *B ... N. Điều này tạo ra danh sách [N ** .5, (N ** .5) * N], kết quả không mong muốn cho các trường hợp chẵn và lẻ. Tiếp theo, kết quả không mong muốn thích hợp được chọn bằng cách lập chỉ mục vào danh sách với @ ... N. Vì Pyth có lập chỉ mục mô-đun, không có lỗi ngoài giới hạn nào được đưa ra. Cuối cùng, kết quả được thả nổi với s.

MATL, 13 12 byte

`tt2\.5+^ktq

Hãy thử trực tuyến!

Giải trình

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

Cảm ơn Luis vì đã tiết kiệm một byte!

Chồn 0,15 , 25 byte

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

Hãy thử nó ở đây!

Giải trình

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

Đầu vào đi vào @N:

DECLARE @N INT = 5;

Mã số:

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|⎕←⍵}⍣=⎕

Đây là một chương trình chấp nhận một số nguyên và in các đầu ra liên tiếp trên các dòng riêng biệt.

Giải trình:

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

Dùng thử trực tuyến

Đã lưu 8 byte nhờ 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));}

Ban đầu tôi đã sử dụng một forvòng lặp điển hình , nhưng tôi phải nhảy qua các vòng để nó hoạt động tốt. Sau khi ăn cắp mượn ý tưởng user81655 của để recurse thay vào đó, tôi đã nhận nó xuống mười hai byte.

Haskell, 70 byte

Haskell không có số nguyên tích sqrthợp, nhưng tôi nghĩ có thể có thứ gì đó ngắn hơn 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;

Không chơi gôn

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;

Thêm MOD (i, 2) vào .5 ngắn hơn nhưng có lỗi với POWER (2, .5):

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

cho

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

Đã lưu 3 byte nhờ plannapus.

CJam, 18 byte

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

Kiểm tra nó ở đây

Tương tự như câu trả lời MATL của David .

Python 3, 57 , 45 , 43 , 41 byte

Giải pháp tốt hơn với đề xuất từ ​​@mathmandan

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

Phương pháp này sẽ in mỗi số trên một dòng mới

Giải pháp trước: Giảm xuống còn 43 byte sau khuyến nghị của xnor

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

Bạn có thể gọi ở trên bằng cách a(10)trả về[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Ở trên sẽ xuất ra các giá trị dưới dạng float. Nếu bạn muốn chúng là số nguyên, thì chúng ta chỉ cần thêm 2 byte cho 43 byte:

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

TI-Basic, 30 byte

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

Tôi biết điều này có thể được chơi golf. Trả về một chuỗi các số được phân tách bằng dấu phẩy.

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

Lấy cảm hứng từ @ user81655 và @Alex A., tôi đã sử dụng đệ quy.

Võng mạc, 144 byte

Đầu vào và đầu ra là đơn nhất.

Dòng thứ 2 đến cuối cùng chứa một khoảng trắng, và hai dòng giữa và dòng cuối cùng trống.

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

Dùng thử trực tuyến

Giải trình

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

Căn bậc hai trong Retina , bởi 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

Tôi đang kéo Thomas Kwa và trả lời câu hỏi này trên điện thoại di động của tôi.

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

Thay thế sqrtbằng biểu tượng thực tế trên máy tính của bạn. Hiển thị danh sách các số được phân tách theo dòng, đây là định dạng hợp lý.

JavaScript ES6, 76 byte

Là một máy phát điện có tên j. Để sử dụng, thiết lập a = j(<your value>);. Để xem giá trị tiếp theo trong chuỗi, nhập a.next().value.

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

Ung dung:

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

Không chấm dứt ở 1, nhưng vẫn tiếp tục.

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

Sử dụng:

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

Phiên bản thực sự chấm dứt ở 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)))

Ung dung

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, cộng 1 cho -pEthay vì-e

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

Giải trình

Đầu tiên, -pđặt biến $_bằng với đầu vào từ stdin. Sau đó, chúng tôi bắt đầu một khối mã:

1. sayin $_.
2. $_=int$_**($_%2+.5)đặt $_bằng phần nguyên của { $_với lũy thừa của {{ $_modulo 2} + 0.5}}, do phép thuật của thứ tự các phép toán ( ưu tiên toán tử ). Nhiệm vụ này trả về giá trị mới của$_ và
3. (...)-1&&redokiểm tra giá trị trả về, trừ đi 1. Nếu chênh lệch là 0, không làm gì cả; nếu không, làm lại khối này.

Cuối cùng, -pin$_ .

Có độ dài bằng nhau

Cũng sử dụng -p.

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

Đây: bản in $_; phân công như trên; kiểm tra xem giá trị trả về của say(là 1), trừ đi giá trị mới của $_, là 0 và làm lại khối nếu có; sau đó in $_ở cuối

đc 22 21 byte

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

Giải thích:

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

Có một lỗi: Khi đầu vào là 1, đầu ra bao gồm hai 1s.