La secuencia del malabarista se describe como sigue. Comenzando con una entrada a ₁ , el siguiente término se define por la relación de recurrencia

La secuencia termina cuando alcanza 1, ya que todos los términos posteriores serían 1.

Tarea

Dada una entrada nmayor o igual a 2, escriba un programa / función / generador / etc. que genera / devuelve la secuencia de malabarista respectiva. La salida puede ser de cualquier forma razonable. No puede usar un incorporado que calcule la secuencia del malabarista, o cualquier incorporado que produzca directamente el resultado. Puede suponer que la secuencia termina en 1.

Casos de prueba

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

Este es un código de golf. El código más corto en bytes gana.

Jalea , 12 11 10 bytes

*BṪ×½Ḟµ’п

¡Gracias a @ Sp3000 por jugar golf en 1 byte!

Pruébalo en línea!

Cómo funciona

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

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

Esta es una función recursiva que acepta un número entero y devuelve una matriz flotante.

Construimos una matriz concatenando la entrada con el siguiente término de la secuencia, calculada como x a la potencia de su paridad más 1/2. Esto nos da x ^1/2 o x ^{1 + 1/2} = x ^3/2 . La división entera por 1 toma la palabra. Cuando la condición x <3 es verdadera, el elemento final será un valor booleano en lugar de un valor numérico, pero como la matriz no es de tipo Any, se convierte para tener el mismo tipo que el resto de la matriz.

¡Guardado 14 bytes gracias a Dennis!

JavaScript (ES7), 45 33 bytes

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

Explicación

Enfoque recursivo. Devuelve una cadena de números separados por comas.

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
  )

Prueba

** no se utiliza en la prueba de compatibilidad del navegador.

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 bytes

Gracias a Martin Büttner por guardar 1 byte.

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

Caso de prueba

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

Pyth, 14 12 bytes

.us@*B@N2NNQ

Demostración

Comenzamos con una reducción acumulativa, .u , que en este caso comienza en la entrada y aplica una función hasta que se repite el resultado, en cuyo punto genera todos los resultados intermedios.

La función toma el valor anterior como N. Comienza tomando su raíz cuadrada con @N2. Luego, bifurca ese valor en la multiplicación por Ncon*B ... N . Esto crea la lista [N ** .5, (N ** .5) * N], los resultados sin explorar para los casos pares e impares. A continuación, se selecciona el resultado sin explorar apropiado indexando en la lista con @ ... N. Dado que Pyth tiene indexación modular, no se arrojan errores fuera de los límites. Finalmente, el resultado es anulado s.

MATL, 13 12 bytes

`tt2\.5+^ktq

Pruébalo en línea!

Explicación

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

¡Gracias Luis por salvar un byte!

Minkolang 0.15 , 25 bytes

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

Pruébalo aquí!

Explicación

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 bytes

La entrada entra @N:

DECLARE @N INT = 5;

Código:

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 bytes

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

Este es un programa que acepta un número entero e imprime las salidas sucesivas en líneas separadas.

Explicación:

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

Pruébalo en línea

¡Guardado 8 bytes gracias a Dennis!

Java 7, 83 71 bytes

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

Originalmente utilicé un forbucle típico , pero tuve que saltar a través de los aros para que funcionara correctamente. Después de robar prestado la idea de user81655 para recurrir en su lugar, obtuve doce bytes.

Haskell, 70 bytes

Haskell no tiene un número entero sqrtincorporado, pero creo que puede haber algo más corto que 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 bytes

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;

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

Agregar MOD (i, 2) a .5 es más corto pero hay un error con POWER (2, .5):

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

da

2   1   1,99999999999999999999999999999999999999

R, 54 51 bytes

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

Guardado 3 bytes gracias a plannapus.

CJam, 18 bytes

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

Pruébalo aquí

Similar a la respuesta MATL de David .

Python 3, 57 , 45 , 43 , 41 bytes

Mejor solución con sugerencia de @mathmandan

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

Este método imprimirá cada número en una nueva línea.

Solución anterior: Reduzca a 43 bytes después de la recomendación de xnor

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

Puede llamar a lo anterior haciendo a(10)qué devuelve[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Lo anterior generará los valores como flotantes. Si los quiere como enteros, entonces podemos agregar 2 bytes adicionales por 43 bytes:

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 bytes

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

Yo sé que esto puede ser golfed. Devuelve una cadena de números separados por comas.

C ++, 122 bytes

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

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

Inspirado por @ user81655 y @Alex A., utilicé la recursividad.

Retina, 144 bytes

La entrada y la salida están en unario.

La penúltima línea contiene un espacio, y las dos líneas medias y la última línea están vacías.

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

Pruébalo en línea

Explicación

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

Raíz cuadrada entera en retina , por Digital Trauma

C, 64 63 61 bytes

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

TI BASIC, 43 bytes

Estoy sacando un Thomas Kwa y respondiendo este en mi móvil.

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

Reemplace sqrtcon el símbolo real en su calculadora. Muestra una lista de números separada por salto de línea, que es un formato razonable.

JavaScript ES6, 76 bytes

Es un generador llamado j. Para usar, establecer a = j(<your value>);. Para ver el siguiente valor en la secuencia, ingrese a.next().value.

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

Sin golf:

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 bytes

No termina en 1, pero continúa.

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

Uso:

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

Versión que realmente termina en 1, 100 bytes

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

Sin golf

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 bytes

33, más 1 para en -pElugar de-e

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

Explicación

Primero, -pestablece la variable $_igual a la entrada de stdin. Luego comenzamos un bloque de código:

1. sayimpresiones $_.
2. $_=int$_**($_%2+.5)establece $_igual a la parte entera de { $_a la potencia de {{ $_módulo 2} + 0.5}}, debido a la magia del orden de operaciones ( precedencia del operador ). Esta asignación devuelve el nuevo valor de$_ y
3. (...)-1&&redoprueba ese valor devuelto, menos 1. Si la diferencia es 0, no haga nada; de lo contrario, vuelva a hacer este bloque.

Finalmente, -pimpresiones$_ .

De igual longitud

También utiliza -p.

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

Esto: impresiones $_; asigna como arriba; prueba si el valor de retorno de say(que es 1), menos el nuevo valor de $_, es 0, y rehace el bloque si es así; luego imprime $_al final.

corriente continua, 22 21 bytes

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

Explicado:

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

Hay un error: cuando la entrada es 1, la salida consta de dos 1s.