21, 21, 23, 20, 5, 25, 31, 24,?

Inspiré par ce puzzle , étant donné un entier $n>0$ , imprimez la séquence suivante jusqu'à ce que vous atteigniez un non-entier (gâté, au cas où vous voudriez résoudre le puzzle vous-même en premier)

$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)$
ou plus intuitivement: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

TestCases:

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, 9, 11, 8, 2, 10, 16, 9
21: 21, 21, 23, 20, 5, 25, 31, 24, 3, 27, 37, 26

L'entrée et la sortie peuvent être prises dans n'importe quel format raisonnable, les failles standard sont aussi interdites que d'habitude.

Dans l'esprit du code-golf , la réponse la plus courte en octets gagne!

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

05AB1E (hérité) , 18 17 octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

J'utilise la version héritée de 05AB1E ici, et je calcule d'abord le nombre suivant avant de l'imprimer, car la boucle est basée sur 0 et elle fera un /0 dans la toute première itération. Cela a sauvé un octet par rapport aux précédents N>et "*+-/". Cela ne fonctionne que parce que dans la version héritée, un nombre divisé par 0 reste le même; alors que dans la nouvelle version, il deviendrait 0; et en mathématiques réelles, cela donnerait une division par zéro erreur.

Scratch 3.0 39 blocs / 323 octets

Essayez-le en ligne !

Alternativement, comme syntaxe SB:

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

Regardez-vous les gars, amusez-vous avec votre fantaisie eval déclarations ! Enfin pas moi! Non ... Scratch n'a pas d'éval, alors j'ai dû faire les choses à la dure ... si les déclarations.

Au moins ce n'est pas gotos ...

Whitespace , 251 227 202 octets

[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]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

-24 octets après un commentaire de @JoKing suggérant n%i > 0. Bien que seuls if(x < 0)et if(x == 0)disponibles dans l'espace blanc, la simple vérification if(x*-1 < 0)est fondamentalement la même chose que if(x > 0).
-25 octets supplémentaires grâce à @JoKing .

Explication:

Citation de la réponse Scratch :

Au moins ce n'est pas gotos ...

Quelqu'un a dit goto? L'espace blanc n'a rien d'autre que gotode créer des boucles et des instructions if. xD De plus, c'est un langage basé sur la pile, donc je dois permuter / supprimer / copier assez souvent. Et pour couronner le tout: l'espace blanc n'a même pas de virgule flottante et seulement une division entière, donc j'ai utilisén % i * -1 < 0 de quitter le programme si l'entier ne peut pas diviser le nombre actuel.

Pseudo-code:

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 octets

-1 octet grâce à Will Ness -1 octet grâce à 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

Essayez-le en ligne!

Évite l'utilisation d'entiers fractionnaires pour économiser sur les octets

JavaScript (V8) , 52 octets

Imprime des groupes de 4 termes. Inspiré par la réponse Ruby de GB .

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

Essayez-le en ligne!

JavaScript (V8) , 54 octets

Imprime les termes de la séquence.

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

Essayez-le en ligne!

JavaScript (ES6),  59  58 octets

Renvoie un tableau.

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

Essayez-le en ligne!

Perl 6 , 44 octets

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

Essayez-le en ligne!

Bloc de code anonyme qui prend un nombre et renvoie une séquence. Si nous pouvions ignorer le premier élément (qui est toujours le même que le deuxième élément de toute façon), nous pourrions économiser 3 octets en supprimant le$_,

Python 3 , 60 octets

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

Essayez-le en ligne!

Piet , 297 190 144 codels (432 octets)

J'ai essayé une nouvelle approche en utilisant un pointer commande comme commutateur (k mod 4) pour unifier le code de sortie, résultant en une image de code 10x19 plus dense. Ensuite, j'ai joué au golf d'une rangée et de deux colonnes à 8x18.

Voici une trace, pour voir comment ça marche:

La première ligne pousse un 0 sur la pile comme index de départ (puisque nous ne pouvons push des nombres naturels, nous poussons 2 uns puis soustrayons), puis lit l'entrée en tant que nombre.

La colonne la plus à gauche a le code partagé de duplication du nombre et d'en insérer un dans la sortie, puis de déplacer l'index au-dessus de la pile, de l'incrémenter puis de le dupliquer trois fois. Nous entrons ensuite dans le bloc en forme de R rouge pastel à travers le codel cyan foncé pour unepointer commande qui nous donne différents chemins pour le reste de notre index mod 4.

Mod 1, on sort par le haut pour se multiplier. Nous mélangeons d'abord une copie de notre index pour plus tard, puis effectuons la multiplication. Après avoir traversé le blanc pour un noop, nous entrons dans la colonne ci-dessus pour fixer la parité cc (elle doit être retournée un nombre pair de fois pour maintenir la boucle stable), suivie d'unpointer (1) pour entrer dans la barre magenta: il agit comme un attraper nos quatre chemins et nous renvoyer dans la boucle.

Mod 2, nous sortons à l'envers pour résumer. La forme du bloc de code pastel signifie que nous sortons d'une ligne au-dessus de l'endroit où nous sommes entrés, et nous utilisons les 3 que nous poussons sur la pile en sortant par le codel rouge vers pointer (3)nous vers le haut. Cette colonne a l'espace blanc avant l'arithmétique et un ordre légèrement différent de pousser et de commuter cc, car sinon nous aurions un chevauchement de couleur avec des codels à valeur entière dans la colonne voisine.

Le module 3 nous envoie vers le bas pour la soustraction. Même chose que la multiplication, sauf que nous traversons le chemin de division en montant (comme le cc a une parité différente en entrant dans la barre verte pastel, les deux exécutions sortent de cette barre à des extrémités différentes). Ce faisant, nous prenons une duplicatecommande indésirable , nous la popreculant donc avec le codel vert foncé avant d'entrer dans la barre de correction et de collecte cc.

Mod 4, nous allons tout droit de diviser. Ici, nous devons d'abord réorganiser la pile plus sévèrement pour obtenir deux paires de n et a pour effectuer des opérations, car nous devons tester si elle est entière. Nous faisons ce que je fais modsur la première paire, puis notsur le résultat, puis utilisons cela pour un pointer- si ce n'est pas divisible, nous continuons tout droit, ce qui nous envoie avec deux pointercommandes dans le coin opposé dans le bloc incontournable et termine ainsi le programme. Sinon, nous tournons à droite et obtenons une dividecommande d'entrer dans la barre magenta.

Ancienne version

Code très simple: pousse un 1 et l'entrée sur la pile, puis effectue une boucle à travers les quatre opérations en: mélangeant l'index au-dessus de la pile, l'incrémentant de 1, le dupliquant, en mélangeant une copie vers le bas, en effectuant l'opération arithmétique, dupliquer le nombre et en insérer un dans la sortie.

Pour la division, qui est la seule où la séquence peut se terminer, elle crée une pile plus compliquée pour d'abord vérifier si n mod index == 0, sinon elle entre dans le codel incontournable et se termine. Sinon, il utilise sa deuxième copie de i et n pour effectuer la division.

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

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

Essayez-le en ligne!

Rubis , 56 54 52 octets

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

Essayez-le en ligne!

Après une tentative (infructueuse) avec eval, j'ai découvert que la solution la plus heureuse était de construire le tableau avec 4 éléments à la fois, au moins en rubis.

Merci à Arnauld pour -2 octets.

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

Une mise en œuvre simple des règles:

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]

Essayez-le en ligne!

avec ce qui T<13suit d'une analyse plus approfondie du puzzle. En effet il n'y a que trois sortes de séquences: celles de longueur 4, lorsque a⁰ n'est pas congru à 1 modulo 8; ceux de longueur 12 lorsque a⁰ est congru à 21 modulo 32; et ceux de longueur 8 pour les autres cas.

Un code alternatif évitant les boucles finit par être plus long avec 87 octets:

`~`=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]

Essayez-le en ligne!

Haskell , 104 86 85 octets

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

Essayez-le en ligne!

Le h=peut être omis car il n'est utilisé que pour les tests.

Ah, le golf de code, où une augmentation quadratique de la complexité temporelle en vaut la peine pour la réduction d'un caractère.

104 octets

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

Essayez-le en ligne!

J'aime mieux cette réponse, mais hélas elle est plus longue.

Japt , 25 24 octets

Une autre adaptation de la solution Ruby de GB .

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

Essayez-le

L'astuce principale ici est la surcharge de la cméthode pour les tableaux. Passez-lui un autre tableau comme argument et il le concatène au tableau d'origine. Passez-lui un nombre comme argument, comme cela se produit lors du dernier appel récursif, et il aplatit le tableau d'origine de ce nombre de niveaux - 1dans ce cas, après l'arrondi. Mais, comme la matrice n'a qu'un niveau de profondeur, l'aplatissement n'a aucun effet.

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

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

Essayez-le en ligne.

La création d'un tableau avec les quatre valeurs est inspirée de la réponse Ruby de @GB , bien que je remarque maintenant que l'utilisation d'une instruction if ternaire est la même quantité d'octets:

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

Essayez-le en ligne.

Perl 5 , 53 octets

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

Essayez-le en ligne!

Rouge , 102 octets

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

Essayez-le en ligne!

AWK , 57 octets

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

Essayez-le en ligne!

Rutger , 310 octets

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

Essayez-le en ligne!

Il est temps que j'utilise à nouveau Rutger. Malheureusement, ce n'est peut-être pas le meilleur langage pour la tâche, car il n'a aucune forme eval, ce qui m'oblige à utiliser quatre instructions if

Comment ça marche

Comment fonctionne Rutger

Un bref avant-propos sur le fonctionnement du langage: tout est soit une affectation, soit une fonction, et chaque fonction prend exactement un argument. Pour les opérations qui nécessitent plus d'un argument (par exemple la multiplication), le premier appel renvoie une fonction partielle qui, lorsqu'elle est appelée à nouveau avec le deuxième argument, renvoie le résultat attendu. Par exemple:

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

imprimera 30: Essayez-le en ligne!. Bien que cela soit généralement plus long que l'alternative habituelle, il peut parfois économiser des octets, si une fonction est appelée à plusieurs reprises avec un argument constant et un argument changeant, par exemple lors de l'impression de tables de temps.

Cette règle à un argument s'applique à tout ce qui n'est pas une constante ou une variable, y compris les boucles et les conditions. Cependant, les boucles et conditionals ( For, Each, While, DoWhile, Ifet IfElse) sont faisables , ce qui signifie que pour les exécuter en fait, laDo fonction doit être appelée (voir la dernière ligne dans la réponse). Encore une fois, cela peut économiser des octets lors de l'exécution répétée de la même boucle, ou vous permettre d'exécuter du code arbitraire entre la définition et l'exécution des boucles.

Enfin, il existe trois façons de se référer aux variables, qui sont toutes utilisées dans ce programme. Le premier est le référencement direct , où le nom de la variable est préfixé par un $symbole. Cela accède directement à la valeur de la variable et la renvoie. Le second est le référencement fonctionnel , qui n'a pas de caractère de préfixe. Cela permet au code de faire la distinction entre les fonctions (potentiellement partielles) attribuées aux variables et les variables réelles contenant une valeur spécifique. Enfin, le référencement indirect , préfixé d'un @symbole, crée une variable (si elle n'existe pas déjà) et renvoie l'objet variable dans une portée donnée. Cela vous permet de créer une variable de boucle (par exemple idans for i in range(...)).

Fonctionnement de la solution réelle

Voici le code non golfé:

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

Essayez-le en ligne!

Comme vous pouvez le voir, il commence par attribuer des trois variables n, eet aqui représentent l'entrée, l'élément de modification de la séquence, et le numéro de modification pour chaque nouvel élément , respectivement. Nous créons ensuite une boucle while:

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

{}me % m$1$$0$$0 \to 1$$n \to 0, n \ne 0$

Nous arrivons ensuite à la monstruosité absolue constituée du corps de la boucle while:

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];}];

La partie principale de cette boucle est une boucle for, qui itère $4$x

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

La première instruction imprime chaque itération de la séquence avant de la modifier. Nous créons ensuite une fonction partielle pour vérifier l'égalité avec la variable de boucle xet rencontrons quatre instructions if. Chaque instruction suivante vérifie si xest égal à 1, 2, 3 ou 4 respectivement, puis attribue kà chacune des fonctions dans *, +, -et /, puis le transforme en une fonction partielle avec ecomme argument. Enfin, nous assignons eà kexécuter avec acomme deuxième argument, et à incrémenter a.

Rubis , 52 octets

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

Essayez-le en ligne!

C (clang) , 80 octets

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

Essayez-le en ligne!

A golfed switch statement.   

Merci aux nombreuses améliorations de @ceilingcat.

dzaima / APL, 34 33 octets

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

Essayez-le en ligne!

-1 grâce à ngn

TI83 / 84 BASIC, 69 octets

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

Nous avons configuré un compteur en A et effacé L1 afin de pouvoir l'utiliser pour suivre la séquence. Nous répétons ensuite jusqu'à ce que l'étape de division provoque une fraction. À l'intérieur de la boucle, nous stockons d'abord N dans la liste. Le stockage sur un élément après la fin d'une liste ou une liste vide crée cet élément, donc celui-ci ajoute à la fois le résultat de la division quand il ne provoque pas de fraction et initialise la liste lors de la première passe. Nous utilisons ensuite l'augmentation pour ajouter les 3 termes suivants de la séquence. Le calcul se réduit de quelques octets en calculant le terme A4k + 3 dans la variable O puis en basant A4k + 2 et A4k + 4 sur O. Ensuite, nous faisons la division séparément pour réinitialiser N pour la vérification de répétition et ajouter 4 à A.

J'ai mis un Disp L1 à la fin, mais je ne sais pas à quel point c'est idéal car il n'y a pas de bon moyen pour adapter tous les termes à l'écran. De manière réaliste, l'utilisateur exécuterait L1 après l'exécution manuelle du programme pour faire défiler les résultats.

Fusain , 29 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｎθ

Saisissez la valeur initiale.

Ｗ¬﹪θ¹«

Répétez jusqu'à ce que la valeur ne soit plus un entier.

Ｉθ⸿

Imprimez la valeur sur sa propre ligne.

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

Calculez les quatre opérations arithmétiques disponibles et sélectionnez la bonne en fonction du numéro de ligne de sortie actuel.

Python 3 , 78 76 octets

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

Essayez-le en ligne!

Prend l'entrée comme une liste de 1 élément et ajoute récursivement l'élément suivant de la séquence jusqu'à ce qu'il ne soit pas un entier.

Dans le cas où la prise d'entrée en tant que liste n'est pas autorisée, voici une version corrigée très rapidement qui prend l'entrée en tant qu'int.

Entrée sous forme d'entier, 102 octets

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

Essayez-le en ligne!

+2 octets grâce à moi en oubliant de nommer la fonction récursive ...
-4 octets grâce à Jitse

Brindille , 164 octets

D'accord, c'était vraiment horrible à écrire.

Limites:

• Non returns! Vous sortez ou ne sortez pas
• Pas de whileboucles. Vous devez utiliser la récursivité ou rien
• Pas de moyen facile de sortir! Vous devez répéter la sortie à chaque fois
• Vous ne pouvez pas donner une valeur aux variables sans utiliser le set balise
• Pas un moyen facile de sortir d'une boucle. Il n'y a pas break, continue, gotoou similaire. Cela rend une boucle impossible à utiliser.
• Il n'y a qu'une seule boucle:, for ... in ....et elle boucle sur tous les éléments d'un tableau, sans aucun moyen de s'arrêter.

Tous ceux-là ont rendu le code massif!
Hé, je l'ai même rendu plus long que la réponse Java!
C'est aussi long que la réponse JavaScript de @ Arnauld ! ... Avec les 3 alternatives combinées.

Voici le 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%}

Vous pouvez l'essayer sur https://twigfiddle.com/zw5zls

Comment utiliser:

Importez simplement le fichier et appelez la première macro.

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

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

Pour avoir un tableau utilisable, vous pouvez le faire a.a(21)|split(',').

Non golfé:

{% 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 %}

Doit être facile à lire.
Cette réponse non golfée ne donnera PAS la sortie correcte, car elle jettera des espaces blancs aléatoires.
Il existe simplement pour être humainement lisible.