La séquence du jongleur est décrite comme suit. En commençant par une entrée a ₁ , le terme suivant est défini par la relation de récurrence

La séquence se termine lorsqu'elle atteint 1, car tous les termes suivants seraient alors 1.

Tâche

Étant donné une entrée nsupérieure ou égale à 2, écrivez un programme / fonction / générateur / etc. qui génère / renvoie la séquence de jongleur respective. La sortie peut être sous n'importe quelle forme raisonnable. Vous ne pouvez pas utiliser un module intégré qui calcule la séquence du jongleur ou un module intégré qui donne directement le résultat. Vous pouvez supposer que la séquence se termine en 1.

Cas de 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

Ceci est un golf de code. Le code le plus court en octets gagne.

Gelée , 12 11 10 octets

*BṪ×½Ḟµ’п

Merci à @ Sp3000 d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Comment ça fonctionne

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

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

Il s'agit d'une fonction récursive qui accepte un entier et renvoie un tableau flottant.

Nous construisons un tableau en concaténant l'entrée avec le terme suivant de la séquence, calculé comme x à la puissance de sa parité plus 1/2. Cela nous donne soit x ^1/2 ou x ^{1 + 1/2} = x ^3/2 . La division entière par 1 obtient la parole. Lorsque la condition x <3 est vraie, l'élément final sera un booléen plutôt qu'une valeur numérique, mais comme le tableau n'est pas de type Any, il est converti pour avoir le même type que le reste du tableau.

14 octets enregistrés grâce à Dennis!

JavaScript (ES7), 45 33 octets

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

Explication

Approche récursive. Renvoie une chaîne de nombres séparés par des virgules.

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
  )

Tester

** non utilisé dans le test de compatibilité du navigateur.

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 octets

Merci à Martin Büttner pour avoir économisé 1 octet.

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

Cas de test

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

Pyth, 14 12 octets

.us@*B@N2NNQ

Manifestation

Nous commençons par une réduction cumulative, .u , qui dans ce cas commence à l'entrée et applique une fonction jusqu'à ce que le résultat se répète, auquel cas il génère tous les résultats intermédiaires.

La fonction prend la valeur précédente comme N. Il commence par prendre sa racine carrée avec @N2. Ensuite, il bifurque cette valeur lors de la multiplication par Navec *B ... N. Cela crée la liste [N ** .5, (N ** .5) * N], les résultats sans étage pour les cas pairs et impairs. Ensuite, le résultat sans étage approprié est sélectionné en l'indexant dans la liste avec @ ... N. Étant donné que Pyth dispose d'une indexation modulaire, aucune erreur hors limites n'est levée. Enfin, le résultat est terrassé par s.

MATL, 13 12 octets

`tt2\.5+^ktq

Essayez-le en ligne!

Explication

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

Merci Luis d'avoir sauvé un octet!

Minkolang 0,15 , 25 octets

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

Essayez-le ici!

Explication

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 octets

L'entrée entre @N:

DECLARE @N INT = 5;

Code:

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 octets

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

Il s'agit d'un programme qui accepte un entier et imprime les sorties successives sur des lignes distinctes.

Explication:

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

Essayez-le en ligne

8 octets enregistrés grâce à Dennis!

Java 7, 83 71 octets

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

J'ai utilisé à l'origine une forboucle typique , mais j'ai dû sauter à travers des cerceaux pour que cela fonctionne correctement. Après avoir volé l'idée d' emprunter à user81655 pour recurse , je l'ai fait descendre de douze octets.

Haskell, 70 octets

Haskell n'a pas de nombre entier sqrtintégré, mais je pense qu'il peut y avoir quelque chose de plus court 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 octets

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;

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

L'ajout de MOD (i, 2) à 0,5 est plus court mais il y a un bogue avec POWER (2, 0,5):

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

donne

2   1   1,99999999999999999999999999999999999999

R, 54 51 octets

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

Enregistré 3 octets grâce à plannapus.

CJam, 18 octets

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

Testez-le ici

Similaire à la réponse MATL de David .

Python 3, 57 , 45 , 43 , 41 octets

Meilleure solution avec la suggestion de @mathmandan

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

Cette méthode imprime chaque numéro sur une nouvelle ligne

Solution précédente: réduit à 43 octets après la recommandation de xnor

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

Vous pouvez appeler ce qui précède en faisant a(10)ce qui retourne[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Ce qui précède affichera les valeurs sous forme de flottants. Si vous les voulez sous forme d'entiers, nous pouvons simplement ajouter 2 octets supplémentaires pour 43 octets:

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

TI-Basic, 30 octets

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

JavaScript ES6, 109 102 octets

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

Je sais que cela peut être joué au golf. Renvoie une chaîne de nombres séparés par des virgules.

C ++, 122 octets

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

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

Inspiré par @ user81655 et @Alex A., j'ai utilisé la récursivité.

Rétine, 144 octets

L'entrée et la sortie sont unaires.

L'avant-dernière ligne contient un espace, et les deux lignes du milieu et la dernière ligne sont vides.

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

Essayez-le en ligne

Explication

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

Racine carrée entière dans la rétine , par Digital Trauma

C, 64 63 61 octets

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

TI BASIC, 43 octets

Je tire un Thomas Kwa et je réponds à celui-ci sur mon mobile.

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

Remplacer sqrt par le symbole réel sur votre calculatrice. Affiche une liste de nombres séparés par des sauts de ligne, qui est un format raisonnable.

JavaScript ES6, 76 octets

Est un générateur nommé j. Pour utiliser, réglez a = j(<your value>);. Pour voir la valeur suivante de la séquence, entrez a.next().value.

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

Non 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 octets

Ne se termine pas à 1, mais continue.

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

Usage:

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

Version qui se termine réellement à 1, 100 octets

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

Non 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 octets

33, plus 1 pour -pEau lieu de-e

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

Explication

Tout d'abord, -pdéfinit la variable $_égale à l'entrée de stdin. Ensuite, nous commençons un bloc de code:

1. sayimpressions $_.
2. $_=int$_**($_%2+.5)ensembles $_égaux à la partie entière de { $_à la puissance de {{ $_modulo 2} + 0,5}}, en raison de la magie de l'ordre des opérations ( priorité de l'opérateur ). Cette affectation renvoie la nouvelle valeur de $_, et
3. (...)-1&&redotests qui ont renvoyé une valeur, moins 1. Si la différence est 0, ne faites rien; sinon, refaites ce bloc.

Enfin, les -pimpressions$_ .

De longueur égale

Utilise également -p.

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

Cela: imprime $_; attribue comme ci-dessus; teste si la valeur de retour de say(qui est 1), moins la nouvelle valeur de $_, est 0 et refait le bloc si c'est le cas; puis imprime $_à la fin.

dc, 22 21 octets

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

Expliqué:

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

Il y a un bug: lorsque l'entrée est 1, la sortie se compose de deux 1s.