Geben Sie die Jongleur-Sequenz aus

18

Die Jongleursequenz wird wie folgt beschrieben. Beginnend mit einer Eingabe a 1 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.

Seadrus
quelle
3
Ich ließ mich von einem kleinen Nerd ausschneiden und berechnete die Anzahl der Schritte, die für die ersten ~5.6*10^7Werte angehalten werden müssen (sie halten alle bis jetzt an).
Michael Klein
Erinnert mich an die Collatz-Vermutung (immer noch ungelöst)
wim
@wim ja, das ist sehr ähnlich.
Seadrus

Antworten:

8

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.
Dennis
quelle
Ich habe fast Angst zu fragen, da das Poster eine Reputation von 87.000 hat, aber ist es wirklich möglich, dies in 10 Bytes darzustellen? Sie verwenden 10 Zeichen, aber können Sie wirklich alle diese sehr esoterischen Zeichen in nur 256 Kombinationen einpassen? ½, Ḟ, Ð scheint nicht meine erste Wahl für Zeichen zu sein, die in mein Alphabet
eingefügt werden sollen
1
@Annonymus Jelly verwendet eine benutzerdefinierte Codepage , die jedes der 256 Zeichen, die es versteht, als einzelnes Byte codiert.
Dennis
1
Aha! Vielen Dank. Übrigens habe ich einen Fehler in Ihrer Tabelle gefunden, Zeichen 20 (ich gehe davon aus, dass es ein Leerzeichen ist, wenn es nicht der "Fehler" ist, dass dies unklar ist) wird entfernt, da es ein einsames Leerzeichen ist. Verwenden Sie & nbsp; stattdessen.
Annonymus
@Annonymus Ja, das sah ein bisschen komisch aus. Ich wollte NBSP nicht verwenden, da jeder Versuch, die Tabelle zu kopieren, <code> </code>fehlschlagen würde, aber anstelle der Backticks scheint ein tatsächliches SP-Zeichen anzuzeigen. Vielen Dank für den Hinweis.
Dennis
10

Julia, 64 50 48 42 32 30 Bytes

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

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!

Alex A.
quelle
Kann der Julia-Interpreter den Quellcode in ISO 8859-1 verarbeiten? Dann wäre die Ganzzahldivision nur ein einzelnes Byte.
Martin Ender
@ MartinBüttner Nein, ich habe es schon mal ausprobiert und es wurde ziemlich verrückt. Julias Parser geht von UTF-8 aus.
Alex A.
8

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.

user81655
quelle
1
Ich wünschte **, wir würden in allen Browsern unterstützt.
ETHproductions
@ETHproductions Ich wünschte, ich würde ** in C # unterstützt.
Aloisdg sagt Reinstate Monica
7

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} *)
njpipeorgan
quelle
6

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.

isaacg
quelle
6

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!

David
quelle
Die floorFunktion wurde in geändert k, sodass Sie damit Zo1 Byte speichern können. (Entschuldigung für diese Änderungen; Sie können die Release-Zusammenfassungen hier sehen )
Luis Mendo
Oh cool, danke, dass du mich informiert hast!
David
5

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.
El'endia Starman
quelle
3

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
Liesel
quelle
3

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!

Alex A.
quelle
2

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.

Geobits
quelle
2

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) 
Michael Klein
quelle
2

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
Jeto
quelle
2

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.

mnel
quelle
Angesichts der Tatsache, dass alle n positiv sind, kann floor(n^(.5+n%%2))man sich n^(.5+n%%2)%/%1meiner Meinung nach verkürzen . +1 Trotzdem.
Plannapus
2

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)))
Cameron Aavik
quelle
Es ist etwas kürzer, mit dem Basisfall umzugehen [n][:n<2]or, oder mit 1/n*[n]ordem Ganzzahlfall.
xnor
Mit Python 2 können Sie es auf 41 Bytes reduzieren def j(n):print n;n-1and j(n**(.5+n%2)//1). (Oder in Python 3 sind def j(n):print(n);n-1and j(n**(.5+n%2)//1)es 42 Byte.) Es wird die Sequenz Begriff für Begriff gedruckt, anstatt die Begriffe in einer Liste zu sammeln.
Mathmandan
Ich kann auch ein weiteres Byte entfernen, indem ich es n<2ornicht machen-1and
Cameron Aavik
2

TI-Basic, 30 Bytes

Prompt A
Repeat A=1
Disp A
int(A^(remainder(A,2)+.5->A
End
1
user1812
quelle
22 Bytes , wenn Sie eine Eingabe von Ans nehmen, ersetzen Sie Repeat Ans=1mit While log(Ansund Verwendung √(Ans)Ans^remainder(Ans,2.
Lirtosiast
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.

Conor O'Brien
quelle
1

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;}
MegaTom
quelle
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.

aloisdg sagt Reinstate Monica
quelle
1

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

mbomb007
quelle
1

C 64 63 61 Bytes

t;q(n){for(;!t;n=pow(n,.5+n%2))printf("%d%c ",n,n^1?44:t++);}
o79y
quelle
2
Sie können n%2?1.5:0.5mit n%2+0.5oder ersetzen.5+n%2 (falls C erlaubt es). Wenn n%2wahr ist, n%2ist 1, sonst 0.
Aloisdg sagt Reinstate Monica
0

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.

Conor O'Brien
quelle
Sie können dies mehr Golf spielen.
Lirtosiast
@ThomasKwa Ja, du hast wahrscheinlich recht. Ich werde ein bisschen darüber nachdenken.
Conor O'Brien
0

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;
    }
}
Conor O'Brien
quelle
0

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
Asibahi
quelle
0

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.

msh210
quelle
0

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.

Joe
quelle