La sequenza di giocolieri è descritta come segue. A partire da un input a ₁ , il termine successivo è definito dalla relazione di ricorrenza

La sequenza termina quando raggiunge 1, poiché tutti i termini successivi sarebbero quindi 1.

Compito

Dato un input nmaggiore o uguale a 2, scrivere un programma / funzione / generatore / ecc. che genera / restituisce la rispettiva sequenza di giocolieri. L'output può essere in qualsiasi forma ragionevole. Non è possibile utilizzare un built-in che calcola la sequenza di giocolieri o qualsiasi built-in che produca direttamente il risultato. Si può presumere che la sequenza termini 1.

Casi test

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

Questo è un codice golf. Vince il codice più breve in byte.

Gelatina , 12 11 10 byte

*BṪ×½Ḟµ’п

Grazie a @ Sp3000 per giocare a golf a 1 byte!

Provalo online!

Come funziona

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

Questa è una funzione ricorsiva che accetta un numero intero e restituisce un array float.

Costruiamo un array concatenando l'input con il termine successivo della sequenza, calcolato come x in base alla potenza della sua parità più 1/2. Questo ci dà x ^1/2 o x ^{1 + 1/2} = x ^3/2 . La divisione intera per 1 ottiene la parola. Quando la condizione x <3 è vera, l'elemento finale sarà un valore booleano anziché un valore numerico, ma poiché l'array non è di tipo Any, questo viene trasmesso per avere lo stesso tipo del resto dell'array.

Salvato 14 byte grazie a Dennis!

JavaScript (ES7), 45 33 byte

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

Spiegazione

Approccio ricorsivo Restituisce una stringa di numeri separata da virgole.

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
  )

Test

** non utilizzato nel test per la compatibilità del 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

Grazie a Martin Büttner per aver salvato 1 byte.

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

Caso di prova

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

Pyth, 14 12 byte

.us@*B@N2NNQ

Dimostrazione

Iniziamo con una riduzione cumulativa .u, che in questo caso inizia all'ingresso e applica una funzione fino a quando il risultato non si ripete, a quel punto restituisce tutti i risultati intermedi.

La funzione assume il valore precedente come N. Inizia prendendo la sua radice quadrata con @N2. Successivamente, biforcerà quel valore sulla moltiplicazione per Ncon *B ... N. Questo crea l'elenco [N ** .5, (N ** .5) * N], i risultati non piani per i casi pari e dispari. Successivamente, il risultato appropriato non selezionato viene selezionato indicizzandolo nell'elenco con @ ... N. Poiché Pyth ha l'indicizzazione modulare, non vengono generati errori fuori limite. Alla fine, il risultato è a terra s.

MATL, 13 12 byte

`tt2\.5+^ktq

Provalo online!

Spiegazione

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

Grazie Luis per aver salvato un byte!

Minkolang 0,15 , 25 byte

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

Provalo qui!

Spiegazione

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

L'ingresso entra @N:

DECLARE @N INT = 5;

Codice:

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

Questo è un programma che accetta un numero intero e stampa gli output successivi su righe separate.

Spiegazione:

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

Provalo online

Risparmiato 8 byte grazie a 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));}

Inizialmente utilizzavo un forciclo tipico , ma ho dovuto saltare attraverso i cerchi per farlo funzionare correttamente. Dopo aver rubato in prestito l'idea di user81655 di ricorrere invece, l'ho ridotto di dodici byte.

Haskell, 70 byte

Haskell non ha numeri interi sqrtintegrati, ma penso che ci potrebbe essere qualcosa di più corto di 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;

Un-golfed

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;

L'aggiunta di MOD (i, 2) a .5 è più breve ma è presente un bug con POWER (2, .5):

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

dà

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

Salvato 3 byte grazie a plannapus.

CJam, 18 byte

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

Provalo qui

Simile alla risposta MATL di David .

Python 3, 57 , 45 , 43 , 41 byte

Soluzione migliore con il suggerimento di @mathmandan

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

Questo metodo stampa ogni numero su una nuova riga

Soluzione precedente: ridurre a 43 byte dopo la raccomandazione di xnor

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

È possibile chiamare quanto sopra facendo a(10)quale restituisce[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Quanto sopra genererà i valori come float. Se li vuoi come numeri interi, allora possiamo semplicemente aggiungere altri 2 byte per 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")

Io so questo può essere giocato a golf. Restituisce una stringa di numeri separati da virgola.

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

Ispirato da @ user81655 e @Alex A., ho usato la ricorsione.

Retina, 144 byte

Ingresso e uscita sono unari.

La penultima riga contiene uno spazio e le due righe centrali e l'ultima riga sono vuote.

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

Provalo online

Spiegazione

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

Radice quadrata intera in Retina , di 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

Sto tirando un Thomas Kwa e rispondo a questo sul mio cellulare.

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

Sostituire sqrtcon il simbolo reale sulla calcolatrice. Visualizza un elenco separato di numeri di avanzamento riga, che è un formato ragionevole.

JavaScript ES6, 76 byte

È un generatore di nome j. Per usare, impostare a = j(<your value>);. Per vedere il valore successivo nella sequenza, immettere 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 byte

Non termina con 1, ma continua.

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; ...]

Versione che termina effettivamente a 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)))

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 byte

33, più 1 per -pEanziché-e

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

Spiegazione

Innanzitutto, -pimposta la variabile $_uguale all'input di stdin. Quindi iniziamo un blocco di codice:

1. saystampe $_.
2. $_=int$_**($_%2+.5)imposta $_uguale alla parte intera di { $_alla potenza di {{ $_modulo 2} + 0,5}}, a causa della magia dell'ordine delle operazioni ( precedenza dell'operatore ). Questa assegnazione restituisce il nuovo valore di $_, e
3. (...)-1&&redotest che hanno restituito valore, meno 1. Se la differenza è 0, non fare nulla; altrimenti, ripetere questo blocco.

Infine, -pstampa $_.

Di uguale lunghezza

Utilizza anche -p.

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

Questo: stampe $_; assegna come sopra; verifica se il valore restituito di say(che è 1), meno il nuovo valore di $_, è 0, e ripristina il blocco in tal caso; quindi stampa $_alla fine.

dc, 22 21 byte

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

Ha spiegato:

[                # 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'è un bug: quando l'input è 1, l'output è composto da due 1s.