Jonglörüm dizisi aşağıdaki gibi tarif edilir. Bir giriş ile başlayarak , bir ₁ , sonraki terim nüks denklem ile ifade edilir

Sıra, 1'e ulaştığında sona erer, çünkü sonraki tüm terimler 1 olur.

Görev

n2 veya daha büyük bir girdi verildiğinde , bir program / fonksiyon / jeneratör / vb. Yazın. ilgili hokkabaz dizisini çıktılar / döndürür. Çıktı herhangi bir makul biçimde olabilir. Hokkabaz dizisini hesaplayan bir yerleşik veya doğrudan sonucu veren herhangi bir yerleşik kullanamazsınız. Sekansın sona erdiğini varsayabilirsiniz 1.

Test Durumları

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

Bu bir kod golf. Bayt cinsinden en kısa kod kazanır.

Jöle , 12 11 10 bayt

*BṪ×½Ḟµ’п

1 bayt golf için @ Sp3000 sayesinde!

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Bu, bir tamsayıyı kabul eden ve bir kayan noktalı dizi döndüren özyinelemeli bir işlevdir.

Girdiyi , parite artı 1/2 gücüne x olarak hesaplanan dizinin bir sonraki terimi ile birleştirerek bir dizi oluştururuz . Bu bize x ^1/2 veya x ^{1 + 1/2} = x ^{3/2 verir} . Tamsayı 1'e bölüyor. X <3 koşulu doğru olduğunda, son öğe sayısal bir değer yerine bir Boolean olur, ancak dizi tür olmadığından bu, dizinin Anygeri kalanıyla aynı türe sahip olacak şekilde verilir.

Dennis sayesinde 14 bayt tasarruf etti!

JavaScript (ES7), 45 33 bayt

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

açıklama

Özyinelemeli yaklaşım. Virgülle ayrılmış bir sayı dizesi döndürür.

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
  )

Ölçek

** tarayıcı uyumluluğu için testte kullanılmaz.

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 bayt

1 bayt tasarruf sağladığı için Martin Büttner'a teşekkürler.

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

Test durumu

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

Pyth, 14 12 bayt

.us@*B@N2NNQ

gösteri

Kümülatif bir azaltmayla başlıyoruz, .u başlıyoruz, bu durumda girişte başlar ve sonuç tekrarlanana kadar bir işlev uygular, bu noktada tüm ara sonuçların çıktısını verir.

İşlev önceki değeri olarak alır N. Kare kökünü alarak başlar @N2. Daha sonra, o tarafından çarpma üzerine bu değeri ikiye bölen Nile *B ... N. Bu liste oluşturur, [N ** .5, (N ** .5) * N]çift ​​ve tek durumlar için döşenmemiş sonuçlar. Ardından, uygun tabansız sonuç ile listenin endekslenmesiyle seçilir @ ... N. Pyth'in modüler indekslemesi olduğundan, sınır dışı hatalar atılmaz. Son olarak, sonuç ile kaplanır s.

MATL, 13 12 bayt

`tt2\.5+^ktq

Çevrimiçi deneyin!

açıklama

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

Bayt kaydettiği için Luis'e teşekkürler!

Minkolang 0.15 , 25 bayt

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

Burada deneyin!

açıklama

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 bayt

Girdi giriyor @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 bayt

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

Bu, bir tamsayıyı kabul eden ve birbirini izleyen çıkışları ayrı satırlara yazdıran bir programdır.

Açıklama:

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

Çevrimiçi deneyin

Dennis sayesinde 8 bayt tasarruf etti!

Java 7, 83 71 bayt

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

Başlangıçta tipik bir fordöngü kullandım , ancak doğru çalışması için çemberlerden atlamak zorunda kaldım. Sonra çalarak borç user81655 fikri yerine Recurse, ben on iki bayt aşağı aldım.

Haskell, 70 bayt

Haskell'in sqrtyerleşik bir tamsayısı yoktur , ancak bence daha kısa bir şey olabilir 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 bayt

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;

.5'e MOD (i, 2) eklemek daha kısadır, ancak POWER (2, .5) ile ilgili bir hata vardır:

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

verir

2   1   1,99999999999999999999999999999999999999

R, 54 51 bayt

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

Plannapus sayesinde 3 bayt tasarruf etti.

CJam, 18 bayt

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

Burada test edin

David'in MATL cevabına benzer .

Python 3, 57 , 45 , 43 , 41 bayt

@Mathmandan'ın önerisi ile Daha İyi Çözüm

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

Bu yöntem, her sayıyı yeni bir satıra yazdırır

Önceki Çözüm: xnor'ın önerisinden sonra 43 bayta kadar azaltın

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

Yukarıdakileri a(10)hangi dönüşleri yaparak arayabilirsiniz[10, 3.0, 5.0, 11.0, 36.0, 6.0, 2.0, 1.0]

Yukarıdaki değerler float olarak çıkacaktır. Tamsayı olarak istiyorsanız, 43 bayt için fazladan 2 bayt ekleyebiliriz:

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

TI-Basic, 30 Bayt

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

JavaScript ES6, 109 102 bayt

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

Ben biliyorum bu golfed edilebilir. Virgülle ayrılmış sayılar dizesi döndürür.

C ++, 122 bayt

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

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

@ User81655 ve @Alex A.'den esinlenerek özyineleme kullandım.

Retina, 144 bayt

Giriş ve çıkış tekli.

2. son satır, bir boşluk içerir ve iki orta satır ve son satır boştur.

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

Çevrimiçi deneyin

açıklama

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

Digital Trauma tarafından Retina'da tam sayı karekök

C, 64 63 61 bayt

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

TI BASIC, 43 bayt

Bir Thomas Kwa çekiyorum ve bunu cep telefonuma cevaplıyorum.

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

sqrtHesap makinenizdeki gerçek simgeyle değiştirin . Makul bir format olan satır besleme ile ayrılmış bir sayı listesi görüntüler.

JavaScript ES6, 76 bayt

Adlı bir jeneratördür j. Kullanmak için ayarlayın a = j(<your value>);. Sıradaki bir sonraki değeri görmek için şunu girin: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 bayt

1'de bitmez, ama devam eder.

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

Kullanımı:

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

1, 100 baytta gerçekten sona eren sürüm

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 bayt

33, artı 1 -pEyerine-e

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

açıklama

İlk olarak, -pdeğişkeni $_stdin girişine eşit olarak ayarlar . Sonra bir kod bloğu başlatırız:

1. sayyazdırır $_.
2. $_=int$_**($_%2+.5)setleri $_{tamsayı kısmına eşit $_{{gücüne $_bağlı olarak operasyonların (mertebesinde büyü, modülo 2} + 0.5}} operatör öncelik ). Bu atama,$_ , ve
3. (...)-1&&redoeksi 1 değerini döndüren testler. Fark 0 ise hiçbir şey yapmayın; aksi halde bu bloğu tekrarlayın.

Sonunda -pyazdırır $_.

Eşit uzunlukta

Ayrıca kullanır -p.

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

Bu: baskılar $_; yukarıdaki gibi atar; sayyeni değerinin eksi (0) dönüş değerinin 0 olup olmadığını test eder $_ve öyleyse bloğu yeniden yapar; daha sonra yazdırır $_.

dC, 22 21 bayt

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

Açıklaması:

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

Bir hata var: Giriş olduğunda 1, çıkış iki 1s'den oluşur .