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，...

测试用例：

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在第一次迭代中执行a 。与之前的N>和相比，节省了一个字节"*+-/"。这只行得通，因为在旧版本中，被0除的数字保持不变。而在新版本中它将变为0；在实际的数学运算中会给出除以零的误差。

临时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陈述吧！好吧，不是我！不 ... Scratch没有评估，所以我不得不用艰难的方式做事... if陈述。

至少不是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]仅作为说明添加。

在线尝试（仅使用空格，制表符和换行符）。

@JoKing建议后的-24个字节n%i > 0。尽管只有if(x < 0)且if(x == 0)在Whitespace中可用，但是简单检查if(x*-1 < 0)基本上与相同if(x > 0)。@JoKing
额外增加了-25个字节。

说明：

引用从头开始的答案：

至少不是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字节感谢威尔·内斯 -1字节感谢尼米

(#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个字词。受GB的Ruby答案启发。

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}

在线尝试！

带有数字并返回序列的匿名代码块。如果我们可以跳过第一个元素（无论如何总是与第二个元素相同），则可以通过删除$_,

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)

在线尝试！

皮特，297个 190 144 codels（432个字节）

尝试了一种使用pointer命令作为switch（k mod 4）的新方法来统一输出代码，从而产生更密集的10x19代码图片。然后，我将其向下打了1排，并在2个立柱上打了8x18。

这是跟踪，以了解其工作原理：

第一行将栈中的0压入起始索引（因为我们只能输入push自然数，所以我们压入2并减去），然后将输入读取为数字。

最左边的列具有共享的代码：将数字复制并将其弹出到输出中，然后将索引移到堆栈的顶部，将其递增，然后将其复制三次。然后，我们通过深青色代码输入柔和的红色R形块，以pointer执行一条命令，该命令为索引mod 4的其余部分提供了不同的路径。

Mod 1，我们从顶部退出以相乘。我们首先将索引的副本改组以供以后使用，然后执行乘法。通过白色后不再打op，我们进入上方的列以固定cc奇偶校验（需要翻转偶数以保持环路稳定），然后按a pointer (1)进入洋红色条：抓住我们的四个路径，然后将我们送回循环中。

Mod 2，我们向后退出求和。柔和代码块的形状意味着我们从输入的位置上方离开一行，然后使用3 pointer (3)向上通过红色编码退出，将其推入堆栈。此列在算术运算之前具有空白，并且按和切换cc的顺序略有不同，因为否则我们将与相邻列中的整数值编解码器发生颜色重叠。

Mod 3向下送我们进行减法。与乘法的处理相同，不同之处在于我们在向上跨越分割路径时（由于cc在进入柔和的绿色条形时具有不同的奇偶校验，因此两个执行在不同的末端退出该条形）。在执行此操作时，我们会收到一个不需要的duplicate命令，因此pop在进入cc校正和收集栏之前，将其与深绿色编解码器一起退回。

Mod 4，我们直接进行划分。在这里，我们首先必须对堆栈进行更严格的重排以获取两对n和a来执行操作，因为我们需要测试它是否为整数。我们mod先在第一对上执行此操作，然后not对结果进行操作，然后将其用于pointer-如果无法将其整除，我们将继续前进，这将向我们发送两个pointer命令到对面的角落到不可避免的块中，从而结束程序。否则，我们右转并divide进入洋红色条获得命令。

旧版

非常简单的代码：将1和输入推入堆栈，然后通过以下操作循环执行以下四个操作：将索引移至堆栈顶部，将索引加1，复制，将一个副本向下移回，执行算术运算，复制数字并将一个弹出到输出中。

对于除法（这是序列可以结束的唯一方法），它创建了一个更复杂的堆栈，以首先检查n mod index == 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中。

感谢Arnauld提供了-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不等于1模8时）；当a 1等于21模32时长度为12的那些；其余长度为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 字节

GB的Ruby解决方案的另一种改编。

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

在线尝试。

创建具有所有四个值的数组的灵感来自@GB的Ruby答案，尽管我现在注意到使用三元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];

在线尝试！

现在是我再次使用Rutger的时候了。不幸的是，它可能不是最好的语言，因为它没有形式的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。

Ruby，52个字节

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

在线尝试！

C（clang），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个术语。通过计算变量O中的项A4k + 3，然后基于O来计算A4k + 2和A4k + 4，该数学计算得出的字节数要小几个字节。然后我们分别进行除法以重置N以进行重复检查，并将A加4。

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

在线尝试！

将输入作为1个项目的列表，并递归地追加序列的下一个项目，直到它成为非整数为止。

在不允许将输入作为列表的情况下，这是一个非常快速的修补版本，将输入作为整数。

输入为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个字节感谢Jitse

枝条，164字节

好吧，这实际上简直太可怕了。

局限性：

• 没有 returns！您要么输出要么不输出
• 没有while循环。你必须使用递归或不使用任何递归
• 没有简单的输出方法！您必须每次重复输出
• 您不能在不使用变量的情况下给变量赋值 set标记
• 没有简单的方法可以摆脱循环。有没有break，continue，goto或类似的。这使循环无法使用。
• 只有1个循环：for ... in ....，并且循环遍历数组中的所有元素，而没有停止的方法。

所有这些使代码变得庞大！
嘿，我什至使它比Java答案更长！
只要@Arnauld的 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(',')。

取消高尔夫：

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

应该很容易阅读。
这个没有答案的答案将不会给出正确的输出，因为它将抛出随机的空格。
它仅仅是为了人类可读而存在。