Transformada de Laplace polinomial
Este é um relançamento deste desafio, com a intenção de renová-lo para formatos de I / O mais flexíveis e regras atualizadas
Você deve escrever um programa que recebe um polinômio inteiro em \$t\$como entrada e produz a transformada de Laplace deste polinômio. Algumas definições e propriedades:
- A transformada de Laplace de uma determinada função \$f(t)\$ é
$$\mathcal{L}\{f(t)\} = F(s) = \int_0^\infty f(t)e^{-st}dt$$
- A transformação de Laplace de \$f(t) = t^n, \, n = 0, 1, 2, ...\$ é
$$\mathcal{L}\{t^n\} = \frac{n!}{s^{n+1}}$$
- As transformações de Laplace são distribuídas sobre a adição:
$$\mathcal{L}\{f(t)+g(t)\} = \mathcal{L}\{f(t)\} + \mathcal{L}\{g(t)\}$$
- A transformada de Laplace de uma constante multiplicada por uma função é igual à constante multiplicada pela transformação:
$$\mathcal{L}\{af(t)\} = a\mathcal{L}\{f(t)\}$$
- Um polinômio inteiro é um polinômio onde cada termo tem um coeficiente inteiro e uma ordem não negativa
Um exemplo trabalhado:
$$\begin{align} \mathcal{L}\{3t^4+2t^2+t-4\} & = \mathcal{L}\{3t^4\}+\mathcal{L}\{2t^2\}+\mathcal{L}\{t\}-\mathcal{L}\{4\} \\ & = 3\mathcal{L}\{t^4\}+2\mathcal{L}\{t^2\}+\mathcal{L}\{t\}-4\mathcal{L}\{1\} \\ & = 3\left(\frac{4!}{s^5}\right)+2\left(\frac{2!}{s^3}\right)+\left(\frac{1!}{s^2}\right)-4\left(\frac{0!}{s}\right) \\ & = \frac{72}{s^5}+\frac{4}{s^3}+\frac{1}{s^2}-\frac{4}{s} \end{align}$$
Você pode obter a entrada em uma representação padrão de um polinômio. Alguns exemplos (para \$3x^4+2x^2+x-4\$ como exemplo) são:
- Uma lista de coeficientes.
[-4, 1, 2, 0, 3]
ou[3, 0, 2, 1, -4]
- Pares de coeficientes e potências.
[[3, 4], [2, 2], [1, 1], [-4, 0]]
e vários pedidos diferentes - Uma string, usando qualquer variável que você quiser.
3x^4+2x^2+x-4
Da mesma forma, como a saída será um polinômio com ordens negativas, você pode produzir em formatos semelhantes, como (usando \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):
- Uma lista de coeficientes.
[72, 0, 4, 1, -4]
ou[-4, 1, 4, 0, 72]
- Pares de coeficientes e potências.
[[72, -5], [4, -3], [1, -2], [-4, -1]]
e várias ordens diferentes (ou as versões positivas dos poderes) - Uma string, usando qualquer variável que você quiser.
72s^-5+4s^-3+s^-2-4s^-1
Se você tiver um método de E / S alternativo sobre o qual não tem certeza, comente abaixo para perguntar.
Este é o código-golfe, então o código mais curto em bytes vence.
Respostas
Haskell , 25 bytes
zipWith(*)$scanl(*)1[1..]
Experimente online!
Muito simples: Gera a lista de fatoriais [1,1,2,6,...]
com um e scanl
, a seguir, zipWith(*)
multiplica cada elemento da entrada pelo valor correspondente.
32 bytes
foldr(\(i,x)r->x:map((i+1)*)r)[]
Experimente online!
Uma solução bastante baseada em dobradura. Aceita entradas como (exponent, coefficient)
pares.
transmitir , 15 bytes
v"*<
0+1"
1{*}
Experimente online!

As duas colunas da esquerda copiam "
1, 2, 3,… para o topo *
. O valor no canto superior direito é multiplicado por isso a cada volta, então obtemos (começando com um 1 extra = 0!) 1 !, 2 !, 3 !, ... copiado para o fundo *
. {
lê a entrada, multiplica-a com os fatoriais e os produz }
.
Gelatina , 4 bytes
J’!×
Aceita a entrada como lista de coeficientes.
Explicação
J’!×
J | Returns an array of elements from 1 to length of input array
’ | Subtracts 1 from each
! | Factorial each
×| Multiply each item in the original array by the created array
Experimente online!
APL (Dyalog Unicode) , 3 bytes
×∘!
Experimente online!
Leva o I / O liberal ao extremo: leva o polinômio \$ 3x^4 + 2x^2+x-4 \$como dois argumentos, os coeficientes à esquerda e as potências à direita em ordem decrescente e incluindo termos zero, como em 3 0 2 1 ¯4 f 4 3 2 1 0
. Retorna o polinômio como um vetor de coeficientes.
PowerShell , 28 bytes
Insira como uma lista de coeficientes
$p++;$args|%{$p*$_;$p*=++$i}
Experimente online!
APL (Dyalog Unicode) , 7 bytes
⊢×!∘⍳∘≢
Experimente online!
Usos ⎕IO←0
(indexação 0)
Insira como uma lista de coeficientes.
Linguagem Wolfram (Mathematica) , 10 bytes
#2!#&@@@#&
Experimente online!
Insira uma lista de pares de coeficiente / potência, incluindo coeficientes zero, classificados por potência, e produza uma lista de coeficientes correspondentes.
O integrado é maior: 23 bytes
LaplaceTransform[#,t,]&
Experimente online!
Insira um polinômio em termos de t
e produza um em termos de Null
.
Retina , 30 bytes
L$`.+ $&$:&* +`\d+_ $.(*$(_$%'
Experimente online! I / O é uma lista delimitada por nova linha de coeficientes do grau mais baixo ao mais alto. Explicação:
L$`.+ $&$:&*
Para cada coeficiente, acrescente um número de sublinhados igual ao seu grau.
+`\d+_
$.(*$(_$%'
Até que nenhum sublinhado permaneça, multiplique cada coeficiente pelo número de sublinhados seguintes, excluindo um no processo.
Scala 3, 52 48 bytes
p=>p.indices.scanLeft(1)(_*_.+(1))zip p map(_*_)
Experimente online!
Entrada e saída como uma lista de inteiros, do grau mais baixo ao mais alto.
p.indices
nos dá um intervalo de 0 a p.size - 1
. A varredura para a esquerda com a multiplicação fornece o fatorial em cada índice, mas como o primeiro elemento é 0, precisamos adicionar 1 (portanto _.+(1)
). Em seguida, todos os fatoriais são compactados com os coeficientes e multiplicados juntos.
Python 2 , 39 bytes
p=i=1
while 1:print p*input();p*=i;i+=1
Experimente online!
A entrada e a saída são coeficientes, um por linha, começando com o menor grau (mais próximo de zero).
Ficar em (coefficient, exponent)
pares acaba sendo um pouco mais longo.
p=1
while 1:x,i=input();print p*x;p*=i+1
Experimente online!
Raku , 15 bytes
*Z*1,|[\*] 1..*
Experimente online!
[\*] 1..*
é a sequência infinita de fatoriais começando com 1!
. Um adicional 1
(para 0!
) é colado na frente, então tudo é compactado com multiplicação ( Z*
) com a única sequência de entrada *
.
Japt -m , 3 bytes
*Vl
Experimente aqui
R , 34 28 25 bytes
(x=scan())*gamma(seq(!x))
Experimente online!
Bem direto.
R não tem uma função fatorial abreviada, mas tem gamma
.
Gera sequência x
usando truque de @Giuseppe .
JavaScript (ES6), 31 29 bytes
I / O: listas de coeficientes, do menor ao maior grau.
a=>a.map((v,i)=>v*=p=i?p*i:1)
Experimente online!
Comentado
a => // a[] = polynomial coefficients
a.map((v, i) => // for each coefficient v at position i in a[]:
v *= // multiply v by:
p = // the updated factorial p, which is:
i ? // if i > 0:
p * i // multiplied by i
: // else:
1 // initialized to 1
) // end of map()
SageMath , 27 23 bytes
Economizei 4 bytes graças ao ovs !!!
lambda f:f.laplace(x,x)
Experimente online!
Desempenha uma função de \$x\$como entrada e retorna a transformada de Laplace como uma função de \$x\$.
Carvão , 12 bytes
IEA×ιΠ⊞Oυ∨κ¹
Experimente online! O link é para a versão detalhada do código. I / O é uma lista de coeficientes do grau mais baixo ao mais alto. Explicação:
A Input array
E Map over elements
ι Current element
× Multiplied by
Π Product of
υ Predefined empty list
⊞O After pushing
∨ Logical Or of
κ Current index
¹ Literal 1
I Cast to string
Implicitly print
05AB1E , 4 bytes
εN!*
Experimente online.
Ou alternativamente:
ā<!*
Experimente online.
Ambos recebem uma lista de coeficientes como entrada.
Explicação:
ε # Map over each value of the (implicit) input-list
N # Push the 0-based map-index
! # Pop and take it's faculty
* # Multiply it by the current value
# (after the map, the resulting list is output implicitly)
ā # Push a list in the range [1,length] based on the (implicit) input-list
< # Decrease each by 1 to make the range [0,length)
! # Take the faculty of each
* # And multiply it to the values at the same positions in the (implicit) input-list
# (after which the result is output implicitly)