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

Inspirado neste quebra-cabeça , dado um número inteiro $n>0$ , imprima a sequência a seguir até chegar a um número não inteiro (spoiler, caso você queira resolver o quebra-cabeça primeiro)

$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 mais intuitivamente: * 1, +2, -3, / 4, * 5, +6, -7, / 8, ...

Casos de teste:

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

A entrada e a saída podem ser feitas em qualquer formato razoável; as brechas padrão são proibidas como de costume.

No espírito do código-golfe , a resposta mais curta em bytes ganha!

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

05AB1E (herdado) , 18 17 bytes

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

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Estou usando a versão herdada do 05AB1E aqui e também primeiro calcule o próximo número antes de imprimi-lo, porque o loop é baseado em 0 e fará uma /0na primeira iteração. Isso salvou um byte em comparação com o anterior N>e "*+-/". Isso só funciona, porque na versão herdada, um número dividido por 0 permanece o mesmo; considerando que na nova versão se tornaria 0; e na matemática real daria uma divisão por erro zero.

Scratch 3.0 39 blocos / 323 bytes

Experimente na linha zero!

Como alternativa, como sintaxe 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

Olhe para vocês, se divertindo com suas evaldeclarações chiques ! Bem, eu não! Não ... Scratch não tem avaliações, então eu tive que fazer as coisas da maneira mais difícil ... se declarações.

Pelo menos não é gotos ...

Espaço em branco , 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]

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

-24 bytes após um comentário da sugestão @JoKingn%i > 0 . Embora apenas if(x < 0)e if(x == 0)estejam disponíveis no espaço em branco, a simples verificação if(x*-1 < 0)é basicamente a mesma que if(x > 0).
-25 bytes adicionais graças a @JoKing .

Explicação:

Citação da resposta do zero :

Pelo menos não é gotos ...

Alguém disse goto? Espaço em branco não tem mais do gotoque criar loops e instruções if. xD Além disso, é uma linguagem baseada em pilha, então eu tenho que trocar / descartar / copiar com bastante frequência. E ainda por cima: o espaço em branco nem mesmo tem pontos flutuantes e apenas divisão de números inteiros, então usei n % i * -1 < 0para sair do programa se o número inteiro não puder dividir o número atual.

Pseudo-có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 graças a Will Ness -1 byte graças 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

Experimente online!

Evita o uso de ints fracionários para economizar em bytes

JavaScript (V8) , 52 bytes

Imprime grupos de 4 termos. Inspirado pela resposta Ruby da GB .

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

Experimente online!

JavaScript (V8) , 54 bytes

Imprime os termos da sequência.

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

Experimente online!

JavaScript (ES6),  59  58 bytes

Retorna uma matriz.

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

Experimente online!

Perl 6 , 44 bytes

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

Experimente online!

Bloco de código anônimo que pega um número e retorna uma sequência. Se pudéssemos pular o primeiro elemento (que é sempre o mesmo que o segundo elemento), poderíamos salvar 3 bytes removendo o$_,

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)

Experimente online!

Piet , 297 190 144 codels (432 bytes)

Tentei uma nova abordagem usando um pointercomando como switch (k mod 4) para unificar o código de saída, resultando em uma imagem de código 10x19 mais densa. Depois, joguei isso em 1 linha e 2 colunas para 8x18.

Aqui está um rastreamento, para ver como funciona:

A primeira linha empurra um 0 na pilha como índice inicial (já que podemos apenas pushnúmeros naturais, pressionamos 2 e subtraímos) e, em seguida, lê a entrada como número.

A coluna mais à esquerda tem o código compartilhado de duplicar o número e inserir um na saída, movendo o índice no topo da pilha, incrementando-o e duplicando-o três vezes. Em seguida, inserimos o bloco vermelho pastel em forma de r através do codel ciano escuro para um pointercomando que nos fornece caminhos diferentes para o restante do nosso índice mod 4.

Mod 1, saímos pelo topo para multiplicar. Primeiro, embaralhamos uma cópia do nosso índice para mais tarde e, em seguida, executamos a multiplicação. Depois de passar pelo branco para um noop, inserimos a coluna acima para corrigir a paridade cc (ela precisa ser invertida um número par de vezes para manter o loop estável), seguida por a pointer (1)de entrar na barra magenta: pegue nossos quatro caminhos e envie-nos de volta ao circuito.

Mod 2, saímos para trás para somar. A forma do bloco de código pastel significa que saímos de uma linha acima de onde entramos e usamos os 3 que empurramos para a pilha, saindo pelo codel vermelho para pointer (3)nós mesmos para cima. Essas colunas têm o espaço em branco antes da aritmética e uma ordem ligeiramente diferente de pressionar e alternar cc, porque, de outro modo, teríamos sobreposição de cores com codelos com valor inteiro na coluna vizinha.

O Mod 3 nos envia para baixo para subtração. O mesmo negócio que multiplicação, exceto que cruzamos o caminho da divisão no caminho para cima (como o cc tem paridade diferente ao entrar na barra verde pastel, as duas execuções saem dessa barra em extremidades diferentes). Ao fazer isso, captamos um duplicatecomando indesejado e , em popseguida, recuamos com o codel verde escuro antes de entrar na barra de correção e coleção de cc.

Mod 4, vamos em frente para dividir. Aqui, primeiro temos que reorganizar a pilha mais severamente para obter dois pares de n e a para executar operações, porque precisamos testar se é inteiro. Fazemos isso fazendo modno primeiro par, depois notno resultado e depois o usamos para um pointer- se não é divisível, continuamos em frente, o que nos envia com dois pointercomandos no canto oposto no bloco inevitável e, assim, termina o programa. Caso contrário, viramos à direita e recebemos um dividecomando de entrar na barra magenta.

Versão antiga

Código muito simples: envia um 1 e a entrada na pilha e percorre as quatro operações: Embaralhando o índice na parte superior da pilha, incrementando-o em 1, duplicando-o, reproduzindo uma cópia novamente, executando a operação aritmética, duplicar o número e colocar um na saída.

Para a divisão, que é a única onde a sequência pode terminar, ela cria uma pilha mais complicada para verificar primeiro se n mod index == 0; caso contrário, entra no codel inevitável e termina. Caso contrário, ele usa sua segunda cópia de ie para executar a divisão.

C # (compilador interativo do 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+" ");}

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

Experimente online!

Depois de alguma tentativa (falha) eval, descobri que a solução mais feliz é construir a matriz com 4 elementos ao mesmo tempo, pelo menos em rubi.

Agradecimentos a Arnauld por -2 bytes.

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

Uma implementação clara das regras:

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]

Experimente online!

com o T<13seguinte de uma análise mais profunda do quebra-cabeça. De fato, existem apenas três tipos de sequências: aquelas de comprimento 4, quando a⁰ não é congruente com 1 módulo 8; os de comprimento 12 quando a1 é congruente com o módulo 32; e os de comprimento 8 para os demais casos.

Um código alternativo que evita loops acaba sendo mais longo com 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]

Experimente online!

Haskell , 104 86 85 bytes

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

Experimente online!

o h= pode ser omitido, pois é usado apenas para teste.

Ah, código golf, onde um aumento quadrático na complexidade do tempo vale a pena pela redução de um caractere.

104 bytes

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

Experimente online!

Eu gosto mais desta resposta, mas infelizmente é mais longa.

Japonês , 25 24 bytes

Outra adaptação da solução Ruby da GB .

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

Tente

O principal truque aqui está na sobrecarga do cmétodo para matrizes. Passe outra matriz como argumento e concatene-a com a matriz original. Passe um número como argumento, como acontece na última chamada recursiva, e nivelará a matriz original em muitos níveis - 1neste caso, após o arredondamento. Mas, como o array tem apenas um nível de profundidade, o nivelamento não tem efeito.

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

Experimente online.

A criação de uma matriz com todos os quatro valores é inspirada na resposta Ruby do @GB , embora agora note que o uso de uma declaração if ternária é a mesma quantidade 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);}

Experimente online.

Perl 5 , 53 bytes

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

Experimente online!

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

Experimente online!

AWK , 57 bytes

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

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

Experimente online!

Já era hora de eu usar Rutger novamente. Infelizmente, pode não ser o melhor idioma para a tarefa, pois não possui forma deeval , me forçando a usar quatro declarações if

Como funciona

Como o Rutger funciona

Um breve prefácio sobre como a linguagem funciona: tudo é uma atribuição ou uma função, e toda função requer exatamente um argumento. Para operações que requerem mais de um argumento (por exemplo, multiplicação), a primeira chamada retorna uma função parcial que, quando chamada novamente com o segundo argumento, retorna o resultado esperado. Por exemplo:

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

imprimirá 30: Experimente online!. Embora geralmente seja mais longo do que a alternativa usual, às vezes é possível salvar bytes, se uma função for chamada repetidamente com um argumento constante e um argumento alterado, por exemplo, ao imprimir tabelas de tempos.

Essa regra de um argumento se aplica a tudo que não é uma constante ou uma variável, incluindo loops e condicionais. No entanto, loops e condicionais ( For, Each, While, DoWhile, Ife IfElse) são factível , o que significa que, a fim de realmente executá-los, a Dofunção deve ser chamada (ver a última linha na resposta). Novamente, isso pode economizar bytes ao executar repetidamente o mesmo loop ou permitir que você execute código arbitrário entre a definição e a execução de loops.

Finalmente, existem três maneiras de se referir a variáveis, todas usadas neste programa. O primeiro é a referência direta , onde o nome da variável é prefixado com um $símbolo. Isso acessa o valor da variável diretamente e a retorna. O segundo é a referência funcional , que não possui um caractere de prefixo. Isso permite que o código faça a distinção entre funções (potencialmente parciais) atribuídas a variáveis ​​e variáveis ​​reais que contêm um valor específico. Finalmente, a referência indireta , prefixada com um @símbolo, cria uma variável (se ela ainda não existe) e retorna o objeto variável dentro de um determinado escopo. Isso permite que você crie uma variável de loop (por exemplo, iin for i in range(...)).

Como a solução real funciona

Aqui está o código não destruído:

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

Experimente online!

Como você pode ver, ele começa atribuindo as três variáveis n, ee a, que representam a entrada, o elemento de mudança na seqüência, eo número de modificação para cada novo elemento respectivamente. Em seguida, criamos um loop while:

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

As chaves ( {e }) definem um bloco de código, em que a instrução final no bloco é a condição para o loop while. Nesse caso, começamos definindo uma função de módulo parcial, que receberá um segundo argumento me retornará e % m. Em seguida, chamamos essa função parcial com$1$ como seu segundo argumento, retornando $0$para números inteiros e um número inteiro diferente de zero para flutuadores. Em seguida, calculamos o não lógico disso, mapeando$0 \to 1$ e $n \to 0, n \ne 0$.

Em seguida, chegamos à monstruosidade absoluta que consiste no corpo do loop 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];}];

A parte principal desse loop é um loop for, que itera $4$vezes cada iteração do loop while, tem uma variável de iteração xe consiste em:

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

A primeira instrução imprime cada iteração da sequência antes de modificá-la. Em seguida, criamos uma função parcial para verificar a igualdade com a variável loopx e encontramos quatro instruções if. Cada instrução verifica se xé igual a 1, 2, 3 ou 4, respectivamente, e depois atribui ka cada função *, +, -e /, em seguida, faz-lo em uma função parcial com ecomo argumento. Por fim, atribuímos ea kexecução acomo segundo argumento e 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}

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

Experimente online!

A golfed switch statement.   

Graças a muitas melhorias no @ceilingcat.

dzaima / APL, 34 33 bytes

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

Experimente online!

-1 graças a 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

Montamos um contador em A e limpamos L1 para que possamos usá-lo para rastrear a sequência. Em seguida, repetimos até que a etapa de divisão cause uma fração. Dentro do loop, primeiro armazenamos N na lista. Armazenar em um elemento após o final de uma lista ou em uma lista vazia cria esse elemento; portanto, esse armazenamento adiciona o resultado da divisão quando não causa uma fração e inicializa a lista durante a primeira passagem. Em seguida, usamos aumentada para acrescentar os próximos 3 termos da sequência. A matemática elabora alguns bytes menores calculando o termo A4k + 3 na variável O e baseando A4k + 2 e A4k + 4 em O. Em seguida, fazemos a divisão separadamente para redefinir N para a verificação repetida e adicionar 4 a A.

Coloquei um Disp L1 no final, mas não tenho certeza de quão ideal é, pois não há uma boa maneira de ajustar todos os termos na tela. Realisticamente, o usuário executaria L1 após o programa ser executado manualmente para rolar pelos resultados.

Carvão , 29 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｎθ

Insira o valor inicial.

Ｗ¬﹪θ¹«

Repita até que o valor não seja mais um número inteiro.

Ｉθ⸿

Imprima o valor em sua própria linha.

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

Calcule as quatro operações aritméticas disponíveis e selecione a correta, dependendo do número da linha de saída atual.

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

Experimente online!

Recebe a entrada como uma lista de 1 item e acrescenta recursivamente o próximo item da sequência até que não seja um número inteiro.

Caso a entrada de entrada como lista não seja permitida, aqui está uma versão muito rapidamente corrigida, que recebe entrada como int.

Entrada como um inteiro, 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)")])

Experimente online!

+2 bytes graças a me esquecer de nomear a função recursiva ...
-4 bytes graças ao Jitse

Galho , 164 bytes

Ok, isso foi realmente horrível de escrever.

Limitações:

• Não returns ! Você produz ou não produz
• Sem whileloops. Você deve usar recursão ou nada
• Não é uma maneira fácil de produzir! Você tem que repetir a saída toda vez
• Você não pode atribuir um valor às variáveis ​​sem usar o set tag
• Não é uma maneira fácil de sair de um loop. Não há como break, continue, gotoou similar. Isso impossibilita o uso de um loop.
• Existe apenas 1 loop:, for ... in ....e ele percorre todos os elementos em uma matriz, sem nenhuma maneira de parar.

Todos aqueles fizeram o código enorme!
Ei, eu até fiz isso mais do que a resposta Java!
É contanto que a resposta JavaScript de @ Arnauld ! ... Com todas as 3 alternativas combinadas.

Aqui está o 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%}

Você pode experimentá-lo em https://twigfiddle.com/zw5zls

Como usar:

Simplesmente importe o arquivo e chame a primeira macro.

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

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

Para ter uma matriz utilizável, você pode fazer 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 %}

Deve ser fácil de ler.
Esta resposta não-golpeada NÃO fornecerá a saída correta, pois gerará espaços em branco aleatórios.
Existe apenas para ser humanamente legível.