21, 21, 23, 20, 5, 25, 31, 24, & le;

Inspiriert von diesem Puzzle , drucken Sie die folgende Sequenz aus, wenn Sie eine Ganzzahl $n>0$ , bis Sie eine Nicht-Ganzzahl erreichen (verdorben, falls Sie das Puzzle zuerst selbst lösen möchten).

$a_0 = n$
$a_{4k+1} = a_{4k} \cdot(4k+1)$
$a_{4k+2} = a_{4k+1} + (4k+2)$
$a_{4k+3} = a_{4k+2} - (4k+3)$
$a_{4k+4} = a_{4k+3} / (4k+4)$
oder intuitiver: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

Testfälle:

1: 1, 1, 3, 0, 0, 0, 6, -1
2: 2, 2, 4, 1
3: 3, 3, 5, 2
4: 4, 4, 6, 3
5: 5, 5 , 7, 4, 1, 5, 11, 4
6: 6, 6, 8, 5
9: 9, 11, 8, 2, 10, 16, 9
21: 21, 21, 23, 20, 5, 25, 31, 24, 3, 27, 37, 26

Eingabe und Ausgabe können in jedem vernünftigen Format erfolgen, Standardlücken sind wie üblich verboten.

Im Sinne von Code-Golf gewinnt die kürzeste Antwort in Byte!

Sandbox: https://codegolf.meta.stackexchange.com/a/18142/59642

05AB1E (Legacy) , 18 bis 17 Byte

[N"/*+-"Nè.VÐïÊ#=

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

[                # Start an infinite loop:
 N               #  Push the 0-based loop-index
  "/*+-"         #  Push string "/*+-"
        Nè       #  Index into this string with the loop-index
          .V     #  And use a 05AB1E-eval to calculate the next number
 Ð               #  Triplicate this number
  ï              #  Cast it to an integer
   Ê             #  And if it's NOT equal to the number we triplicated:
    #            #   Stop the infinite loop
  =              #  Print the number without popping

Ich verwende hier die Vorgängerversion von 05AB1E und berechne auch zuerst die nächste Zahl, bevor ich sie drucke, da die Schleife auf 0 basiert und sie /0in der ersten Iteration eine ausführt. Dies sparte ein Byte im Vergleich zum vorherigen N>und "*+-/". Dies funktioniert nur, weil in der Vorgängerversion eine durch 0 geteilte Zahl dieselbe bleibt. in der neuen Version würde es 0 werden; und in der tatsächlichen Mathematik würde es eine Division durch Null geben.

Scratch 3.0 39 Blöcke / 323 Bytes

Probieren Sie es einfach online aus !

Alternativ als SB-Syntax:

when gf clicked
delete[all v]of[o v
ask()and wait
set[. v]to(answer
set[n v]to(1
repeat until<(n)contains[.
if<((n)mod(4))=(0
set[. v]to((. )*(n
else
if<((n)mod(4))=(1
change[. v]by(n
else
if<((n)mod(4))=(2
change[. v]by((0)-(n
else
set[. v]to((. )/(n
end
end
end
add(n)to[o v
change[n v]by(1
end
delete(length of(o))of[o v

Schau euch an, hab Spaß mit deinen ausgefallenen evalStatements! Na ja, nicht ich! Nein ... Scratch hat keine Evals, also musste ich die Dinge auf die harte Tour machen ... if-Anweisungen.

Zumindest ist es nicht gotos ...

Whitespace , 251 227 202 Bytes

[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_top][T N
S T _Print_as_integer][S S S T  S T S N
_Push_10_newline][T N
S S _Print_as_character][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S T S S T   N
_Copy_2nd_item][S T S S T   N
_Copy_2nd_item][S N
S _Duplicate_top][S S S T   S S N
_Push_4][T  S T T   _Modulo][S N
S _Duplicate_top][N
T   S S N
_If_0_Jump_to_Label_DIVIDE][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate_top][N
T   S T N
_If_0_Jump_to_Label_MULTIPLY][S S S T   N
_Push_1][T  S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_ADD][S N
T   _Swap_top_two][S T  S S T   N
_Copy_2nd_item][T   S S T   _Subtract][N
S N
N
_Jump_to_LOOP][N
S S S N
_Create_Label_DIVIDE][S N
N
_Discard_top][T S T S _Divide][S T  S S T   S N
_Copy_3nd_item][S T S S T   S N
_Copy_3nd_item][T   S T T   _Modulo][N
T   S N
_If_0_Jump_to_Label_LOOP][N
N
N
_Exit_Program][N
S S T   N
_Create_Label_MULTIPLY][S N
N
_Discard_top][T S S N
_Multiply][N
S N
N
_Jump_to_Label_LOOP][N
S S S S N
_Create_Label_ADD][T    S S S _Add][N
S N
N
_Jump_to_Label_LOOP]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

-24 Bytes nach einem Kommentar von @JoKing was darauf hindeutet n%i > 0. Obwohl nur if(x < 0)und if(x == 0)in Whitespace verfügbar sind, ist das einfache Überprüfen if(x*-1 < 0)im Grunde dasselbe wie if(x > 0).
Weitere -25 Bytes dank @JoKing .

Erläuterung:

Zitat aus der Scratch-Antwort :

Zumindest ist es nicht gotos ...

Hat jemand gesagt goto? Whitespace hat nichts anderes gotozu tun, als sowohl Schleifen als auch if-Anweisungen zu erstellen. xD Außerdem ist es eine stapelbasierte Sprache, so dass ich ziemlich oft tauschen / verwerfen / kopieren muss. Und um das Ganze abzurunden: Whitespace hat nicht einmal Gleitkommazahlen und nur eine Ganzzahldivision. Deshalb habe ich n % i * -1 < 0das Programm verlassen, wenn die Ganzzahl die aktuelle Zahl nicht teilen kann.

Pseudocode:

Integer n = STDIN as input
Integer i = 0
Label LOOP:
  Print n as number
  i = i + 1
  Integer t = i % 4
  If(t == 0):
    Jump to Label DIVIDE
  t = t - 1
  If(t == 0):
    Jump to Label MULTIPLY
  t = t - 1
  If(t == 0):
    Jump to Label ADD
  n = n - i
  Jump to Label LOOP
Label DIVIDE:
  n = n / i
  Integer m = n % i
  If(m == 0):
    Jump to Label LOOP
  Exit program
Label MULTIPLY:
  n = n * i
  Jump to Label LOOP
Label ADD:
  n = n + i
  Jump to Label LOOP

Haskell , 75 74 73 Bytes

-1 Byte danke an Will Ness -1 Byte danke an nimi

(#1)
n#i|i`mod`4<1,n`mod`i>0=[n]|y<-i+1=n:(x!!i)n i#y
x=div:(*):(+):(-):x

Probieren Sie es online!

Vermeidet die Verwendung von Nachkommastellen, um Bytes zu sparen

JavaScript (V8) , 52 Byte

Druckt Gruppen von 4 Begriffen. Inspiriert von GBs Ruby-Antwort .

n=>{for(k=0;n%1==0;n/=k+=3)print(n,n*=++k,n-~k,--n)}

Probieren Sie es online!

JavaScript (V8) , 54 Byte

Druckt die Begriffe der Sequenz.

n=>{for(k=0;n%1==0;n=eval(n+'*+-/'[k++&3]+k))print(n)}

Probieren Sie es online!

JavaScript (ES6),  59-58  Byte

Gibt ein Array zurück.

f=(n,k)=>k&&(n=eval(n+'/*+-'[k&3]+k))%1?[]:[n,...f(n,-~k)]

Probieren Sie es online!

Perl 6 , 44 Bytes

{$_,{($_,<* + - />[$++%4]~++$).EVAL}...^*%1}

Probieren Sie es online!

Anonymer Codeblock, der eine Nummer annimmt und eine Sequenz zurückgibt. Wenn wir das erste Element überspringen könnten (das ohnehin immer das gleiche wie das zweite Element ist), könnten wir 3 Bytes einsparen, indem wir das entfernen$_,

Python 3 , 60 Bytes

f=lambda n,i=1:[]if n%1else[n]+f([n/i,n*i,n+i,n-i][i%4],i+1)

Probieren Sie es online!

Piet , 297 190 144 codels (432 bytes)

Versuchte einen neuen Ansatz unter Verwendung eines pointerBefehls als Schalter (k mod 4), um den Ausgabecode zu vereinheitlichen, was zu einem dichteren 10x19-Codebild führte. Dann habe ich das um 1 Reihe und 2 Spalten auf 8x18 golfen.

Hier ist eine Spur, um zu sehen, wie es funktioniert:

Die erste Zeile drückt eine 0 auf dem Stapel als pushStartindex (da wir nur natürliche Zahlen können, drücken wir zwei und subtrahieren dann), dann liest die Eingabe als Zahl.

Die am weitesten links stehende Spalte enthält den gemeinsamen Code zum Duplizieren der Zahl und zum Einfügen einer Zahl in die Ausgabe. Anschließend wird der Index auf den Stapel verschoben, inkrementiert und anschließend dreimal dupliziert. Wir geben dann den pastellroten, r-förmigen Block durch den dunklen Cyan-Codel ein, um einen pointerBefehl zu erhalten, der uns für den Rest unseres Index-Mods 4 verschiedene Pfade gibt.

Mod 1 verlassen wir durch die Spitze, um zu multiplizieren. Wir mischen zuerst eine Kopie unseres Indexes für später herunter und führen dann die Multiplikation durch. Nachdem wir das Weiß für eine Pause durchlaufen haben, betreten wir die obere Spalte, um die cc-Parität zu fixieren (es muss eine gerade Anzahl von Malen umgedreht werden, um die Schleife stabil zu halten), gefolgt von a pointer (1)vom Eintreten in den Magenta-Balken: Es wirkt als a Fange nach unseren vier Pfaden und schicke uns zurück in die Schleife.

Mod 2 verlassen wir rückwärts um zu summieren. Die Form des Pastellcodeblocks bedeutet, dass wir eine Zeile über der Eingabe verlassen und die 3 verwenden, die wir auf den Stapel schieben, indem wir durch den roten Codeblock nach pointer (3)oben gehen. Diese Spalte enthält den Leerraum vor der Arithmetik und eine etwas andere Reihenfolge für das Drücken und Umschalten von cc, da sich die Farben sonst mit ganzzahligen Codels in der benachbarten Spalte überlappen würden.

Mod 3 schickt uns zur Subtraktion nach unten. Gleicher Vorgang wie die Multiplikation, außer dass wir den Teilungspfad auf dem Weg nach oben überqueren (da der CC beim Eintritt in den grünen Pastellstrich eine unterschiedliche Parität aufweist, verlassen die beiden Ausführungen diesen Takt an verschiedenen Enden). Währenddessen nehmen wir einen unerwünschten duplicateBefehl auf, so dass wir popihn mit dem dunkelgrünen Codel zurücknehmen, bevor wir in die CC-Korrektur- und Erfassungsleiste eintreten.

Mod 4, wir gehen geradeaus, um uns zu teilen. In diesem Fall müssen wir den Stapel zunächst stärker neu mischen, um zwei Paare von n und a für Operationen zu erhalten, da wir testen müssen, ob es sich um eine Ganzzahl handelt. Wir machen das modmit dem ersten Paar, dann notmit dem Ergebnis und dann mit a pointer- wenn es nicht teilbar ist, fahren wir geradeaus weiter, was uns mit zwei pointerBefehlen in die gegenüberliegende Ecke in den unvermeidlichen Block schickt und damit das Programm beendet. Andernfalls biegen wir rechts ab und erhalten einen divideBefehl, die Magenta-Leiste zu betreten.

Alte Version

Sehr einfacher Code: Drückt eine 1 und die Eingabe auf dem Stapel und durchläuft dann die vier Operationen durch: Mischen des Index über dem Stapel, Inkrementieren um 1, Duplizieren, Mischen einer Kopie nach unten, Ausführen der arithmetischen Operation, Duplizieren der Nummer und Einfügen einer Nummer in die Ausgabe.

Bei der Division, die die einzige ist, bei der die Sequenz enden kann, wird ein komplizierterer Stapel erstellt, um zunächst zu überprüfen, ob n mod index == 0 ist. Andernfalls wird der unvermeidliche Codel eingegeben und beendet. Andernfalls verwendet es seine zweite Kopie von i und n, um die Division durchzuführen.

C # (Visual C # Interactive Compiler) , 72 , 70 , 69 Byte

n=>{for(int i=1;n%1==0;n=new[]{n/i,n*i,n+i,n-i}[i++%4])Write(n+" ");}

Probieren Sie es online!

Ruby , 56 54 52 Bytes

f=->n,z=1{n%1>0?[]:[n,n*=z,n-~z,n-=1]+f[n/=z+3,z+4]}

Probieren Sie es online!

Nach einem (gescheiterten) Versuch mit evalfand ich heraus, dass die glücklichste Lösung darin besteht, das Array mit 4 Elementen auf einmal zu erstellen, zumindest in Ruby.

Danke an Arnauld für -2 Bytes.

R , 90 Bytes , 87 Bytes, 85 Bytes, 80 Bytes, 74, 73 Bytes

Eine einfache Umsetzung der Regeln:

a=scan();while(T<13)a=c(a,d<-a[T]*T,d+T+1,e<-d-1,e/((T<-T+4)-1));a[!a%%1]

Probieren Sie es online!

mit dem T<13folgenden aus einer tieferen Analyse des Puzzles. In der Tat gibt es nur drei Arten von Sequenzen: jene der Länge 4, wenn a⁰ nicht zu 1 Modulo 8 kongruent ist; diejenigen der Länge 12, wenn a when zu 21 modulo 32 kongruent ist; und diejenigen der Länge 8 für die übrigen Fälle.

Ein alternativer Code, der Schleifen vermeidet, ist mit 87 Bytes länger:

`~`=rep;b=(scan()-1)*c(32~4,8,40~3,1,9~3)/32+c(1,1,3,0~3,6,-c(8,1,9,-71,17)/8);b[!b%%1]

Probieren Sie es online!

Haskell , 104 86 85 Bytes

n#i=n:(cycle[(/),(*),(+),(-)]!!floor i)n i#(i+1)
takeWhile((==).ceiling<*>floor).(#1)

Probieren Sie es online!

Das h=kann weggelassen werden, da es nur zum Testen verwendet wird.

Ah, Codegolf, wo sich eine quadratische Zunahme der Zeitkomplexität für die Reduzierung eines Zeichens lohnt.

104 Bytes

f=flip
g x=scanl(f($))x.zipWith(f($))[1..].cycle$f<$>[(*),(+),(-),(/)]
takeWhile((==).ceiling<*>floor).g

Probieren Sie es online!

Mir gefällt diese Antwort besser, aber leider ist sie länger.

Japt , 25 24 Bytes

Eine weitere Anpassung der Ruby-Lösung von GB .

%1ª[UU*=°VU´ÒVU]cßU/=V±3

Versuch es

Der Haupttrick liegt hier in der Überladung der cMethode für Arrays. Übergeben Sie ein anderes Array als Argument und verknüpfen Sie es mit dem ursprünglichen Array. Übergeben Sie eine Zahl als Argument, wie dies beim letzten rekursiven Aufruf der 1Fall ist , und glätten Sie das ursprüngliche Array um so viele Ebenen - in diesem Fall nach dem Runden. Da das Array jedoch immer nur eine Ebene tief ist, hat das Abflachen keine Auswirkung.

%1ª[UU*=°VU´ÒVU]cßU/=V±3     :Implicit input of integer U
%1                           :U modulo 1
  ª                          :Logical OR with
   [                         :Construct and array containing
    U                        :  U
     U*=                     :  U multiplied by
        °V                   :    V (initially 0) prefix incremented
          U´                 :  The new value of U, postfix decremented
            ÒV               :    Subtract the bitwise negation of V
              U              :  The now-decrmented U
               ]             :End array
                c            :Concatenate, or flatten by
                 ß           :  Recursive call to the programme with argument
                  U/=        :    U divided by
                     V±3     :      V incremented by 3

Java 8, 84 Bytes

n->{for(int i=1;n%1==0;n=new float[]{n/i,n*i,n+i,n-i}[i++%4])System.out.println(n);}

Probieren Sie es online aus.

Das Erstellen eines Arrays mit allen vier Werten ist von der Ruby-Antwort von @ GB inspiriert , obwohl ich jetzt feststelle, dass die Verwendung einer ternären if-Anweisung die gleiche Anzahl von Bytes enthält:

n->{for(int i=0;n%1==0;n=++i%4<1?n/i:i%4<2?n*i:i%4<3?n+i:n-i)System.out.println(n);}

Probieren Sie es online aus.

Perl 5 , 53 Bytes

@a=qw(/ * + -);say,eval"\$_$a[++$i%4]=$i"while$_==int

Probieren Sie es online!

rot , 102 Bytes

func[n][k: m: 0 until[foreach o[* + - /][print n t: n
n: do reduce[n o m: m + 1]]k: k + 1 t % m <> 0]]

Probieren Sie es online!

AWK , 57 Bytes

{n=$1;for(k=1;n%1==0;n/=k++)print n,n*=k++,n+=k++,n-=k++}

Probieren Sie es online!

Rutger , 310 Bytes

n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];

Probieren Sie es online!

Es ist an der Zeit, dass ich wieder Rutger benutze. Leider ist es möglicherweise nicht die beste Sprache für die Aufgabe, da es keine Form von hateval , die mich zwingt, vier if-Anweisungen zu verwenden

Wie es funktioniert

Wie funktioniert Rutger?

Ein kurzes Vorwort zur Funktionsweise der Sprache: Alles ist entweder eine Aufgabe oder eine Funktion, und jede Funktion benötigt genau ein Argument. Für Operationen, die mehr als ein Argument erfordern (z. B. Multiplikation), gibt der erste Aufruf eine Teilfunktion zurück, die bei erneutem Aufruf mit dem zweiten Argument das erwartete Ergebnis zurückgibt. Beispielsweise:

left = Times[5];
Print[left[6]];

druckt 30 aus: Online ausprobieren! . Während dies normalerweise länger ist als die übliche Alternative, kann es manchmal Bytes sparen, wenn eine Funktion wiederholt mit einem konstanten Argument und einem sich ändernden Argument aufgerufen wird, beispielsweise beim Ausdrucken von Zeittabellen.

Diese Regel mit einem Argument gilt für alles, was keine Konstante oder Variable ist, einschließlich Schleifen und Bedingungen. Allerdings Schleifen und Bedingungen ( For, Each, While, DoWhile, Ifund IfElse) sind machbar , dass im Hinblick auf Bedeutung , die sie tatsächlich läuft, dieDo muß Funktion (siehe die letzte Zeile in der Antwort) aufgerufen werden. Dies kann wiederum Byte sparen, wenn dieselbe Schleife wiederholt ausgeführt wird, oder Sie können beliebigen Code zwischen der Definition und der Ausführung von Schleifen ausführen.

Schließlich gibt es drei Möglichkeiten, auf Variablen zu verweisen, die alle in diesem Programm verwendet werden. Die erste ist die direkte Referenzierung , bei der dem Variablennamen ein $Symbol vorangestellt wird . Dies greift direkt auf den Wert der Variablen zu und gibt ihn zurück. Die zweite ist die Funktionsreferenzierung , die keinen Präfixcharakter hat. Auf diese Weise kann der Code zwischen (potenziell partiellen) Funktionen, die Variablen zugewiesen sind, und tatsächlichen Variablen, die einen bestimmten Wert enthalten, unterscheiden. Schließlich indirekte Referenzierung mit einem Präfix @Symbol, wird eine Variable (falls es nicht bereits vorhanden ist ) und gibt das variable Objekt innerhalb eines bestimmten Bereichs. Auf diese Weise können Sie eine Schleifenvariable erstellen (z . B. iin for i in range(...)).

Wie die eigentliche Lösung funktioniert

Hier ist der ungolfed Code:

n = elem = $Input;
var = 0;
while = While[{
	mod = Modulo[$elem];
	Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
	Print[$elem];
	equal = Equal[$index];

	if = If[{ equal[1]; }];
	if = if[{ func = Times[$elem]; }];
	Do[$if];

	if = If[{ equal[2];}];
	if = if[{ func = Add[$elem];}];
	Do[$if];

	if = If[{ equal[3];}];
	if = if[{ func = Subtract[$elem];}];
	Do[$if];

	if=If[{ equal[4];}];
	if=if[{ func = Divide[$elem];}];
	Do[$if];

	elem = func[var = Increment[$var]];
	}];
	Do[$for];
}];
Do[$while];

Probieren Sie es online!

Wie man sehen kann, beginnt sie , indem sie die drei Variablen zuweisen n, eund a, die die Eingabe des Änderungselement in der Sequenz repräsentieren, und die Änderungszahl für jedes jeweils neues Element. Wir erstellen dann eine while-Schleife:

w=While[{m=Modulo[$e];Not[m[1]];}];

Die geschweiften Klammern ( {und }) definieren einen Codeblock , wobei die letzte Anweisung im Block die Bedingung für die while-Schleife ist. In diesem Fall definieren wir zunächst eine partielle Modulo-Funktion, die ein zweites Argument aufnimmt mund zurückgibt e % m. Wir nennen diese Teilfunktion dann mit$1$ als zweites Argument zurückkehren $0$für ganze Zahlen und eine ganze Zahl ungleich Null für Gleitkommazahlen. Wir berechnen dann das logische Nicht davon, Mapping$0 \to 1$ und $n \to 0, n \ne 0$.

Als nächstes kommen wir zu der absoluten Monstrosität, die aus dem Körper der while-Schleife besteht:

w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];

Der primäre Teil dieser Schleife ist eine for-Schleife, die iteriert $4$mal jede Iteration der while-Schleife, hat eine Iterationsvariable von xund besteht aus:

Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e]    ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e]      ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e]   ;}];Do[$i];
e=k[a=Increment[$a]];

Die erste Anweisung druckt jede Iteration der Sequenz aus, bevor sie geändert wird. Wir erstellen dann eine Teilfunktion, um die Gleichheit mit der Schleifenvariablen zu überprüfen x, und treffen auf vier if-Anweisungen. Jede Anweisung überprüft , ob xgleich 1, 2, 3 oder 4 ist, und weist dann kjede Funktion in *, +, -und /dann wird es in eine Teilfunktion eals Argument. Schließlich weisen wir eauf kmit laufen aals zweites Argument und Zuwachs a.

Ruby , 52 Bytes

->n{i=0.0;n=[p(n)/i+=1,n*i,n+i,n-i][i%4]until 0<n%1}

Probieren Sie es online!

C (clang) , 80 Bytes

i;f(n){for(i=0;~i;n=++i%4?i%4-1?i%4-2?n-i:n+i:n*i:n%i?i=-1:n/i)printf("%d ",n);}

Probieren Sie es online!

A golfed switch statement.   

Vielen Dank an @ceilingcat Verbesserungen.

dzaima / APL, 34 33 Bytes

⌽1↓{⍵,⍨⊃⍵(⍎⊃'÷×+-'⌽⍨≢⍵)≢⍵}⍣{⍵≢⌊⍵}

Probieren Sie es online!

-1 danke an ngn

TI83 / 84 BASIC, 69 Bytes

1→A
DelVar L1Prompt N
Repeat fPart(N
N→L1(A
NA-1→O
augment(L1,{NA,Ans+A+2,Ans→L1
O/(A+3→N
A+4→A
End
Disp L1

Wir richten einen Zähler in A ein und löschen L1, damit wir die Sequenz verfolgen können. Wir wiederholen dann, bis der Teilungsschritt einen Bruch verursacht. Innerhalb der Schleife speichern wir zuerst N in der Liste. Wenn Sie ein Element hinter dem Ende einer Liste oder eine leere Liste speichern, wird dieses Element erstellt. In diesem einen Speicher wird also das Ergebnis der Division hinzugefügt, wenn es keinen Bruch verursacht, und die Liste wird beim ersten Durchlauf initialisiert. Wir verwenden dann Augment, um die nächsten 3 Terme der Sequenz anzuhängen. Die Mathematik berechnet ein paar Bytes kleiner, indem der Term A4k + 3 in der Variablen O berechnet wird und dann A4k + 2 und A4k + 4 aus O berechnet werden. Dann führen wir die Division separat durch, um N für die Wiederholungsprüfung zurückzusetzen und 4 zu A zu addieren.

Ich habe einen Disp L1 am Ende eingefügt, bin mir aber nicht sicher, wie ideal er ist, da es keinen guten Weg gibt, alle Begriffe auf den Bildschirm zu setzen. Realistisch gesehen würde der Benutzer L1 ausführen, nachdem das Programm manuell ausgeführt wurde, um durch die Ergebnisse zu scrollen.

Holzkohle , 29 Bytes

ＮθＷ¬﹪θ¹«Ｉθ⸿≔§⟦∕θⅉ×θⅉ⁺θⅉ⁻θⅉ⟧ⅉθ

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

Ｎθ

Geben Sie den Anfangswert ein.

Ｗ¬﹪θ¹«

Wiederholen, bis der Wert keine ganze Zahl mehr ist.

Ｉθ⸿

Gibt den Wert in einer eigenen Zeile aus.

≔§⟦∕θⅉ×θⅉ⁺θⅉ⁻θⅉ⟧ⅉθ

Berechnen Sie die vier verfügbaren Rechenoperationen und wählen Sie die richtige aus, abhängig von der aktuellen Ausgabezeilennummer.

Python 3 , 78 76 Bytes

f=lambda n:n[-1]%1and n[:-1]or f(n+[eval(f"n[-1]{'/*+-'[len(n)%4]}len(n)")])

Probieren Sie es online!

Nimmt die Eingabe als Liste mit 1 Element und hängt das nächste Element der Sequenz rekursiv an, bis es eine Nicht-Ganzzahl ist.

Für den Fall, dass die Eingabe als Liste nicht zulässig ist, ist hier eine sehr schnell gepatchte Version, die Eingaben als Int. Akzeptiert.

Eingabe als Ganzzahl, 102 Bytes

f=lambda n:type(n)==int and f([n])or n[-1]%1and n[:-1]or f(n+[eval(f"n[-1]{'/*+-'[len(n)%4]}len(n)")])

Probieren Sie es online!

+2 Bytes danke, dass ich vergessen habe, die rekursive Funktion
zu benennen ... -4 Bytes danke an Jitse

Zweig , 164 Bytes

Okay, das war eigentlich schrecklich schrecklich zu schreiben.

Einschränkungen:

• Nein returns ! Sie geben entweder aus oder geben nicht aus
• Keine whileSchleifen. Du musst Rekursion oder nichts verwenden
• Keine einfache Ausgabe! Sie müssen die Ausgabe jedes Mal wiederholen
• Sie können Variablen keinen Wert geben, ohne das setTag zu verwenden
• Keine einfache Möglichkeit, aus einer Schleife herauszukommen. Es gibt keinen break, continue, gotooder ähnliches. Dies macht die Verwendung einer Schleife unmöglich.
• Es gibt nur eine Schleife: for ... in ....und sie durchläuft alle Elemente in einem Array, ohne dass eine Unterbrechung möglich ist.

Alle diese haben den Code massiv gemacht!
Hey, ich habe es sogar länger gemacht als die Java-Antwort!
Es ist so lange wie die JavaScript-Antwort von @ Arnauld ! ... mit allen 3 Alternativen kombiniert.

Hier ist der Code:

{%macro a(b,n=1)%}{{n<2?b}}{%set b=b*n%},{{b}}{%set b=b+n+1%},{{b}}{%set b=b-(n+2)%},{{b}}{%set b=b/(n+3)%}{%if(b//1)==b%},{{b~_self.a(b,n+4)}}{%endif%}{%endmacro%}

Sie können es unter https://twigfiddle.com/zw5zls ausprobieren

Wie benutzt man:

Importieren Sie einfach die Datei und rufen Sie das erste Makro auf.

{% import 'file.twig' as a %}

{{ a.a(21) }} {# 21,21,23,20,5,25,31,24,3,27,37,26 #}

Um ein brauchbares Array zu haben, können Sie dies tun a.a(21)|split(',').

Ungolfed:

{% macro calc(number, index = 1) %}
    {% if index < 2 %}
        {{ number }}
    {% endif %}

    {% set number = number * index %},{{ number }}
    {% set number = number + index + 1 %},{{ number }}
    {% set number = number - (index + 2) %},{{ number }}
    {% set number = number / (index + 3) %}

    {#
        verifies if it is an integer.
        this is done with an integer division with 1 and compare with itself
        if both values are the same, the number is an integer
        otherwise, it is a floating-point number
    #}
    {% if (number // 1) == number %}
        ,{{ number ~ _self.calc(number, index + 4) }}
    {% endif %}
{% endmacro %}

Sollte leicht zu lesen sein.
Diese ungolfed Antwort gibt NICHT die korrekte Ausgabe aus, da sie zufällige Leerzeichen wirft.
Es existiert nur, um menschlich lesbar zu sein.