Urutan plus-minus

Urutan plus-minus adalah yang dimulai dengan dua biji, a(0)dan b(0). Setiap iterasi dari urutan ini adalah penambahan dan pengurangan dari dua anggota urutan sebelumnya. Yaitu, a(N) = a(N-1) + b(N-1)dan b(N) = a(N-1) - b(N-1).

Tujuan Menghasilkan urutan plus-minus, dalam infinitude atau Klangkah pertama yang diberikan K. Anda dapat melakukan ini menggunakan program keluaran tanpa batas, generator, atau fungsi / program yang memberikan Klangkah pertama . Urutan output tidak masalah, asalkan konsisten. (Yaitu, b(K) a(K)atau a(K) b(K), dengan beberapa pemisah non-numerik di antara keduanya.) Output harus dimulai dengan input.

Uji kasus

Untuk input 10 2(dari a(0) b(0), ini adalah output yang mungkin untuk pendekatan K pertama (atau subbagian dari pendekatan tak terbatas):

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

Untuk input 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

Ini adalah kode-golf , jadi program terpendek dalam byte menang.

Jelly , 5 byte

ṄI;Sß

Ini adalah pendekatan rekursif. Karena optimasi panggilan ekor, satu-satunya batasan adalah kemampuan untuk memasukkan kedua bilangan bulat ke dalam memori. Output adalah satu daftar per baris.

Cobalah online!

Bagaimana itu bekerja

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

Mencetak selamanya. Ya, pada akhirnya Anda melebihi batas rekursi, tetapi itu adalah batasan sistem.

MATL , 10 byte

`tDtswPdhT

Versi ini akan menampilkan elemen dalam jumlah tak terbatas dalam urutan plus-minus.

Cobalah secara Online! (hentikan setelah berjalan karena infinite loop)

Penjelasan

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

Menghasilkan urutan angka yang tak terbatas. Contoh penggunaan:

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 byte

Terima kasih kepada @isaacg untuk 1 byte.

#=Q,s
Q-F

Mencetak urutan pasangan tanpa batas.

$ 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

Menggunakan metode k pertama . Masukkan yang berikut ini untuk:

k
[a, b]

Kode:

FD=OsƂ

Penjelasan:

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]

Menggunakan pengkodean CP-1252 . Cobalah online!

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

Bisa juga disebut dalam bentuk

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

APL, 37 karakter

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

Dapat digunakan sebagai

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

atau

      {⍺←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‼+-∟

Cobalah online!

Mengambil input dalam urutan terbalik, tetapi itu hanya karena itulah cara mereka didorong ke stack. Kalau tidak, itu akan menjadi 1 byte lebih lama. 2-3 byte berasal dari output. Tanpa perlu benar-benar mencetak satu pasang per baris, program bisa æ`‼+-∟(mengisi tumpukan dengan elemen-elemen urutan tanpa batas waktu), atau É‼+-∟(mencetak semua elemen urutan kecuali yang pertama untuk debug, selama -dflag aktif) .

Penjelasan

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

Mencetak urutan yang benar untuk selamanya. Saya telah dapat membiarkan ini berlangsung selama sekitar 30 menit tanpa ada kesalahan yang diangkat, dan program telah mencetak 2301 digit untuk angka pertama, dan 1.150 digit untuk yang kedua! Berdasarkan hal ini, saya menduga bahwa, dengan menyediakan perangkat keras yang cukup untuk dijalankan, ini dapat berlangsung selama WAY lebih lama dan mencetak WAY lebih banyak digit, dan secara teoritis juga tidak memiliki batas rekursi, milik whileloop!

Reng v.3.2, 9 byte (menjawab sendiri, tidak bersaing)

ii¤ææö±2.

Mengambil dua input ( a b) dan output b a. Coba di sini!

imengambil input dua kali, ¤menduplikasi tumpukan, æmencetak angka dan spasi (dan melakukannya dua kali, ada dua), ömencetak baris baru, ±melakukan apa yang Anda harapkan, dan 2.melompati dua karakter berikutnya, membungkus input yang mendapatkan karakter.

Python 2.7, 56 , 42 byte:

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

Simpul sederhana yang mencetak selamanya (ish).

Batch, 54 byte

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

Perhatikan bahwa CMD.EXE terbatas pada bilangan bulat bertanda 32-bit, sehingga akan dengan cepat meluap dan mencetak sampah dan pesan kesalahan.

Julia, 25 byte

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

Penyalahgunaan sintaksis maksimum. Julia aneh . Cobalah online!

Versi alternatif, 29 byte

Perhatikan bahwa output akan akhirnya meluap kecuali Anda memanggil <|pada BigInt . Sayangnya, showakan mengawali setiap array dengan BigIntdalam hal ini. Dengan biaya empat byte lagi, kita dapat menghasilkan output yang dipisahkan spasi untuk semua jenis numerik.

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

Cobalah online!

Bagaimana itu bekerja

Kami mendefinisikan operator biner <|untuk tujuan keluar. Ini tidak terdefinisi dalam versi terbaru Julia, tetapi masih diakui sebagai operator oleh parser. Sementara \(tidak didefinisikan secara eksplisit untuk bilangan bulat) lebih pendek satu byte, prioritas tinggi akan membutuhkan penggantian a+b<|a-bdengan (a+b)\(a-b)(+3 byte) atau \(a+b,a-b)(+2 byte).

Ketika a<|bdijalankan, itu dimulai dengan memanggil showuntuk mencetak [ab] ke STDOUT. Kemudian, a+b<|a-bsecara rekursif memanggil <|jumlah atau perbedaannya.

Karena rekursi (seharusnya) tak terbatas, perbandingan <tidak pernah dilakukan; satu-satunya tujuan adalah merantai dua bagian kode. Ini menghemat dua byte dari alternatif yang lebih mudah ([a b]|>show;a+b<|a-b).

Perl 6 , 23 byte (tak terbatas)

Sunting: terima kasih kepada JoKing, versi urutan sekarang adalah yang terpendek (juga dihapus .sayper klarifikasi dari OP:

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

TIO: InfiniteSeq

Jawaban fungsional lama

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

TIO: InfiniteFunc

Perhatikan bahwa Perl 6 tidak memiliki batas rekursi per se, itu murni berdasarkan memori yang tersedia, jadi ini akan mencapai jutaan sebelum pemboman.

Faktor, 62 byte

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

recursive, atau kalau tidak, callstack terlalu cepat

Ruby, 25 byte

Berdasarkan solusi Python xnor . Mungkin saya akan membuat generator di jawaban lain, tetapi ini akan mencetak a, lalu b, lalu yang baru a, lalu yang baru b, ad infinitum.

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

Python 3, 42 byte

Saya ingin menulis generator untuk fungsi ini, dan saya melakukannya.

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

Dalam Python 3, urutan dihasilkan dengan cara ini:

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

Common Lisp, 57

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

Penggunaan psetf, yang mempengaruhi nilai variabel secara paralel, dan loopsintaksis sederhana .

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

Doa:

./codegolf.sh 2 10 5

CP / M 8080, 47 byte

z80 mnemonics tapi tidak ada yang tidak dimiliki 8080, sumber berkomentar begitu saya memutuskan untuk menghitung output daripada input tetapi nama fungsi singkat dipertahankan, tangan dirakit jadi maafkan 'xx's di mana saya tahu jumlah byte tetapi belum berhasil alamat keluaran atau 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])

Fungsi yang menghasilkan urutan malas yang tak terbatas.

Perl 5, 40 byte

membutuhkan -E(gratis)

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

atau (panjang yang sama)

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

(Saya menemukan yang terakhir karena harus memiliki kesalahan pembulatan untuk beberapa iterasi.)

Topi-tip

Tapi saya curiga harus ada solusi Perl 5 yang lebih pendek.

KEMBALI , 21 byte

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

Try it here.

Operator rekursif-lambda. Pemakaian:

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

Penjelasan

[                 ]=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:@+}-$

Panggil dengan a, b, ndi stack, di mana nadalah jumlah putaran atau nilai negatif untuk output yang tak terbatas. Keluaran adan bdipisahkan oleh spasi.

Sebagai penjelasan, berikut adalah bagaimana tumpukan berevolusi selama runtime:

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

Anda dapat mencobanya pada juru bahasa online dengan jumlah belokan positif tetapi Anda harus menggunakan juru bahasa python resmi untuk menguji mode tak terbatas.

$ 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

(non-bersaing, menggunakan fitur setelah tantangan)

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

Ini sulit dibuat, karena kesalahan sisi klien. Tapi saya mengerti!

Panduan:

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

Serius, 12 byte

,,1WX■@│+)-1

Menghasilkan aliran tanpa batas, formatnya b(n) a(n), sepasang keluaran per baris.

Tidak ada tautan online karena TryItOnline tidak melakukannya dengan baik dengan loop tak terbatas

Penjelasan:

,,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&(]+/,-/)~<

Hanya menghasilkan nilai k pertama untuk urutan berdasarkan pada biji yang diberikan.

Disimpan 4 byte menggunakan trik (atau gula sintaksis) yang ditunjukkan oleh @randomra dalam komentar ini .

Pemakaian

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

Sumber lengkap, termasuk test case:

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

Tipe data BigInteger digunakan sehingga angka tidak meluap dan menjadi 0. Namun, karena ini adalah solusi rekursif, mengharapkan stack overflow.