正负顺序

正负序列是从两个种子开始的序列，a(0)而b(0)。该序列的每次迭代都是该序列的前两个成员的加法和减法。即a(N) = a(N-1) + b(N-1)和b(N) = a(N-1) - b(N-1)。

目的产生无限的正负序列或K给出的第一步K。您可以使用给出K第一步的无限输出程序，生成器或函数/程序来执行此操作。输出顺序无关紧要，只要它是一致的即可。（即，b(K) a(K)或a(K) b(K)，之间使用一些非数字，非换行符。）输出必须以输入开头。

测试用例

对于输入10 2（为a(0) b(0)，这是第一个K方法（或无限方法的一个子节）的可能输出：

10     2
12     8
20     4
24     16
40     8
48     32
80     16
96     64
160    32
192    128
320    64
384    256
640    128
768    512
1280   256
1536   1024
2560   512
3072   2048
5120   1024
6144   4096
10240  2048
12288  8192
20480  4096
24576  16384
40960  8192
49152  32768
81920  16384
98304  65536

对于输入2 20 10（a(0) b(0) k）：

2     20
22   -18
4     40
44   -36
8     80
88   -72
16    160
176  -144
32    320
352  -288

这是一个代码高尔夫球，因此以字节为单位的最短程序获胜。

果冻，5 个字节

ṄI;Sß

这是一种递归方法。由于尾调用的优化，唯一的限制是将两个整数都适合放入内存的能力。输出是每行一个列表。

在线尝试！

怎么运行的

ṄI;Sß  Main link. Argument: [b[n], a[n]] (n = 0 for original input)

Ṅ      Print [b[n], a[n]] to STDOUT.
 I     Compute the increments of the list, i.e., [a[n] - [b[n]].
   S   Compute the sum of the list, i.e., b[n] + a[n].
  ;    Concatenate the results to the left and to the right.
    ß  Recursively call the main link.

Python 2，31个字节

def f(a,b):print a,b;f(a+b,a-b)

永远打印。好吧，最终您超过了递归限制，但这是系统限制。

MATL，10字节

`tDtswPdhT

此版本将按正负顺序输出无限数量的元素。

在线尝试！ （由于无限循环运行后将其停止）

说明

    % Implicitly grab input as a two-element array [a,b]
`   % do...while loop
tD  % Duplicate and display the top of the stack
ts  % Duplicate [a,b] and add them together
w   % Swap the top two elements on the stack
P   % Swap the order of b and a in preparation for diff
d   % Compute the difference between b and a
h   % Horizontally concatenate [a+b, a-b]
T   % Explicit TRUE to make it an infinite loop
    % Implicit end of the do...while loop

Haskell，19个字节

a#b=a:b:(a+b)#(a-b)

产生无限个数字序列。用法示例：

Prelude> take 20 $ 2#20

[2,20,22,-18,4,40,44,-36,8,80,88,-72,16,160,176,-144,32,320,352,-288]

Pyth，10个 9字节

感谢@isaacg提供了1个字节。

#=Q,s
Q-F

打印成对的无限序列。

$ pyth plusminus.p <<< "[10,2]" | head -n 15
[10, 2]
[12, 8]
[20, 4]
[24, 16]
[40, 8]
[48, 32]
[80, 16]
[96, 64]
[160, 32]
[192, 128]
[320, 64]
[384, 256]
[640, 128]
[768, 512]
[1280, 256]

C，81个字节

a,b;main(c){for(scanf("%d%d%d",&a,&b,&c);c--;a+=b,b=a-b-b)printf("%d %d\n",a,b);}

05AB1E，7个字节

使用first-k方法。输入以下内容：

k
[a, b]

码：

FD=OsƂ

说明：

F        # For N in range(0, k).
 D=      # Duplicate top of the stack and print without popping.
   O     # Sum up the array.
    sÆ   # Swap and perform a reduced subtraction.
      ‚  # Pair the top two elements. a, b --> [a, b]

使用CP-1252编码。在线尝试！

k，12

{(+;-).\:x}\

。

k){(+;-).\:x}\[10;10 2]
10  2
12  8
20  4
24  16
40  8
48  32
80  16
96  64
160 32
192 128
320 64

也可以以

k)10{(+;-).\:x}\10 2

APL，37个字符

{⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z}

可以用作

    {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2
10 2
12 8
20 4
24 16
40 8
48 32
80 16
[...]

要么

      {⍺←3⊃3↑⍵⋄⎕←z←2↑⍵⋄⍺=1:⋄(⍺-1)∇(+/,-/)z} 10 2 6
10 2
12 8
20 4
24 16
40 8
48 32

MathGolf，8个字节

ô`αp‼+-∟

在线尝试！

以相反的顺序获取输入，但这仅仅是因为这就是将它们压入堆栈的方式。否则，长度会增加1个字节。2-3字节来自输出。无需实际每行打印一对，程序可以是æ`‼+-∟（无限期地用序列的元素填充堆栈），或者É‼+-∟（只要-d标志处于活动状态，就打印要调试的序列中除第一个元素之外的所有元素） 。

说明

ô      ∟   do-while-true
 `         duplicate the top two items
  αp       wrap last two elements in array and print
    ‼      apply next two operators to the top stack elements
     +     pop a, b : push(a+b)
      -    pop a, b : push(a-b)

蟒3.5，55 43个字节：

def q(a,b):
 while 1:print(a,b);a,b=a+b,a-b

似乎永远打印出正确的顺序。我已经能够让它继续运行大约30分钟，而不会引发任何错误，并且该程序已打印出第一个数字2301位，第二个输出1150位！基于此，我猜想，只要有足够的硬件来运行，它就可以运行更长的时间并打印出更多的数字，并且由于while循环的原因，理论上也没有递归限制！

Reng v.3.2，9个字节（自我应答，非竞争）

ii¤ææö±2.

接受两个输入（a b）和输出b a。在这里尝试！

i输入两次，¤复制堆栈，æ打印一个数字和一个空格（重复两次，两次），ö打印换行符，±执行您可能期望的操作，并2.跳过接下来的两个字符，将输入换成字符。

Python 2.7版，56，42个字节：

a,b=input()
while 1:print a,b;a,b=a+b,a-b

可以永久打印的简单循环。

批次，54个字节

@echo %1 %2
@set/aa=%1+%2
@set/ab=%1-%2
@%0 %a% %b%

请注意，CMD.EXE限于32位有符号整数，因此它将快速溢出并打印垃圾和错误消息。

朱莉娅，25个字节

a<|b=[a b]|>show<a+b<|a-b

最大程度地滥用语法。朱莉娅很奇怪。在线尝试！

替代版本，29字节

请注意，输出最终会溢出，除非你调用<|一个BigInt有。不幸的是，在这种情况下show会给每个数组加上前缀BigInt。以另外四个字节为代价，我们可以为所有数字类型生成空格分隔的输出。

a<|b="$a $b
"|>print<a+b<|a-b

在线尝试！

怎么运行的

我们<|出于输出目的定义了二进制运算符。它在Julia的最新版本中未定义，但仍被解析器识别为运算符。尽管\（未明确为整数定义）短了一个字节，但其高优先级将需要替换a+b<|a-b为(a+b)\(a-b)（+3字节）或\(a+b,a-b)（+2字节）。

当a<|b执行时，它通过调用show将[ab]打印到STDOUT开始。然后，a+b<|a-b递归调用<|总和或差。

由于递归是无限的（假设是无限的），所以<从不执行比较；唯一的目的是链接代码的两个部分。与更直接的替代方法相比，这节省了两个字节([a b]|>show;a+b<|a-b)。

Perl 6、23个字节（无限）

编辑：感谢JoKing，序列版本现在是最短的（.say根据澄清，也从OP中删除了：

{@_,{.sum,[-] |$_}...*}

TIO：无限序列

旧的功能性答案

->\a,\b {(a,b).say;f(a+b,a -b)}

TIO：InfiniteFunc

请注意，Perl 6本身没有递归限制，它完全基于可用的内存，因此在轰炸之前将达到数百万。

因子62字节

:: f ( a b -- x ) a b "%s %s" printf a b + a b - f ; recursive

recursive，否则调用栈会很快用完。

Ruby，25个字节

基于xnor的Python解决方案。也许我会在另一个答案中生成一个生成器，但这将先打印a，然后b，然后是new a，然后是new b。

f=->a,b{p a,b;f[a+b,a-b]}

Python 3，42个字节

我想为此功能编写一个生成器，所以我做到了。

def f(a,b):
 while 1:yield a,b;a,b=a+b,a-b

在Python 3中，序列是通过以下方式生成的：

>>> gen = f(2, 20)
>>> next(gen)
(2, 20)
>>> next(gen)
(22, -18)
>>> next(gen)
(4, 40)
>>> next(gen)
(44, -36)
>>> next(gen)
(8, 80)

常见的Lisp，57岁

(lambda(a b)(loop(print`(,a,b))(psetf a(+ a b)b(- a b))))

使用psetf，它会影响并行变量的值以及简单的loop语法。

bash + GNU coreutils，75个字节

a=$1
b=$2
for i in `seq $3`;{ echo -e "$a\t$b";c=$a;a=$((c+b));b=$((c-b));}

调用：

./codegolf.sh 2 10 5

CP / M 8080，47字节

z80助记符，但8080没有助记符，一旦我决定对输出而不是输入进行计数，消息源评论说，但保留了简短的函数名，手工组装，所以原谅了我知道字节数但还没有解决的“ xx”输出地址或偏移量：

# setup
ld c, 2     0e 02

# loop
.s

# update H (temporarily in B)
ld a, h     7c
add l       85
daa         27
ld b, a     46

# update L
ld a, h     7c
sub l       95
daa         27
ld l, a     6f

# copy B back to H, output H
ld h, b     60
call +o     cd xx xx

# output L
ld b, l     45
call +o     cd xx xx

# repeat
jr -s       18 xx

# output a two-digit BCD value followed by a space
.o

# output high digit
ld a, b     78
rra         1f
rra         1f
rra         1f
rra         1f
call +ob    cd xx xx

# output low digit
ld a, b     78
call +ob    cd xx xx

# output a space
ld e, #$20  1e 20
call 5      cd 00 05

# return
ret         c9

# output a single BCD digit
.ob
and #$f     e6 0f
add #$30    c6 30
ld e, a     5f
call 5      cd 00 05
ret         c9

Clojure，44个字节

#(iterate(fn[[a b]][(+ a b)(- a b)])[%1 %2])

产生无限延迟序列的函数。

Perl 5，40个字节

要求-E（免费）

sub a{say"@_";($c,$d)=@_;a($c+$d,$c-$d)}

或（相同长度）

$_=<>;{say;/ /;$_=$`+$'.$".($`-$');redo}

（我克服了后者，因为它在某些迭代中应该具有舍入误差。）

帽子尖。

但是我怀疑必须有一个较短的Perl 5解决方案。

返回，21字节

[¤.' ,$.'
,¤¤+2ª-F]=F

Try it here.

递归运算符-lambda。用法：

[¤.' ,$.'
,¤¤+2ª-F]=F10 2F

说明

[                 ]=F  declare function F for recursion
 ¤.' ,$.'␊,            output top 2 stack items along with trailing newline
           ¤¤+2ª-      get plus and minus of top 2 stack items
                 F     recurse!

> <>，26个字节

:?!;1-r:n48*o:@@:nao:@+}-$

与调用a，b，n在栈上，在这里n是匝数或无限输出为负值。输出a并b用空格分隔。

作为说明，这是堆栈在运行时如何演变的：

abn
nba
nbaa
naab
naabb
nabab
nab+
+nab
+n-
+-n

您可以通过积极的尝试在在线解释器上尝试使用它，但是您将需要使用官方的python解释器来测试无限模式。

$ python fish.py -c ':?!;1-r:n48*o:@@:nao:@+}-$' -t 0.01 -v 10 2 -1
10 2
12 8
20 4
24 16
40 8
48 32
80 16
96 64
160 32
192 128
320 64
384 256
640 128
768 512
1280 256
1536 1024
2560 512
3072 2048
5120 1024
6144 4096
10240 2048
12288 8192
20480 4096
24576 16384
40960 8192
49152 32768
81920 16384
98304 65536
163840 32768
196608 131072
327680 65536
393216 262144
655360 131072
786432 524288
1310720 262144
[...]

Fuzzy Octo鳄梨酱，17 16字节

（不竞争，使用功能晚于挑战）

^^(:C.Zs.aZ.s.-)

由于客户端错误，很难做到这一点。但是我明白了！

演练：

^^                # Get input twice, pushes it to the stack.
  (               # Start a infinite loop.
   :              # Prints the stack, and since it has [a,b] is just the output.
    C             # Copy the active stack to the inactive stack.
     .            # Shift the active stack.
      Z           # Reverse the stack.
       s          # Move the top item on the active stack to the top of the inactive.
        .         # Switch stacks again.
         a        # Add the top 2 items, giving the first new item.
          Z       # Reverse the stack, so we keep the 'a' safe and prepare for the 'b'.
           .      # Switch stacks.
            s     # Move the top item on the active stack to the top of the inactive stack.
             .    # Switch stacks.
              -   # Minus the top 2 items, giving 'b'.
               )  # End infinite loop.

认真地，12个字节

,,1WX■@│+)-1

输出无限流，格式为b(n) a(n)，每行一对输出。

没有在线链接，因为TryItOnline在无限循环方面做得不好。

说明：

,,1WX■@│+)-1
,,1           push a(0), push b(0), push 1
   W          while loop:
    X           discard the 1 (only used to make sure the while loop always runs)
     ■          print all stack elements, separated by spaces, without popping
      @│        swap, duplicate entire stack
        +)      push a(n) + b(n) (a(n+1)) and move it to the bottom of the stack
          -     push a(n) - b(n) (b(n+1))
           1    push 1 to make sure the loop continues

J，16 12字节

0&(]+/,-/)~<

根据给定的种子仅生成序列的前k个值。

使用@randomra在此注释中显示的技巧（或语法糖）节省了4个字节。

用法

   f =: 0&(]+/,-/)~<
   2 20 f 10
  2   20
 22  _18
  4   40
 44  _36
  8   80
 88  _72
 16  160
176 _144
 32  320
352 _288

C＃，50个字节

f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};

完整的源代码，包括测试用例：

using System;
using System.Numerics;

namespace PlusMinusSequence
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<BigInteger,BigInteger>f=null;
            f=(a,b)=>{Console.WriteLine(a+" "+b);f(a+b,a-b);};
            BigInteger x=10, y=2;
            f(x,y);
        }
    }
}

使用BigInteger数据类型，因此数字不会溢出并变为0。但是，由于它是递归解决方案，因此可能会出现堆栈溢出。