Wenn wir eine Folge von Zahlen als Koeffizienten einer Potenzreihe schreiben, dann wird diese Potenzreihe die (gewöhnliche) Erzeugungsfunktion (oder Gf) dieser Folge genannt. Das heißt, wenn für einige Funktionen F(x)und ganze a(n)Zahlenreihen gilt:

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

Dann F(x)ist die erzeugende Funktion von a. Zum Beispiel sagt uns die geometrische Reihe , dass:

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

Die erzeugende Funktion von 1, 1, 1, ...ist also 1/(1-x). Wenn wir beide Seiten der obigen Gleichung unterscheiden und mit multiplizieren, erhalten xwir die folgende Gleichheit:

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

Die erzeugende Funktion von 1, 2, 3, ...ist also x/(1-x)^2. Das Generieren von Funktionen ist ein sehr mächtiges Werkzeug, mit dem Sie viele nützliche Dinge tun können. Eine kurze Einführung kann gefunden werden hier , aber für eine wirklich gründliche Erklärung gibt es die erstaunliche Buch generatingfunctionology.

In dieser Challenge nehmen Sie eine rationale Funktion (den Quotienten aus zwei Polynomen mit ganzzahligen Koeffizienten) als Eingabe als zwei Arrays von ganzzahligen Koeffizienten, zuerst den Zähler, dann den Nenner. Zum Beispiel wird die Funktion f(x) = x / (1 - x - x^2)wie [0, 1], [1, -1, -1]in der Eingabe codiert .

Anhand dieser Eingabe muss Ihr Programm die Koeffizienten der Potenzreihe, die der Erzeugungsfunktion entspricht, unendlich ausgeben, und zwar eine pro Zeile, beginnend mit dem Koeffizienten von x, dann x^2usw.

Beispiele:

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

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

Probieren Sie es online!

Definiert einen Operator %, der eine unendliche Liste fauler Koeffizienten zurückgibt. Die Liste ist nullindexiert, sodass der konstante Koeffizient enthalten ist.

Mathematica, 64 83 90 Bytes

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

Vielen Dank an @ngenisis und @Jenny_mathy!

Nimm die Eingabe als zwei Listen.

Müssen Sie Alt+.die Ausführung beenden, um das Ergebnis zu sehen. Frontend kann aufgrund schneller Ausgabe abstürzen.

83-Byte-Version (@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 Bytes)

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

Online-Demo . Beachten Sie, dass wie viele der vorhandenen Antworten auch der 0. Koeffizient in der Ausgabe enthalten ist.

Präparation

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

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

Nimmt die Eingabe als zwei separate Listen (Zählerkoeffizienten, Nennerkoeffizienten) vor. Wenn die Eingabe direkt als Bruchteil von Polynomen und nicht als Liste von Koeffizienten verwendet werden kann, kann dies erheblich verkürzt werden.

Es scheint, dass Doin v11 mit unendlichen Grenzen gearbeitet werden kann. Ich kann das lokal nicht testen, aber wenn dies der Fall ist, kann diese Lösung auf 75 Byte verkürzt werden :

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

Pyth , 23 Bytes

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

Probieren Sie es online!

Wie es funktioniert

                       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 Bytes

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

Probieren Sie es online!