Nếu chúng ta viết một chuỗi các con số như các hệ số của một chuỗi lũy thừa, sau đó rằng chuỗi lũy thừa được gọi là (bình thường) chức năng tạo ra (hoặc GF) của chuỗi đó. Đó là, nếu đối với một số chức năng F(x)và chuỗi số nguyên a(n)chúng ta có:

a(0) + a(1)x + a(2)x^2 + a(3)x^3 + a(4)x^4 + ... = F(x)

Sau đó F(x)là chức năng tạo của a. Ví dụ, loạt hình học cho chúng ta biết rằng:

1 + x + x^2 + x^3 + x^4 + ... = 1/(1-x)

Vì vậy, chức năng tạo ra 1, 1, 1, ...là 1/(1-x). Nếu chúng ta phân biệt cả hai mặt của phương trình trên và nhân với xchúng ta sẽ có được đẳng thức sau:

x + 2x^2 + 3x^3 + 4x^4 + ... = x/(1-x)^2

Vì vậy, chức năng tạo ra 1, 2, 3, ...là x/(1-x)^2. Tạo các hàm là một công cụ rất mạnh và bạn có thể làm nhiều việc hữu ích với chúng. Một giới thiệu ngắn có thể được tìm thấy ở đây , nhưng để giải thích thực sự kỹ lưỡng có chức năng tạo sách tuyệt vời.

Trong thử thách này, bạn sẽ lấy một hàm hữu tỷ (thương số của hai đa thức có hệ số nguyên) làm đầu vào dưới dạng hai mảng hệ số nguyên, đầu tiên là tử số sau đó là mẫu số. Ví dụ, hàm f(x) = x / (1 - x - x^2)sẽ được mã hóa như [0, 1], [1, -1, -1]trong đầu vào.

Với đầu vào này, chương trình của bạn phải in vô hạn các hệ số của chuỗi công suất bằng với hàm tạo, mỗi dòng trên một dòng, bắt đầu từ hệ số x, sau đó x^2, v.v.

Ví dụ:

[1], [1, -1] -> 1, 1, 1, 1, 1, 1, 1, ...
[1], [2, -2] -> 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, ...
[0, 1], [1, -2, 1] -> 1, 2, 3, 4, 5, 6, 7, 8, ...
[0, 1], [1, -1, -1] -> 1, 1, 2, 3, 5, 8, 13, 21, 34, ...
[1], [1, -2] -> 1, 2, 4, 8, 16, 32, 64, 128, ...
[0, 1, 1], [1, -3, 3, -1] -> 1, 4, 9, 16, 25, 36, ...

Haskell , 63 byte

z=0:z
(a:b)%y@(c:d)=a/c:zipWith(-)(b++z)(map(a/c*)d++z)%y
_%_=z

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

Xác định một toán tử %trả về một danh sách các hệ số lười biếng vô hạn. Danh sách này được lập chỉ mục bằng không, do đó, hệ số không đổi được bao gồm.

Toán học, 64 83 90 byte

Do[Echo@Limit[D[#/#2/i!&@@Fold[x#+#2&]/@#,{x,i}],x->0],{i,∞}‌​]&

Cảm ơn @ngenisis và @Jenny_mathy!

Lấy đầu vào là hai danh sách.

Cần Alt+.chấm dứt thực hiện để xem kết quả. Frontend có thể sụp đổ do đầu ra nhanh chóng.

Phiên bản 83 byte (@Jenny_mathy):

i=1;v=Tr[#*x^Range@Length@#]&;While[1<2,Echo@Limit[D[v@#/v@#2/i!,{x,i}],x->0];i++]&

CJam (22 byte)

{\{(W$(@\/_pW*f*.+1}g}

Bản demo trực tuyến . Lưu ý rằng như nhiều câu trả lời hiện có, điều này bao gồm hệ số 0 trong đầu ra.

Mổ xẻ

{           e# Define a block which takes numerator N and denominator D as arguments
  \         e# Flip to put D at the bottom, since that won't change
  {         e# Infinite loop:
    (       e#   Pop the first element of (the modified) N
    W$(     e#   Copy D and pop its first element
            e#   Stack: D N[1:] N[0] D[1:] D[0]
    @\/     e#   Bring N[0] to top, flip, divide
            e#   Stack: D N[1:] D[1:] N[0]/D[0]
    _p      e#   Print a copy
    W*f*.+  e#   Multiply by -1, multiply all, pointwise add
            e#   Stack: D N[1:]-(N[0]/D[0])*D[1:]
  1}g
}

Toán học, 86 79 byte

f=x^Range@Length@#.#&;For[n=1,8>3,Print@SeriesCoefficient[f@#/f@#2,{x,0,n++}]]&

Lấy đầu vào là hai danh sách riêng biệt (hệ số tử số, hệ số mẫu số). Nếu đầu vào có thể được lấy trực tiếp dưới dạng một phần của đa thức chứ không phải là danh sách các hệ số, điều này có thể được rút ngắn đáng kể.

Dường như Docó thể làm việc với giới hạn vô hạn trong v11. Tôi không thể kiểm tra điều này cục bộ, nhưng, nếu đây là trường hợp, thì giải pháp này có thể được rút ngắn xuống còn 75 byte :

f=x^Range@Length@#.#&;Do[Print@SeriesCoefficient[f@#/f@#2,{x,0,n}],{n,∞}]&

Bình thường , 23 byte

JE#
KchQhJ=t-M.t,Q*LKJ0

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

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

                       Q = eval(input())
JE                     J = eval(input())
  #                    infinite loop:
 chQhJ                   Q[0]/J[0]
K                        assign that to K (and print it, because of the preceding newline)
              *LKJ       K times every element of J
            ,Q           [Q, that]
          .t      0      transpose, padding with 0s
        -M               subtract each pair
       t                 remove the first element
      =                  assign that back to Q

Pari / GP , 66 byte

p->q->for(i=0,oo,print(Pol(Polrev(p)/(Polrev(q)+O(x*x^i)))\x^i%x))

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