Die Jongleursequenz wird wie folgt beschrieben. Beginnend mit einer Eingabe a ₁ wird der nächste Term durch die Wiederholungsrelation definiert

Die Sequenz endet, wenn sie 1 erreicht, da alle nachfolgenden Terme dann 1 wären.

Aufgabe

nSchreiben Sie bei einer Eingabe größer oder gleich 2 ein Programm / eine Funktion / einen Generator / usw. das gibt die jeweilige Jongleur-Sequenz aus / gibt sie zurück. Die Ausgabe kann in jeder vernünftigen Form erfolgen. Sie dürfen kein eingebautes Programm verwenden, das die Jongleursequenz berechnet, oder ein eingebautes Programm, das direkt das Ergebnis liefert. Sie können davon ausgehen, dass die Sequenz in endet 1.

Testfälle

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

Dies ist ein Code Golf. Kürzester Code in Bytes gewinnt.

Jelly , 12 11 10 Bytes

*BṪ×½Ḟµ’п

Vielen Dank an @ Sp3000 für das Golfen ab 1 Byte!

Probieren Sie es online!

Wie es funktioniert

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

Dies ist eine rekursive Funktion, die eine Ganzzahl akzeptiert und ein Float-Array zurückgibt.

Wir erstellen ein Array, indem wir die Eingabe mit dem nächsten Term der Sequenz verketten, der als x mit der Potenz seiner Parität plus 1/2 berechnet wird . Dies ergibt entweder x ^1/2 oder x ^{1 + 1/2} = x ^3/2 . Ganzzahlige Division durch 1 ergibt das Wort. Wenn die Bedingung x <3 wahr ist, ist das letzte Element ein Boolescher Wert und kein numerischer Wert. Da das Array jedoch nicht vom Typ ist Any, wird es so umgewandelt, dass es den gleichen Typ wie der Rest des Arrays hat.

14 Bytes gespart dank Dennis!

JavaScript (ES7), 45 33 Bytes

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

Erläuterung

Rekursiver Ansatz. Gibt eine durch Kommas getrennte Folge von Zahlen zurück.

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
  )

Prüfung

** Wird im Test für die Browserkompatibilität nicht verwendet.

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

Vielen Dank an Martin Büttner für das Speichern von 1 Byte.

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

Testfall

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

Pyth, 14 12 Bytes

.us@*B@N2NNQ

Demonstration

Wir beginnen mit einer kumulativen Reduzierung, .u die in diesem Fall bei der Eingabe beginnt und eine Funktion anwendet, bis sich das Ergebnis wiederholt, und an diesem Punkt alle Zwischenergebnisse ausgibt.

Die Funktion nimmt den vorherigen Wert als an N. Es beginnt mit der Quadratwurzel @N2. Als nächstes teilt es diesen Wert bei der Multiplikation mit Nmit *B ... N. Dies erzeugt die Liste [N ** .5, (N ** .5) * N], die unbegründeten Ergebnisse für die geraden und ungeraden Fälle. Als nächstes wird das entsprechende unbodenständige Ergebnis durch Indizieren in die Liste mit ausgewählt @ ... N. Da Pyth über eine modulare Indizierung verfügt, werden keine Out-of-Bound-Fehler ausgegeben. Schließlich ist das Ergebnis mit bodenständig s.

MATL, 13 - 12 Bytes

`tt2\.5+^ktq

Probieren Sie es online!

Erläuterung

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

Danke Luis für das Speichern eines Bytes!

Minkolang 0,15 , 25 Bytes

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

Probieren Sie es hier aus!

Erläuterung

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

Eingabe erfolgt in @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 Bytes

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

Dies ist ein Programm, das eine Ganzzahl akzeptiert und die aufeinanderfolgenden Ausgaben in separaten Zeilen ausgibt.

Erläuterung:

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

Probieren Sie es online aus

8 Bytes gespart dank 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));}

Ich habe ursprünglich eine typische forSchleife verwendet, musste aber durch die Reifen springen, damit sie richtig funktioniert. Nach dem Diebstahl Kreditaufnahme Idee user81655 die statt Rekursion, habe ich es auf zwölf Bytes.

Haskell, 70 Bytes

In Haskell ist keine Ganzzahl sqrtintegriert, aber ich denke, es ist möglicherweise etwas kürzer als 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;

Nicht golfen

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;

Das Hinzufügen von MOD (i, 2) zu .5 ist kürzer, aber es gibt einen Fehler mit POWER (2, .5):

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

gibt

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

3 Bytes gespart dank Plannapus.

CJam, 18 Bytes

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

Teste es hier

Ähnlich wie Davids MATL-Antwort .

Python 3, 57 , 45 , 43 , 41 Bytes

Bessere Lösung mit Vorschlag von @mathmandan

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

Diese Methode druckt jede Nummer in einer neuen Zeile

Vorherige Lösung: Nach Empfehlung von xnor auf 43 Byte reduzieren

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

Sie können das oben genannte aufrufen, indem Sie tun, a(10)was zurückgibt[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Das obige gibt die Werte als Float aus. Wenn Sie sie als Ganzzahlen haben möchten, können Sie für 43 Bytes einfach 2 zusätzliche Bytes hinzufügen:

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

Ich weiß, dass man Golf spielen kann. Gibt eine Zeichenfolge von durch Kommas getrennten Zahlen zurück.

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

Inspiriert von @ user81655 und @ Alex A. habe ich die Rekursion verwendet.

Netzhaut, 144 Bytes

Eingabe und Ausgabe sind unär.

Die vorletzte Zeile enthält ein Leerzeichen, und die beiden mittleren Zeilen und die letzte Zeile sind leer.

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

Probieren Sie es online aus

Erläuterung

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

Ganzzahlige Quadratwurzel in der Netzhaut , von 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

Ich ziehe einen Thomas Kwa und beantworte diesen auf meinem Handy.

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

Ersetzen Sie sqrtmit dem tatsächlichen Symbol auf Ihrem Rechner. Zeigt eine durch Zeilenvorschub getrennte Liste von Zahlen an. Dies ist ein angemessenes Format.

JavaScript ES6, 76 Bytes

Ist ein Generator namens j. Zum Verwenden einstellen a = j(<your value>);. Geben Sie ein, um den nächsten Wert in der Sequenz anzuzeigena.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 Bytes

Endet nicht bei 1, sondern geht weiter.

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

Verwendung:

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

Version, die tatsächlich bei 1, 100 Bytes endet

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 Bytes

33, plus 1 für -pEstatt-e

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

Erläuterung

Zuerst -psetzt die Variable $_gleich den Eingang von stdin. Dann starten wir einen Codeblock:

1. saydruckt $_.
2. $_=int$_**($_%2+.5)setzt $_gleich dem ganzzahligen Teil von { $_hoch hoch $_hoch von {{ modulo 2} + 0.5}}, aufgrund der magischen Reihenfolge der Operationen ( Operator-Rangfolge ). Diese Zuweisung gibt den neuen Wert von $_und zurück
3. (...)-1&&redotestet den zurückgegebenen Wert minus 1. Wenn die Differenz 0 ist, nichts tun; Andernfalls wiederholen Sie diesen Block.

Schließlich -pdruckt$_ .

Gleicher Länge

Verwendet auch -p.

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

Dies: druckt $_; weist wie oben zu; testet, ob der Rückgabewert von say(der 1 ist) minus dem neuen Wert von $_0 ist, und wiederholt den Block, wenn dies der Fall ist; druckt dann $_am Ende.

dc, 22 21 Bytes

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

Erklärt:

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

Es gibt einen Fehler: Wenn der Eingang ist 1, besteht der Ausgang aus zwei 1s.