Se escrevermos uma sequência de números como coeficientes de uma série de potências, essa série de potências será chamada de função geradora (comum) (ou Gf) dessa sequência. Ou seja, se, para alguma função F(x)e série de números inteiros a(n), temos:

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

Então F(x)é a função geradora de a. Por exemplo, a série geométrica nos diz que:

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

Portanto, a função geradora de 1, 1, 1, ...é 1/(1-x). Se diferenciarmos ambos os lados da equação acima e multiplicarmos x, obtemos a seguinte igualdade:

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

Portanto, a função geradora de 1, 2, 3, ...é x/(1-x)^2. A geração de funções é uma ferramenta muito poderosa e você pode fazer muitas coisas úteis com elas. Uma breve introdução pode ser encontrada aqui , mas para uma explicação realmente completa, há o incrível livro que gera a funcionalidade.

Nesse desafio, você terá uma função racional (o quociente de dois polinômios com coeficientes inteiros) como entrada como duas matrizes de coeficientes inteiros, primeiro o numerador e o denominador. Por exemplo, a função f(x) = x / (1 - x - x^2)será codificada como [0, 1], [1, -1, -1]na entrada.

Dada essa entrada, seu programa deve imprimir infinitamente os coeficientes da série de potências que são iguais à função geradora, um por linha, começando no coeficiente de x, então x^2, etc.

Exemplos:

[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

Experimente online!

Define um operador %retornando uma lista lenta infinita de coeficientes. A lista é indexada a zero, portanto, o coeficiente constante é incluído.

Mathematica, 64 83 90 bytes

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

Obrigado a @ngenisis e @Jenny_mathy!

Tome entrada como duas listas.

Precisa Alt+.finalizar a execução para ver o resultado. O front-end pode falhar devido à saída rápida.

Versão de 83 bytes (@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}

Demonstração online . Observe que, como muitas das respostas existentes, isso inclui o coeficiente 0 na saída.

Dissecação

{           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++}]]&

Recebe entrada como duas listas separadas (coeficientes do numerador, coeficientes do denominador). Se a entrada puder ser tomada diretamente como uma fração de polinômios, e não como listas de coeficientes, isso poderá ser reduzido significativamente.

Parece que Dopode funcionar com limites infinitos na v11. Não posso testar isso localmente, mas, se for esse o caso, essa solução pode ser reduzida para 75 bytes :

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

Pitão , 23 bytes

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

Experimente online!

Como funciona

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

Experimente online!