Sekwencja balansista jest opisany w następujący sposób. Począwszy od wejścia ₁ , następny okres jest określony przez stosunek nawrotu

Sekwencja kończy się, gdy osiągnie 1, ponieważ wszystkie kolejne warunki byłyby wówczas 1.

Zadanie

Biorąc pod uwagę wejście nwiększe lub równe 2, napisz program / funkcję / generator / itp. który wyprowadza / zwraca odpowiednią sekwencję żonglera. Wynik może być w dowolnej rozsądnej formie. Nie możesz używać wbudowanego, który oblicza sekwencję żonglera, ani żadnego wbudowanego, który bezpośrednio daje wynik. Możesz założyć, że sekwencja kończy się w 1.

Przypadki testowe

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

To jest golf golfowy. Najkrótszy kod w bajtach wygrywa.

Galaretka , 12 11 10 bajtów

*BṪ×½Ḟµ’п

Dzięki @ Sp3000 za grę w golfa przy 1 bajcie!

Wypróbuj online!

Jak to działa

*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 bajtów

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

Jest to funkcja rekurencyjna, która przyjmuje liczbę całkowitą i zwraca tablicę zmiennoprzecinkową.

Budujemy tablicę, łącząc dane wejściowe z następnym terminem sekwencji, obliczonym jako x do potęgi jego parzystości powiększonej o 1/2. To daje nam albo x ^1/2, albo x ^{1 + 1/2} = x ^3/2 . Podział na liczby całkowite przez 1 otrzymuje podłogę. Gdy warunek x <3 jest prawdziwy, końcowym elementem będzie wartość logiczna, a nie wartość liczbowa, ale ponieważ tablica nie jest typu Any, rzutowany jest tak, aby miał ten sam typ co reszta tablicy.

Zaoszczędzono 14 bajtów dzięki Dennisowi!

JavaScript (ES7), 45 33 bajtów

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

Wyjaśnienie

Podejście rekurencyjne. Zwraca ciąg liczb oddzielony przecinkami.

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

** nieużywany w teście zgodności przeglądarki.

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>

Matematyka, 40 39 bajtów

Podziękowania dla Martina Büttnera za oszczędność 1 bajtu.

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

Przypadek testowy

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

Pyth, 14 12 bajtów

.us@*B@N2NNQ

Demonstracja

Zaczynamy od skumulowanego zmniejszenia, .u które w tym przypadku rozpoczyna się na wejściu i stosuje funkcję do momentu powtórzenia wyniku, w którym to momencie wyprowadza wszystkie wyniki pośrednie.

Funkcja przyjmuje poprzednią wartość jako N. Zaczyna się od pierwiastka kwadratowego z @N2. Następnie, rozwidla tę wartość na mnożenie przez Nz *B ... N. Spowoduje to utworzenie listy [N ** .5, (N ** .5) * N]bez wyników dla nieparzystych i nieparzystych przypadków. Następnie odpowiedni niepochlebny wynik jest wybierany przez indeksowanie do listy za pomocą @ ... N. Ponieważ Pyth ma modułowe indeksowanie, nie są zgłaszane żadne błędy poza zakresem. Ostatecznie wynik jest zapisany za pomocą s.

MATL, 13 12 bajtów

`tt2\.5+^ktq

Wypróbuj online!

Wyjaśnienie

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

Dzięki Luis za uratowanie bajtu!

Minkolang 0,15 , 25 bajtów

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

Wypróbuj tutaj!

Wyjaśnienie

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 bajtów

Wejście wchodzi @N:

DECLARE @N INT = 5;

Kod:

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 bajtów

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

Jest to program, który przyjmuje liczbę całkowitą i drukuje kolejne wyjścia w osobnych wierszach.

Wyjaśnienie:

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

Wypróbuj online

Zaoszczędź 8 bajtów dzięki Dennisowi!

Java 7, 83 71 bajtów

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

Pierwotnie użyłem typowej forpętli, ale musiałem przeskoczyć przez obręcze, aby dobrze działała. Po kradzieży pożyczonego przez użytkownika pomysłu użytkownika 81655 na powtórkę, zmniejszyłem go o dwanaście bajtów.

Haskell, 70 bajtów

Haskell nie ma sqrtwbudowanej liczby całkowitej , ale myślę, że może być coś krótszego niż 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 bajtów

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;

Nie grał w golfa

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;

Dodanie MOD (i, 2) do .5 jest krótsze, ale występuje błąd w POWER (2, .5):

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

daje

2   1   1,99999999999999999999999999999999999999

R, 54 51 bajtów

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

Zaoszczędź 3 bajty dzięki plannapusowi.

CJam, 18 bajtów

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

Sprawdź to tutaj

Podobne do odpowiedzi MATL Dawida .

Python 3, 57 , 45 , 43 , 41 bajtów

Lepsze rozwiązanie dzięki sugestii @mathmandan

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

Ta metoda wydrukuje każdy numer w nowym wierszu

Poprzednie rozwiązanie: Zmniejsz do 43 bajtów po zaleceniu xnor

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

Możesz zadzwonić do powyższego, robiąc, a(10)który zwraca[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Powyższe wyświetli wartości jako liczby zmiennoprzecinkowe. Jeśli chcesz je jako liczby całkowite, możemy po prostu dodać dodatkowe 2 bajty dla 43 bajtów:

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

TI-Basic, 30 bajtów

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

JavaScript ES6, 109 102 bajtów

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

Ja wiem, można to grałem. Zwraca ciąg liczb oddzielonych przecinkami.

C ++, 122 bajty

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

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

Zainspirowany przez @ user81655 i @Alex A., użyłem rekurencji.

Siatkówka, 144 bajty

Wejścia i wyjścia są jednostkowe.

Przedostatni wiersz zawiera spację, a dwie środkowe linie i ostatni wiersz są puste.

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

Wypróbuj online

Wyjaśnienie

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

Liczba całkowita pierwiastek kwadratowy w siatkówce , według Digital Trauma

C, 64 63 61 bajtów

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

TI BASIC, 43 bajty

Wyciągam Thomasa Kwa i odbieram ten na telefonie komórkowym.

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

Zamień sqrtna rzeczywisty symbol na kalkulatorze. Wyświetla listę liczb oddzieloną od linii, co jest rozsądnym formatem.

JavaScript ES6, 76 bajtów

Jest generatorem o nazwie j. Aby użyć, ustawa = j(<your value>); . Aby zobaczyć następną wartość w sekwencji, wprowadź a.next().value.

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

Nie golfowany:

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 bajtów

Nie kończy się na 1, ale kontynuuje.

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

Stosowanie:

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

Wersja, która faktycznie kończy się na 1, 100 bajtów

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

Bez golfa

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 bajtów

33, plus 1 za -pEzamiast-e

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

Wyjaśnienie

Najpierw -pustawia zmienną $_równą wartości wejściowej ze standardowego wejścia. Następnie uruchamiamy blok kodu:

1. sayodbitki $_.
2. $_=int$_**($_%2+.5)zestawy $_równe części całkowitej { $_do potęgi {{ $_modulo 2} + 0,5}}, ze względu na magię kolejności operacji ( pierwszeństwo operatora ). To przypisanie zwraca nową wartość$_ i
3. (...)-1&&redotesty, które zwróciły wartość minus 1. Jeśli różnica wynosi 0, nie rób nic; w przeciwnym razie powtórz ten blok.

Wreszcie -pdruki $_.

Równej długości

Używa również -p.

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

To: drukuje $_; przypisuje jak wyżej; sprawdza, czy zwracana wartość say(która wynosi 1), minus nowa wartość $_, wynosi 0, a jeśli tak, to przerywa blok; następnie drukuje $_na końcu.

dc 22 21 bajtów

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

Wyjaśniono:

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

Wystąpił błąd: gdy wejście jest 1, wyjście składa się z dwóch 1s.