的杂耍序列被描述如下。从输入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Ṫ×½Ḟµ’п

感谢@ 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.

朱莉娅64 50 48 42 32 30字节

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

这是一个递归函数，它接受一个整数并返回一个float数组。

我们通过将输入与序列的下一项进行级联来构建数组，将其计算为x为其奇偶校验的幂加1/2。这给我们x ^1/2或x ^{1 + 1/2} = x ^3/2。整数除以1达到最低要求。当条件x <3为true时，最后一个元素将是布尔值而不是数字值，但是由于数组不是type Any，因此将其强制转换为与数组其余部分相同的类型。

感谢Dennis，节省了14个字节！

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字节

感谢MartinBüttner节省了1个字节。

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

测试用例

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

Pyth，14 12字节

.us@*B@N2NNQ

示范

我们从累积归约.u开始，在这种情况下，它从输入开始并应用一个函数，直到结果重复为止，这时它将输出所有中间结果。

该函数将先前的值作为N。它以的平方根开始@N2。接下来，它将N与乘以该值*B ... N。这将创建list [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

感谢路易斯保存一个字节！

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个字节！

Java 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个字节。

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）添加到.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

多亏了Plannapus，节省了3个字节。

CJam，18个字节

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

在这里测试

类似于David的MATL答案。

Python 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]

上面的将值输出为浮点数。如果您想将它们作为整数，那么我们可以为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

的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字节

输入和输出均为一元。

倒数第二行包含一个空格，中间的两行和最后一行为空。

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

数字创伤在视网膜中的整数平方根

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个字节

我要拉托马斯·夸（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为计算器上的实际符号。显示换行符分隔的数字列表，这是一种合理的格式。

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}

取消高尔夫：

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

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，则不执行任何操作；否则，返回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，输出包含两个1。