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

Inspirado en este rompecabezas , dado un número entero $n>0$ , imprima la siguiente secuencia hasta que llegue a un número entero (estropeado, en caso de que quiera resolver el rompecabezas usted mismo primero)

$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)$
o más intuitivamente: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

Casos de prueba:

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

La entrada y salida pueden tomarse en cualquier formato razonable, las lagunas estándar están tan prohibidas como de costumbre.

En el espíritu del código golf , ¡la respuesta más corta en bytes gana!

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

05AB1E (heredado) , 18 17 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Estoy usando la versión heredada de 05AB1E aquí, y también calculo primero el siguiente número antes de imprimirlo, porque el bucle está basado en 0 y lo hará /0en la primera iteración. Esto salvó un byte en comparación con el anterior N>y "*+-/". Esto solo funciona, porque en la versión heredada un número que se divide por 0 sigue siendo el mismo; mientras que en la nueva versión se convertiría en 0; y en matemática real daría una división por cero error.

Scratch 3.0 39 bloques / 323 bytes

Intentalo línea scratch!

Alternativamente, como sintaxis 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

Miren a ustedes, divirtiéndose con su imaginación eval declaraciones! ¡Pues yo no! No ... Scratch no tiene evaluaciones, así que tuve que hacer las cosas de la manera más difícil ... si las declaraciones.

Al menos no es gotos ...

Espacio en blanco , 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébalo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

-24 bytes después de un comentario de @JoKing sugiriendo n%i > 0. Aunque solo if(x < 0)y if(x == 0)están disponibles en espacios en blanco, simplemente marcandoif(x*-1 < 0) es básicamente el mismo que if(x > 0).
Un -25 bytes adicionales gracias a @JoKing .

Explicación:

Cita del respuesta Scratch :

Al menos no es gotos ...

Alguien dijo goto ? El espacio en blanco no tiene más que gotocrear bucles y sentencias if. xD Además, es un lenguaje basado en pila, por lo que tengo que intercambiar / descartar / copiar con bastante frecuencia. Y para colmo: el espacio en blanco ni siquiera tiene puntos flotantes y solo división de enteros, por lo que solía n % i * -1 < 0salir del programa si el entero no puede dividir el número actual.

Pseudocódigo:

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 gracias a Will Ness -1 byte gracias a 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

Pruébalo en línea!

Evita el uso de entradas fraccionales para guardar en bytes

JavaScript (V8) , 52 bytes

Imprime grupos de 4 términos. Inspirado por la respuesta de GB Ruby .

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

Pruébalo en línea!

JavaScript (V8) , 54 bytes

Imprime los términos de la secuencia.

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

Pruébalo en línea!

JavaScript (ES6),  59  58 bytes

Devuelve una matriz.

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

Pruébalo en línea!

Perl 6 , 44 bytes

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

Pruébalo en línea!

Bloque de código anónimo que toma un número y devuelve una secuencia. Si pudiéramos omitir el primer elemento (que siempre es el mismo que el segundo elemento de todos modos), podríamos ahorrar 3 bytes eliminando el$_,

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)

Pruébalo en línea!

Piet , 297 190 144 CODELs (432 bytes)

Intenté un nuevo enfoque usando un pointercomando como interruptor (k mod 4) para unificar el código de salida, lo que resultó en una imagen de código 10x19 más densa. Luego jugué golf por 1 fila y 2 columnas a 8x18.

Aquí hay un rastro, para ver cómo funciona:

La primera línea empuja un 0 en la pila como índice inicial (ya que solo podemos push números naturales, empujamos 2 unos y luego restamos), luego lee la entrada como número.

La columna de la izquierda tiene el código compartido de duplicar el número y sacar uno a la salida, luego mueve el índice en la parte superior de la pila, incrementándolo y luego duplicándolo tres veces. Luego ingresamos el bloque en forma de r de color rojo pastel a través del codel cian oscuro para obtener un pointercomando que nos da diferentes caminos para el resto de nuestro mod de índice 4.

Mod 1, salimos por la parte superior para multiplicar. Primero barajamos una copia de nuestro índice hacia abajo para luego, luego realizamos la multiplicación. Después de pasar por el blanco para un noop, ingresamos a la columna de arriba para corregir la paridad cc (se debe voltear un número par de veces para mantener el ciclo estable), seguido de unpointer (1) de ingresar a la barra magenta: actúa como un coger nuestros cuatro caminos y enviarnos de vuelta al bucle.

Mod 2, salimos hacia atrás para sumar. La forma del bloque de código en colores pastel significa que salimos de una fila arriba de donde ingresamos, y usamos el 3 que empujamos hacia la pila al salir a través del códec rojo hacia pointer (3)nosotros. Esta columna tiene el espacio en blanco antes de la aritmética y un orden ligeramente diferente de presionar y cambiar cc, porque de lo contrario tendríamos una superposición de color con códeles con valores enteros en la columna adyacente.

Mod 3 envíanos hacia abajo para restar. El mismo trato que la multiplicación, excepto que cruzamos el camino de división en el camino hacia arriba (como el cc tiene paridad diferente al ingresar a la barra verde pastel, las dos ejecuciones salen de esa barra en diferentes extremos). Mientras lo hacemos, tomamos un duplicatecomando no deseado , por lo popque retrocedemos con el códec verde oscuro antes de ingresar a la barra de corrección y colección de cc.

Mod 4, vamos hacia adelante para dividir. Aquí, primero tenemos que volver a barajar la pila más severamente para obtener dos pares de n y a para realizar operaciones, porque necesitamos probar si es entero. Hacemos lo que hago moden el primer par, luego noten el resultado, luego lo usamos para un pointer: si no es divisible, seguimos recto, lo que nos envía con dos pointercomandos a la esquina opuesta al bloque ineludible y así termina el programa. De lo contrario, giramos a la derecha y obtenemos un dividecomando al ingresar a la barra magenta.

Versión antigua

Código muy sencillo: empuja un 1 y la entrada en la pila, luego recorre las cuatro operaciones: barajando el índice en la parte superior de la pila, incrementándolo en 1, duplicándolo, barajando una copia hacia abajo, realizando la operación aritmética, duplicando el número y sacando uno a la salida.

Para la división, que es la única en la que la secuencia puede terminar, crea una pila más complicada para verificar primero si n mod index == 0, de lo contrario, ingresa al códele ineludible y termina. De lo contrario, utiliza su segunda copia de i y n para realizar la división.

C # (compilador interactivo de Visual C #) , 72 , 70 , 69 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Después de algún intento (fallido) con eval, descubrí que la solución más feliz es construir la matriz con 4 elementos a la vez, al menos en rubí.

Gracias a Arnauld por -2 bytes.

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

Una implementación simple de las reglas:

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]

Pruébalo en línea!

con lo T<13siguiente de un análisis más profundo del rompecabezas. De hecho, solo hay tres tipos de secuencias: las de longitud 4, cuando a⁰ no es congruente con 1 módulo 8; los de longitud 12 cuando a⁰ es congruente con 21 módulo 32; y los de longitud 8 para los casos restantes.

Un código alternativo que evita los bucles termina siendo más largo con 87 bytes:

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

Pruébalo en línea!

Haskell , 104 86 85 bytes

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

Pruébalo en línea!

Se h=puede omitir ya que solo se usa para pruebas.

Ah, codifique el golf, donde un aumento cuadrático en la complejidad del tiempo vale la pena para la reducción de un personaje.

104 bytes

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

Pruébalo en línea!

Me gusta más esta respuesta, pero por desgracia es más larga.

Japt , 25 24 bytes

Otra adaptación de la solución Ruby de GB .

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

Intentalo

El truco principal aquí está en la sobrecarga del cmétodo para matrices. Páselo otra matriz como argumento y lo concatena a la matriz original. Pase un número como argumento, como sucede en la última llamada recursiva, y aplana la matriz original en tantos niveles, 1en este caso, después del redondeo. Pero, como la matriz solo tiene un nivel de profundidad, el aplanamiento no tiene ningún efecto.

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

Pruébalo en línea.

La creación de una matriz con los cuatro valores está inspirada en la respuesta Ruby de @GB , aunque ahora me doy cuenta de que usar una declaración if ternaria es la misma cantidad de bytes:

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

Pruébalo en línea.

Perl 5 , 53 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

AWK , 57 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

Ya es hora de que vuelva a usar Rutger. Desafortunadamente, puede que no sea el mejor lenguaje para la tarea, ya que no tiene forma de evalobligarme a usar cuatro declaraciones if

Cómo funciona

¿Cómo funciona Rutger?

Un breve prólogo sobre cómo funciona el lenguaje: todo es una asignación o una función, y cada función toma exactamente un argumento. Para operaciones que requieren más de un argumento (por ejemplo, multiplicación), la primera llamada devuelve una función parcial que, cuando se llama nuevamente con el segundo argumento, devuelve el resultado esperado. Por ejemplo:

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

imprimirá 30: ¡ Pruébelo en línea!. Si bien esto suele ser más largo que la alternativa habitual, a veces puede guardar bytes, si se llama a una función repetidamente con un argumento constante y un argumento cambiante, por ejemplo, al imprimir tablas de tiempos.

Esta regla de argumento se aplica a todo lo que no es una constante o una variable, incluidos los bucles y condicionales. Sin embargo, los bucles y condicionales ( For, Each, While, DoWhile, Ify IfElse) son factibles , lo que significa que con el fin de ejecutar de hecho ellos, elDo función debe ser llamada (véase la última línea de la respuesta). Nuevamente, esto puede ahorrar bytes cuando se ejecuta repetidamente el mismo bucle, o le permite ejecutar código arbitrario entre la definición y la ejecución de bucles.

Finalmente, hay tres formas de referirse a las variables, todas las cuales se utilizan en este programa. El primero es la referencia directa , donde el nombre de la variable tiene como prefijo un $símbolo. Esto accede al valor de la variable directamente y lo devuelve. El segundo es la referencia funcional , que no tiene un carácter de prefijo. Esto permite que el código distinga entre funciones (potencialmente parciales) asignadas a variables y variables reales que contienen un valor específico. Finalmente, la referencia indirecta , con el prefijo de un @símbolo, crea una variable (si aún no existe) y devuelve el objeto variable dentro de un ámbito determinado. Esto le permite crear una variable de bucle (por ejemplo, ien for i in range(...)).

Cómo funciona la solución real

Aquí está el código sin 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];

Pruébalo en línea!

Como se puede ver, se inicia mediante la asignación de las tres variables n, ey a, lo que representa la entrada, el elemento de cambio en la secuencia, y el número de modificación para cada nuevo elemento, respectivamente. Luego creamos un ciclo while:

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

Las llaves ( {y }) definen un bloque de código, donde la declaración final en el bloque es la condición para el ciclo while. En este caso, comenzamos definiendo una función de módulo parcial, que tomará un segundo argumento my regresará e % m. Luego llamamos a esta función parcial con$1$ como segundo argumento, volviendo $0$para enteros y un entero distinto de cero para flotantes. Luego calculamos el no lógico de esto, mapeo$0 \to 1$ y $n \to 0, n \ne 0$.

Luego llegamos a la monstruosidad absoluta que consiste en el cuerpo del bucle 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 parte principal de este ciclo es un ciclo for, que itera $4$veces cada iteración del ciclo while, tiene una variable de iteración de xy consiste en:

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 primera declaración imprime cada iteración de la secuencia antes de modificarla. Luego creamos una función parcial para verificar la igualdad con la variable de bucle x, y encontramos cuatro declaraciones if. Cada uno de los estados comprueba si xes igual a 1, 2, 3 o 4, respectivamente, y entonces asigna ka cada función en *, +, -y /, a continuación, lo hace en una función parcial con ecomo su argumento. Finalmente, se asigna ea kcorrer con acomo segundo argumento, y el incremento 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}

Pruébalo en línea!

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

Pruébalo en línea!

A golfed switch statement.   

Gracias a muchas mejoras de @ceilingcat.

dzaima / APL, 34 33 bytes

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

Pruébalo en línea!

-1 gracias a ngn

TI83 / 84 BÁSICO, 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

Configuramos un contador en A y borramos L1 para poder usarlo para rastrear la secuencia. Luego repetimos hasta que el paso de división causa una fracción. Dentro del bucle, primero almacenamos N en la lista. El almacenamiento en un elemento más allá del final de una lista o una lista vacía crea ese elemento, por lo que este almacén agrega el resultado de la división cuando no causa una fracción e inicializa la lista durante el primer paso. Luego usamos aumentar para agregar los siguientes 3 términos de la secuencia. La matemática resuelve algunos bytes más pequeños calculando el término A4k + 3 en la variable O y luego basando A4k + 2 y A4k + 4 en O. Luego hacemos la división por separado para restablecer N para la verificación repetida y sumar 4 a A.

Puse un Disp L1 al final, pero no estoy seguro de lo ideal que es, ya que no hay una buena manera de ajustar todos los términos en la pantalla. Siendo realistas, el usuario ejecutaría L1 después de que el programa se ejecute manualmente para desplazarse por los resultados.

Carbón , 29 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｎθ

Ingrese el valor inicial.

Ｗ¬﹪θ¹«

Repita hasta que el valor ya no sea un número entero.

Ｉθ⸿

Imprima el valor en su propia línea.

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

Calcule las cuatro operaciones aritméticas disponibles y seleccione la correcta según el número de línea de salida actual.

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

Pruébalo en línea!

Toma la entrada como una lista de 1 elemento y agrega recursivamente el siguiente elemento de la secuencia hasta que no sea un entero.

En el caso de que no se permita tomar entradas como una lista, aquí hay una versión parcheada muy rápida que toma entradas como int.

Entrada como un entero, 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)")])

Pruébalo en línea!

+2 bytes gracias a mí olvidando nombrar la función recursiva ...
-4 bytes gracias a Jitse

Ramita , 164 bytes

De acuerdo, esto fue realmente horrible de escribir.

Limitaciones:

• No returns! Usted sale o no sale
• Sin whilebucles. Usted debe utilizar la recursividad o nada
• No hay forma fácil de salida! Tienes que repetir la salida cada vez
• No puede dar un valor a las variables sin usar la setetiqueta
• No hay forma fácil de salir de un círculo. No hay es break, continue,goto o similar. Esto hace que un bucle sea imposible de usar.
• Solo hay 1 bucle: for ... in ....y recorre todos los elementos de una matriz, sin forma de detenerse.

¡Todos esos hicieron el código masivo!
¡Hey, incluso lo hice más largo que la respuesta de Java!
¡Es tan largo como la respuesta de JavaScript de @ Arnauld ! ... Con las 3 alternativas combinadas.

Aquí está el código:

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

Puedes probarlo en https://twigfiddle.com/zw5zls

Cómo utilizar:

Simplemente importe el archivo y llame a la primera macro.

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

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

Para tener una matriz utilizable, puede hacerlo a.a(21)|split(',').

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

Debería ser fácil de leer.
Esta respuesta no reflejada NO dará el resultado correcto, ya que arrojará espacios en blanco al azar.
Existe simplemente para ser legible humanamente.