Trình tự cộng trừ

Chuỗi cộng trừ là một chuỗi bắt đầu bằng hai hạt a(0)và b(0). Mỗi lần lặp của chuỗi này là phép cộng và phép trừ của hai thành viên trước đó của chuỗi. Đó là, a(N) = a(N-1) + b(N-1)và b(N) = a(N-1) - b(N-1).

Mục tiêu Tạo ra chuỗi cộng trừ, ở mức vô hạn hoặc các Kbước đầu tiên được đưa ra K. Bạn có thể thực hiện việc này bằng cách sử dụng chương trình đầu ra vô hạn, trình tạo hoặc chức năng / chương trình đưa ra các Kbước đầu tiên . Thứ tự đầu ra không quan trọng, miễn là nó phù hợp. (Tức là, b(K) a(K)hoặc a(K) b(K), với một số dấu phân cách không phải là số, không phải dòng mới ở giữa.) Đầu ra phải bắt đầu bằng đầu vào.

Các trường hợp thử nghiệm

Đối với đầu vào 10 2(của a(0) b(0), đây là đầu ra có thể cho phương pháp K đầu tiên (hoặc phần phụ của phương pháp vô hạn):

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

Đối với đầu vào 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

Đây là một môn đánh gôn , vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng.

Thạch , 5 byte

ṄI;Sß

Đây là một cách tiếp cận đệ quy. Do tối ưu hóa cuộc gọi đuôi, giới hạn duy nhất là khả năng phù hợp với cả hai số nguyên vào bộ nhớ. Đầu ra là một danh sách trên mỗi dòng.

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ṅ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 byte

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

In mãi mãi. Chà, cuối cùng bạn vượt quá giới hạn đệ quy, nhưng đó là giới hạn hệ thống.

MATL , 10 byte

`tDtswPdhT

Phiên bản này sẽ xuất ra vô số phần tử trong chuỗi cộng trừ.

Hãy thử trực tuyến! (dừng nó sau khi chạy do vòng lặp vô hạn)

Giải trình

    % 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 byte

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

Tạo ra một chuỗi số vô hạn. Ví dụ sử dụng:

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]

Bình thường, 10 9 byte

Cảm ơn @isaacg cho 1 byte.

#=Q,s
Q-F

In một chuỗi vô hạn của các cặp.

$ 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 byte

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 byte

Sử dụng phương pháp k đầu tiên . Đầu vào sau đây cho:

k
[a, b]

Mã số:

FD=OsƂ

Giải trình:

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]

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

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

Cũng có thể được gọi dưới dạng

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

APL, 37 ký tự

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

Có thể được sử dụng như

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

hoặc là

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

MathGolf , 8 byte

ô`αp‼+-∟

Hãy thử trực tuyến!

Đưa đầu vào theo thứ tự ngược lại, nhưng đó đơn giản là vì đó là cách chúng được đẩy lên ngăn xếp. Nếu không, nó sẽ dài hơn 1 byte. 2-3 byte đến từ đầu ra. Không cần thực sự in một cặp trên mỗi dòng, chương trình có thể æ`‼+-∟(lấp đầy ngăn xếp với các phần tử của chuỗi vô thời hạn) hoặc É‼+-∟(in tất cả các phần tử của chuỗi trừ phần đầu tiên để gỡ lỗi, miễn là-d cờ được kích hoạt) .

Giải trình

ô      ∟   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)

Python 3.5, 55 43 byte:

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

In ra trình tự chính xác dường như mãi mãi. Tôi đã có thể để điều này diễn ra trong khoảng 30 phút mà không có lỗi nào được nêu ra và chương trình đã in ra 2301 chữ số cho số đầu tiên và 1150 chữ số cho lần thứ hai! Dựa trên điều này, tôi đoán rằng, được cung cấp đủ phần cứng để chạy, điều này có thể tiếp tục CÁCH lâu hơn và in ra CÁCH nhiều chữ số hơn, và về mặt lý thuyết không có giới hạn đệ quy, lịch sự của whilevòng lặp!

Reng v.3.2, 9 byte (tự trả lời, không cạnh tranh)

ii¤ææö±2.

Có hai đầu vào ( a b) và đầu rab a . Hãy thử nó ở đây!

inhận đầu vào hai lần, ¤sao chép ngăn xếp, æin một số và khoảng trắng (và thực hiện hai lần, có hai), öin một dòng mới, ±làm những gì bạn có thể mong đợi và 2.bỏ qua hai ký tự tiếp theo, bao quanh các ký tự nhận đầu vào.

Python 2.7, 56 , 42 byte:

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

Vòng lặp đơn giản hoặc in mãi mãi (ish).

Mẻ, 54 byte

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

Lưu ý rằng CMD.EXE bị giới hạn ở các số nguyên có chữ ký 32 bit, do đó, nó sẽ nhanh chóng tràn và in các thông báo lỗi và rác.

Julia, 25 byte

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

Lạm dụng cú pháp tối đa. Julia thật kỳ lạ . Hãy thử trực tuyến!

Phiên bản thay thế, 29 byte

Lưu ý rằng kết quả cuối cùng sẽ tràn trừ khi bạn gọi <|trên một bigint . Thật không may, showsẽ tiền tố từng mảng với BigInttrong trường hợp này. Với chi phí thêm bốn byte, chúng ta có thể tạo đầu ra được phân tách bằng khoảng trắng cho tất cả các loại số.

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Chúng tôi xác định toán tử nhị phân <|cho các mục đích ra. Nó không được xác định trong các phiên bản gần đây của Julia, nhưng vẫn được trình phân tích cú pháp công nhận. Mặc dù \(không được xác định rõ ràng cho số nguyên) ngắn hơn một byte, nhưng mức độ ưu tiên cao của nó sẽ yêu cầu thay thế a+b<|a-bbằng (a+b)\(a-b)(+3 byte) hoặc \(a+b,a-b)(+2 byte).

Khi a<|bđược thực thi, nó bắt đầu bằng cách gọi showđể in [ab] sang STDOUT. Sau đó, a+b<|a-bgọi đệ quy <|trên tổng hoặc chênh lệch.

Vì đệ quy là (được cho là) ​​vô hạn, nên việc so sánh <không bao giờ được thực hiện; mục đích duy nhất của nó là xâu chuỗi hai phần của mã. Điều này tiết kiệm hai byte trên thay thế đơn giản hơn ([a b]|>show;a+b<|a-b).

Perl 6 , 23 byte (vô hạn)

Chỉnh sửa: nhờ JoKing, phiên bản trình tự hiện là ngắn nhất (cũng bị xóa .saytheo mỗi lần làm rõ từ OP:

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

TIO: InfiniteSeq

Câu trả lời chức năng cũ

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

TIO: InfiniteFunc

Lưu ý rằng Perl 6 không có giới hạn đệ quy mỗi lần, nó hoàn toàn dựa trên bộ nhớ khả dụng, do đó, điều này sẽ đạt tới hàng triệu trước khi ném bom.

Yếu tố, 62 byte

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

recursivehoặc nếu không thì callstack hết quá nhanh.

Ruby, 25 byte

Dựa trên giải pháp Python của xnor . Có lẽ tôi sẽ tạo một máy phát điện trong câu trả lời khác, nhưng điều này sẽ in a, sau đób , sau đó là mới a, sau đó là bquảng cáo mới .

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

Python 3, 42 byte

Tôi muốn viết một trình tạo cho chức năng này, và vì vậy tôi đã làm.

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

Trong Python 3, chuỗi được tạo theo cách này:

>>> 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 thường gặp, 57

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

Sử dụng psetf, điều này ảnh hưởng đến các giá trị đến các biến song song và loopcú pháp đơn giản .

bash + GNU coreutils, 75 byte

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

Cầu nguyện:

./codegolf.sh 2 10 5

CP / M 8080, 47 byte

z80 mnemonics nhưng 8080 không có gì, nguồn nhận xét một khi tôi quyết định đếm đầu ra thay vì đầu vào nhưng tên hàm terse được giữ lại, được lắp ráp bằng tay để tha thứ cho 'xx' nơi tôi biết số byte nhưng không hoạt động các địa chỉ đầu ra hoặc offset:

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

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

Chức năng tạo ra một chuỗi lười biếng vô hạn.

Perl 5, 40 byte

yêu cầu -E(miễn phí)

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

hoặc (cùng chiều dài)

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

(Tôi đã vượt qua cái thứ hai vì nó sẽ có lỗi làm tròn cho một số lần lặp.)

Đầu mũ.

Nhưng tôi nghi ngờ phải có một giải pháp Perl 5 ngắn hơn.

TRẢ LẠI , 21 byte

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

Try it here.

Toán tử đệ quy-lambda. Sử dụng:

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

Giải trình

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

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

Gọi với a, b, ntrên stack, nơi nlà số lượt hoặc một giá trị âm cho đầu ra vô hạn. Đầu ra avà bcách nhau bởi một khoảng trắng.

Như một lời giải thích, đây là cách ngăn xếp phát triển trong thời gian chạy:

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

Bạn có thể thử nó trên trình thông dịch trực tuyến với số lượt quay tích cực nhưng bạn sẽ cần sử dụng trình thông dịch python chính thức để kiểm tra chế độ vô hạn.

$ 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 Guacamole , 17 16 byte

(không cạnh tranh, sử dụng các tính năng muộn hơn so với thử thách)

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

Điều này rất khó thực hiện, do lỗi phía máy khách. Nhưng tôi đã nhận nó!

Hướng dẫn:

^^                # 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.

Nghiêm túc, 12 byte

,,1WX■@│+)-1

Đầu ra một luồng vô hạn, định dạng là b(n) a(n), một cặp đầu ra trên mỗi dòng.

Không có liên kết trực tuyến vì TryItOnline không hoạt động tốt với các vòng lặp vô hạn.

Giải trình:

,,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 byte

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

Chỉ tạo ra các giá trị k đầu tiên cho chuỗi dựa trên các hạt đã cho.

Đã lưu 4 byte bằng thủ thuật (hoặc đường cú pháp) được hiển thị bởi @randomra trong bình luận này .

Sử dụng

   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 byte

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

Nguồn đầy đủ, bao gồm cả trường hợp thử nghiệm:

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

Kiểu dữ liệu BigInteger được sử dụng để các số không tràn và trở thành 0. Tuy nhiên, vì đây là một giải pháp đệ quy, hãy mong đợi một tràn ngăn xếp.