Bir güç serisinin katsayıları olarak bir sayı dizisi yazarsak, o güç serisine o dizinin (sıradan) üretici fonksiyonu (veya Gf) denir . Yani, eğer bazı fonksiyonlar F(x)ve tamsayılar dizisi a(n)için:

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

O F(x)halde üreten işlevidir a. Örneğin, geometrik seri bize şunu söyler:

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

Ait oluşturma işlevini Yani 1, 1, 1, ...DİR 1/(1-x). Yukarıdaki denklemin her iki tarafını da ayırt edersek ve çarparsak x, aşağıdaki eşitliği elde ederiz:

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

Ait oluşturma işlevini Yani 1, 2, 3, ...DİR x/(1-x)^2. Üreten işlevler çok güçlü bir araçtır ve bunlarla birçok yararlı şey yapabilirsiniz. Kısa bir giriş burada bulunabilir , ancak gerçekten kapsamlı bir açıklama için şaşırtıcı kitap üretme işlevi vardır.

Bu zorlukta rasyonel bir işlevi (tamsayı katsayıları olan iki polinomun bölümü), tamsayı katsayılarının iki dizisi olarak girdi olarak alırsınız ; önce pay sonra payda. Örneğin, işlev girişte f(x) = x / (1 - x - x^2)olduğu gibi kodlanacaktır [0, 1], [1, -1, -1].

Bu giriş Verilen sonsuz katsayısı başlayan her satırda bir, üreten fonksiyonu eşittir Kuvvet dizisinin katsayılarını koyma zorunluluğu program xdaha sonra, x^2vb

Örnekler:

[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 bayt

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

Çevrimiçi deneyin!

%Sonsuz tembel katsayılar listesi döndüren bir operatörü tanımlar . Liste sıfır indekslidir, bu nedenle sabit katsayı dahil edilir.

Mathematica, 64 83 90 bayt

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

@Ngenisis ve @Jenny_mathy sayesinde!

Girdiyi iki liste olarak alın.

Sonucu Alt+.görmek için yürütmeyi sonlandırmanız gerekir. Ön çıkış hızlı çıktı nedeniyle çökebilir.

83 bayt sürümü (@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 bayt)

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

Çevrimiçi demo . Mevcut cevapların çoğunda, bunun çıktıdaki 0. katsayıyı içerdiğini unutmayın.

teşrih

{           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
}

Mathematica, 86 79 bayt

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

Girişi iki ayrı liste olarak alır (pay katsayıları, payda katsayıları). Girdi, katsayı listeleri yerine doğrudan polinomların bir kısmı olarak alınabiliyorsa, bu önemli ölçüde kısaltılabilir.

Görünüşe göre Dov11'de sonsuz sınırlarla çalışabilir. Bunu yerel olarak test edemiyorum, ancak eğer durum buysa, bu çözüm 75 bayta kısaltılabilir :

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

Pyth , 23 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

                       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 bayt

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

Çevrimiçi deneyin!