ลำดับการบวกลบ

ลำดับบวกลบเป็นหนึ่งที่เริ่มต้นด้วยสองเมล็ดและa(0) b(0)การวนซ้ำของลำดับนี้แต่ละครั้งเป็นการเพิ่มและลบสมาชิกสองคนก่อนหน้าของลำดับ นั่นคือและa(N) = a(N-1) + b(N-1)b(N) = a(N-1) - b(N-1)

วัตถุประสงค์ Produce ลำดับบวกลบในไม่มีที่สิ้นสุดหรือแรกขั้นตอนที่กำหนด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 ไบต์

ใช้ครั้งแรก 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)

Python 3.5, 55 43 ไบต์:

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

พิมพ์ลำดับที่ถูกต้องดูเหมือนจะตลอดไป ฉันสามารถปล่อยให้เรื่องนี้ดำเนินต่อไปได้ประมาณ 30 นาทีโดยไม่มีข้อผิดพลาดใด ๆ ขึ้นและโปรแกรมก็พิมพ์ตัวเลข 2301 หลักสำหรับหมายเลขแรกและ 1,150 หลักในวินาที! จากนี้ผมคาดเดาว่าถูกให้ฮาร์ดแวร์เพียงพอที่จะทำงานบนนี้สามารถไปหาวิธีอีกต่อไปและพิมพ์ตัวเลข WAY มากขึ้นและนอกจากนี้ยังมีในทางทฤษฎีไม่ จำกัด recursion มารยาทของ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

วนรอบง่าย ๆ ที่พิมพ์ตลอดไป (ish)

แบตช์ 54 ไบต์

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

โปรดทราบว่า CMD.EXE ถูก จำกัด ไว้ที่จำนวนเต็ม 32 บิตที่ได้รับการรับรองดังนั้นมันจะล้นอย่างรวดเร็วและพิมพ์ขยะและข้อความแสดงข้อผิดพลาด

Julia, 25 ไบต์

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

การละเมิดไวยากรณ์สูงสุด จูเลียคือแปลก ลองออนไลน์!

รุ่นสำรอง 29 ไบต์

หมายเหตุว่าการส่งออกจะได้ล้นจนกว่าคุณจะเรียก<|ในbigint น่าเสียดายที่showจะนำหน้าแต่ละอาร์เรย์ด้วยBigIntในกรณีนี้ ด้วยค่าใช้จ่ายอีกสี่ไบต์เราสามารถสร้างเอาต์พุตที่คั่นด้วยช่องว่างสำหรับทุกประเภทตัวเลข

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

ลองออนไลน์!

มันทำงานอย่างไร

เรากำหนดผู้ประกอบการไบนารี<|เพื่อวัตถุประสงค์ มันไม่ได้กำหนดไว้ใน Julia รุ่นล่าสุด แต่ยังคงได้รับการยอมรับว่าเป็นตัวดำเนินการโดย parser ในขณะที่\(ไม่ได้กำหนดอย่างชัดเจนสำหรับจำนวนเต็ม) จะสั้นกว่าหนึ่งไบต์ แต่ลำดับความสำคัญสูงนั้นจะต้องแทนที่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: InfiniteSeq

คำตอบการทำงานเก่า

->\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หรืออื่น callstack หมดเร็วเกินไป

ทับทิมขนาด 25 ไบต์

ขึ้นอยู่กับวิธีการแก้ปัญหาของงูหลาม XNOR บางทีฉันอาจจะสร้างเครื่องกำเนิดไฟฟ้าขึ้นมาในคำตอบอื่น แต่สิ่งนี้จะพิมพ์aจากbนั้นสร้างใหม่aจากนั้นจะเป็นbinfinitum โฆษณาใหม่

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)

เสียงกระเพื่อมสามัญ, 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.

Recursive operator-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 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 ไบต์

(ไม่ใช่การแข่งขันใช้ฟีเจอร์ที่ช้ากว่าความท้าทาย)

^^(: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แรกสำหรับลำดับตามเมล็ดที่กำหนด

บันทึกแล้ว 4 ไบต์โดยใช้ลูกเล่น (หรือน้ำตาลประโยค) ที่แสดงโดย @randomra ในความคิดเห็นนี้

การใช้

   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 อย่างไรก็ตามเนื่องจากเป็นโซลูชันแบบเรียกซ้ำ