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

Вдохновленный этой головоломкой , учитывая целое число , распечатайте следующую последовательность, пока не достигнете нецелого числа (испорченного, если вы хотите решить головоломку самостоятельно в первую очередь)$n>0$

$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)$
или более интуитивно: * 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

Ввод и вывод могут быть приняты в любом разумном формате, стандартные лазейки, как обычно, запрещены.

В духе код-гольфа выигрывает самый короткий ответ в байтах!

Песочница: https://codegolf.meta.stackexchange.com/a/18142/59642

05AB1E (наследие) , 18 17 байт

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

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

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

Я использую унаследованную версию 05AB1E здесь, а также сначала вычисляю следующее число, прежде чем печатать его, потому что цикл основан на 0, и это будет сделано /0в самой первой итерации. Это сохранило байт по сравнению с предыдущим N>и "*+-/". Это работает только потому, что в прежней версии число, которое делится на 0, остается неизменным; тогда как в новой версии он станет 0; и в реальной математике это дало бы деление на ноль ошибок.

Scratch 3.0 39 блоков / 323 байта

Попробуйте это на линии нуля!

В качестве альтернативы, как синтаксис 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

Посмотрите на вас, ребята, весело проводя время со своими модными evalвысказываниями! Ну не я! Нет ... У царапины нет никаких злых укусов, поэтому мне пришлось делать что-то нелегко ... если заявления.

По крайней мере, это не gotoс ...

Пробелы , 251 227 202 байта

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

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.
[..._some_action]добавлено только в качестве объяснения.

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).

-24 байта после комментария предложения @JoKingn%i > 0 . Хотя только if(x < 0)и if(x == 0)доступны в Whitespace, простая проверка if(x*-1 < 0)в основном такая же, как if(x > 0).
Дополнительные -25 байтов благодаря @JoKing .

Объяснение:

Цитата с нуля ответ :

По крайней мере, это не gotoс ...

Кто-то сказал goto? Пробел не имеет ничего, кроме gotoкак создавать и циклы, и операторы if. xD Кроме того, это основанный на стеке язык, поэтому мне приходится довольно часто менять / копировать / копировать. И в завершение: в пробеле нет даже чисел с плавающей запятой и только целочисленное деление, поэтому я использовал n % i * -1 < 0для выхода из программы, если целое не может разделить текущее число.

Псевдо-код:

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 байта

-1 байт благодаря Will Ness -1 байт благодаря 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

Попробуйте онлайн!

Позволяет избежать использования дробных целых чисел для экономии на байтах

JavaScript (V8) , 52 байта

Печатает группы из 4 членов. Вдохновленный ответом Ruby от GB .

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

Попробуйте онлайн!

JavaScript (V8) , 54 байта

Печатает условия последовательности.

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

Попробуйте онлайн!

JavaScript (ES6),  59  58 байт

Возвращает массив.

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

Попробуйте онлайн!

Perl 6 , 44 байта

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

Попробуйте онлайн!

Блок анонимного кода, который принимает число и возвращает последовательность. Если бы мы могли пропустить первый элемент (который всегда совпадает со вторым элементом), мы могли бы сохранить 3 байта, удалив$_,

Python 3 , 60 байт

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

Попробуйте онлайн!

Piet , 297 190 144 кодекса (432 байта)

Попробовал новый подход с использованием pointerкоманды в качестве переключателя (k mod 4) для унификации выходного кода, в результате чего получилось более плотное изображение кода 10x19. Затем я проиграл это на 1 ряд и 2 столбца до 8х18.

Вот след, чтобы увидеть, как это работает:

Первая строка помещает 0 в стек как начальный индекс (так как мы можем только pushнатуральные числа, мы нажимаем 2 и затем вычитаем), затем считывает ввод как число.

Крайний левый столбец имеет общий код, дублирующий число и помещающий единицу в вывод, затем перемещающий индекс на вершину стека, увеличивающий его и затем дублирующий его трижды. Затем мы вводим пастельный красный r-образный блок через темно-голубой кодел для pointerкоманды, которая дает нам другие пути для оставшейся части нашего индексного мода 4.

Мод 1, мы выходим через верх для умножения. Сначала мы перетасовываем копию нашего индекса на потом, затем выполняем умножение. Пройдя через белый цвет для noop, мы вводим столбец выше, чтобы зафиксировать четность cc (его необходимо перевернуть четное число раз, чтобы цикл оставался стабильным), после чего следует pointer (1)вход в пурпурный бар: он действует как поймать наши четыре пути и отправить нас обратно в петлю.

Мод 2, мы выходим назад к сумме. Форма блока пастельных кодов означает, что мы выходим из строки выше, откуда мы вошли, и мы используем 3, которые мы помещаем в стек, выходя через красную кодовую область к pointer (3)себе вверх. Этот столбец имеет пустое пространство перед арифметикой и немного другой порядок нажатия и переключения cc, потому что в противном случае мы имели бы перекрытие цвета с целочисленными коделами в соседнем столбце.

Мод 3 отправляет нас вниз для вычитания. То же самое, что и умножение, за исключением того, что мы пересекаем путь деления на пути вверх (так как при вводе пастельного зеленого бара у cc разный паритет, два выполнения выходят из этого бара с разных концов). При этом мы подбираем нежелательную duplicateкоманду, поэтому popперед тем, как войти в панель коррекции и сбора cc , мы возвращаем ее обратно с темно-зеленой кодировкой.

Мод 4, мы идем прямо вперед, чтобы разделить. Здесь мы сначала должны переставить стек более строго, чтобы получить две пары n и a для выполнения операций, потому что нам нужно проверить, является ли оно целым числом. Мы делаем это modдля первой пары, затем notдля результата, затем используем это для a pointer- если это не делится, мы продолжаем идти прямо, что отправляет нас двумя pointerкомандами в противоположный угол в неизбежный блок и, таким образом, завершает программу. В противном случае мы поворачиваем направо и получаем divideкоманду от входа в пурпурный бар.

Старая версия

Очень простой код: помещает 1 и ввод в стек, затем циклически проходит четыре операции: перетасовывает индекс на вершине стека, увеличивает его на 1, дублирует, перекладывает одну копию обратно, выполняет арифметическую операцию, дублируя номер и вставляя один в вывод.

Для деления, которое является единственным, где последовательность может заканчиваться, он создает более сложный стек, чтобы сначала проверить, равен ли индекс n mod == 0, в противном случае он входит в неизбежный кодер и завершается. В противном случае он использует свою вторую копию i и n для выполнения деления.

C # (интерактивный компилятор Visual C #) , 72 , 70 , 69 байт

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

Попробуйте онлайн!

Рубин , 56 54 52 байта

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

Попробуйте онлайн!

После некоторых (неудачных) попыток evalя обнаружил, что самым удачным решением является сборка массива из 4 элементов одновременно, по крайней мере, в ruby.

Спасибо Арно за -2 байта.

R , 90 байтов , 87 байтов 85 байтов 80 байтов 74 73 байта

Простая реализация правил:

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]

Попробуйте онлайн!

со T<13следующим из более глубокого анализа головоломки. Действительно, существует только три вида последовательностей: последовательности длиной 4, когда a⁰ не совпадает с 1 по модулю 8; длины 12, когда a⁰ конгруэнтно 21 по модулю 32; и длины 8 для остальных случаев.

Альтернативный код, избегающий циклов, оказывается длиннее с 87 байтами:

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

Попробуйте онлайн!

Haskell , 104 86 85 байт

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

Попробуйте онлайн!

h=Могут быть опущены , так как он используется только для тестирования.

Ах, код гольф, где квадратичное увеличение сложности времени стоит того, чтобы уменьшить одного персонажа.

104 байта

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

Попробуйте онлайн!

Мне больше нравится этот ответ, но, увы, он длиннее.

Japt , 25 24 байта

Еще одна адаптация решения Ruby от GB .

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

Попытайся

Основной трюк здесь заключается в перегрузке cметода для массивов. Передайте ему другой массив в качестве аргумента, и он объединит его с исходным массивом. Передайте ему число в качестве аргумента, как это происходит при последнем рекурсивном вызове, и он выравнивает исходный массив на столько уровней - 1в данном случае после округления. Но, поскольку массив имеет глубину всего один уровень, выравнивание не оказывает никакого влияния.

%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 байта

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

Попробуйте онлайн.

Создание массива со всеми четырьмя значениями вдохновлено ответом Ruby от @GB , хотя теперь я заметил, что использование троичного оператора if - это то же количество байтов:

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

Попробуйте онлайн.

Perl 5 , 53 байта

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

Попробуйте онлайн!

Красный , 102 байта

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

Попробуйте онлайн!

AWK , 57 байт

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

Попробуйте онлайн!

Рутгер , 310 байт

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

Попробуйте онлайн!

Пришло время снова использовать Рутгер. К сожалению, это может быть не самый лучший язык для этой задачи, так как он не имеет формы eval, заставляя меня использовать четыре оператора if

Как это работает

Как работает Рутгер

Краткое предисловие о том, как работает язык: все является либо назначением, либо функцией, и каждая функция принимает ровно один аргумент. Для операций, которые требуют более одного аргумента (например, умножение), первый вызов возвращает частичную функцию , которая при повторном вызове со вторым аргументом возвращает ожидаемый результат. Например:

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

распечатает 30: Попробуйте онлайн! , Хотя обычно это длиннее, чем обычная альтернатива, она может иногда сохранять байты, если функция вызывается повторно с одним постоянным аргументом и одним изменяющимся аргументом, например, при распечатке таблиц времени.

Это правило с одним аргументом применяется ко всему, что не является константой или переменной, включая циклы и условные выражения. Однако, циклы и условные ( For, Each, While, DoWhile, Ifи IfElse) являются выполнимыми , а это означает , что для того , чтобы фактически запустить их, Doфункция должна быть вызвана (см последней строки в ответе). Опять же, это может сохранить байты при многократном запуске одного и того же цикла или позволить вам запустить произвольный код между определением и выполнением циклов.

Наконец, есть три способа обращения к переменным, каждый из которых используется в этой программе. Первый - это прямая ссылка , где перед именем переменной стоит $символ. Это напрямую обращается к значению переменной и возвращает его. Второе - это функциональные ссылки , которые не имеют префиксного символа. Это позволяет коду различать (потенциально частичные) функции, назначенные переменным, и фактические переменные, содержащие определенное значение. Наконец, косвенная ссылка с префиксом @символа создает переменную (если она еще не существует) и возвращает объект переменной в заданной области видимости. Это позволяет вам создать переменную цикла (например, iв for i in range(...)).

Как работает настоящее решение

Вот негольфированный код:

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

Попробуйте онлайн!

Как видно, она начинает путем присвоения трех переменных n, eи a, которые представляют собой входные данные , изменяющийся элемент в последовательности, и число модификации для каждого нового элемента соответственно. Затем мы создаем цикл while:

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

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

Далее мы подходим к абсолютному чудовищу, состоящему из тела цикла 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];}];

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

Первый оператор печатает каждую итерацию последовательности перед ее изменением. Затем мы создаем частичную функцию для проверки равенства с переменной цикла xи встречаемся с четырьмя операторами if. Каждый оператор проверяет , если xравно 1, 2, 3 или 4 соответственно, а затем назначают kдля каждой функции в *, +, -и /, затем делает его в частичную функцию с в eкачестве аргумента. Наконец, мы относим eк kработать с в aкачестве второго аргумента и приращения a.

Рубин , 52 байта

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

Попробуйте онлайн!

C (лязг) , 80 байтов

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

Попробуйте онлайн!

A golfed switch statement.   

Благодаря многим улучшениям @ceilingcat.

dzaima / APL, 34 33 байта

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

Попробуйте онлайн!

-1 благодаря ngn

TI83 / 84 BASIC, 69 байт

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

Мы установили счетчик в A и очистили L1, чтобы мы могли использовать его для отслеживания последовательности. Затем мы повторяем, пока шаг деления не вызовет дробь. Внутри цикла мы сначала сохраняем N в списке. Сохранение до одного элемента после конца списка или пустого списка создает этот элемент, поэтому это хранилище добавляет результат деления, когда оно не вызывает дроби, и инициализирует список во время первого прохода. Затем мы используем добавление, чтобы добавить следующие 3 условия последовательности. Математика отрабатывает на несколько байтов меньше, вычисляя член A4k + 3 в переменной O, а затем основывая A4k + 2 и A4k + 4 на O. Затем мы делаем деление отдельно, чтобы сбросить N для повторной проверки и добавить 4 к A.

Я поставил Disp L1 в конце, но я не уверен, насколько он идеален, потому что нет хорошего способа разместить все термины на экране. Реально пользователь будет выполнять L1 после запуска программы вручную, чтобы прокрутить результаты.

Древесный уголь , 29 байт

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

Попробуйте онлайн!Ссылка на подробную версию кода. Объяснение:

Ｎθ

Введите начальное значение.

Ｗ¬﹪θ¹«

Повторяйте, пока значение больше не будет целым числом.

Ｉθ⸿

Выведите значение в отдельной строке.

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

Рассчитайте четыре доступных арифметических действия и выберите правильную в зависимости от текущего номера строки вывода.

Python 3 , 78 76 байт

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

Попробуйте онлайн!

Принимает input как список из 1 элемента и рекурсивно добавляет следующий элемент последовательности, пока он не будет целочисленным.

В случае если ввод данных в качестве списка не разрешен, здесь очень быстро исправленная версия, которая принимает ввод как int.

Вводится как целое число, 102 байта

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

Попробуйте онлайн!

+2 байта благодаря тому, что я забыл назвать рекурсивную функцию ...
-4 байта благодаря Джитсе

прут , 164 байта

Хорошо, это было действительно ужасно писать.

Ограничения:

• нет returns ! Вы либо выводите, либо не выводите
• Нет whileпетель. Вы должны использовать рекурсию или ничего
• Нет простого способа вывода! Вы должны повторять вывод каждый раз
• Вы не можете дать переменным значение без использования set тега
• Нет простого способа выйти из цикла. Там нет break, continue, gotoили аналогичный. Это делает цикл невозможным для использования.
• Существует только 1 цикл:, for ... in ....и он проходит по всем элементам массива без возможности остановки.

Все это сделало код массивным!
Эй, я даже сделал это дольше, чем ответ Java!
Это так долго, как ответ @ Arnauld's JavaScript ! ... Со всеми 3 альтернативами в сочетании.

Вот код:

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

Вы можете примерить это на https://twigfiddle.com/zw5zls

Как использовать:

Просто импортируйте файл и вызовите первый макрос.

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

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

Чтобы иметь пригодный для использования массив, вы можете сделать 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 %}

Должно быть легко читаемым.
Этот негольфированный ответ НЕ даст правильного результата, так как он выбрасывает случайные пробелы.
Он существует просто для того, чтобы быть читаемым человеком.