Transformada polinomial de Laplace
Esta es una nueva publicación de este desafío, con la intención de renovarlo para formatos de E / S más flexibles y reglas actualizadas
Debes escribir un programa que tome un polinomio entero en \$t\$como entrada y salida la transformada de Laplace de este polinomio. Algunas definiciones y propiedades:
- La transformada de Laplace de una función dada \$f(t)\$ es
$$\mathcal{L}\{f(t)\} = F(s) = \int_0^\infty f(t)e^{-st}dt$$
- La transformada de Laplace de \$f(t) = t^n, \, n = 0, 1, 2, ...\$ es
$$\mathcal{L}\{t^n\} = \frac{n!}{s^{n+1}}$$
- Las transformadas de Laplace distribuyen sobre la suma:
$$\mathcal{L}\{f(t)+g(t)\} = \mathcal{L}\{f(t)\} + \mathcal{L}\{g(t)\}$$
- La transformada de Laplace de una constante multiplicada por una función es igual a la constante multiplicada por la transformada:
$$\mathcal{L}\{af(t)\} = a\mathcal{L}\{f(t)\}$$
- Un polinomio entero es un polinomio donde cada término tiene un coeficiente entero y un orden no negativo
Un ejemplo trabajado:
$$\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}$$
Puede tomar la entrada en una representación estándar de un polinomio. Algunos ejemplos (para \$3x^4+2x^2+x-4\$ como ejemplo) son:
- Una lista de coeficientes.
[-4, 1, 2, 0, 3]
o[3, 0, 2, 1, -4]
- Pares de coeficientes y potencias.
[[3, 4], [2, 2], [1, 1], [-4, 0]]
y varios ordenamientos diferentes - Una cadena, usando cualquier variable que desee.
3x^4+2x^2+x-4
De manera similar, como la salida será un polinomio con órdenes negativos, puede generar en formatos similares, como (usando \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):
- Una lista de coeficientes.
[72, 0, 4, 1, -4]
o[-4, 1, 4, 0, 72]
- Pares de coeficientes y potencias.
[[72, -5], [4, -3], [1, -2], [-4, -1]]
y varios ordenamientos diferentes (o las versiones positivas de los poderes) - Una cadena, usando cualquier variable que desee.
72s^-5+4s^-3+s^-2-4s^-1
Si tiene un método de E / S alternativo del que no está seguro, comente a continuación para preguntar.
Esto es código de golf, por lo que gana el código más corto en bytes.
Respuestas
Haskell , 25 bytes
zipWith(*)$scanl(*)1[1..]
¡Pruébelo en línea!
Bastante sencillo: genera la lista de factoriales [1,1,2,6,...]
con a scanl
, luego lo hace zipWith(*)
para multiplicar cada elemento de la entrada por el valor correspondiente.
32 bytes
foldr(\(i,x)r->x:map((i+1)*)r)[]
¡Pruébelo en línea!
Una solución bastante plegable. Toma entradas como (exponent, coefficient)
pares.
transmitir , 15 bytes
v"*<
0+1"
1{*}
¡Pruébelo en línea!

Las dos columnas de la izquierda copian "
1, 2, 3,… en la parte superior *
. El valor en la parte superior derecha se multiplica por eso en cada vuelta, por lo que obtenemos (¡comenzando con un 1 adicional = 0!) 1 !, 2 !, 3 !,… copiado en la parte inferior *
. {
lee la entrada, la multiplica por los factoriales y los emite }
.
Gelatina , 4 bytes
J’!×
Toma la entrada como lista de coeficientes.
Explicación
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
¡Pruébelo en línea!
APL (Dyalog Unicode) , 3 bytes
×∘!
¡Pruébelo en línea!
Lleva la E / S liberal al extremo: lleva el polinomio \$ 3x^4 + 2x^2+x-4 \$como dos argumentos, los coeficientes de la izquierda y las potencias de la derecha en orden decreciente e incluyendo términos cero, como en 3 0 2 1 ¯4 f 4 3 2 1 0
. Devuelve el polinomio como un vector de coeficientes.
PowerShell , 28 bytes
Ingrese como una lista de coeficientes
$p++;$args|%{$p*$_;$p*=++$i}
¡Pruébelo en línea!
APL (Dyalog Unicode) , 7 bytes
⊢×!∘⍳∘≢
¡Pruébelo en línea!
Usos ⎕IO←0
(indexación 0)
Ingrese como una lista de coeficientes.
Wolfram Language (Mathematica) , 10 bytes
#2!#&@@@#&
¡Pruébelo en línea!
Ingrese una lista de pares de coeficientes / potencia, incluidos los coeficientes cero, ordenados por potencia, y envíe una lista de los coeficientes correspondientes.
El incorporado es más largo: 23 bytes
LaplaceTransform[#,t,]&
¡Pruébelo en línea!
Ingrese un polinomio en términos de t
y genere uno en términos de Null
.
Retina , 30 bytes
L$`.+ $&$:&* +`\d+_ $.(*$(_$%'
¡Pruébelo en línea! E / S es una lista de coeficientes delimitados por líneas nuevas de menor a mayor grado. Explicación:
L$`.+ $&$:&*
Para cada coeficiente, agregue un número de guiones bajos igual a su grado.
+`\d+_
$.(*$(_$%'
Hasta que no queden guiones bajos, multiplique cada coeficiente por el número de guiones bajos siguientes, eliminando uno en el proceso.
Scala 3, 52 48 bytes
p=>p.indices.scanLeft(1)(_*_.+(1))zip p map(_*_)
¡Pruébelo en línea!
Entrada y salida como una lista de números enteros, de menor a mayor grado.
p.indices
nos da un rango de 0 a p.size - 1
. Escanear a la izquierda con multiplicación da el factorial en cada índice, pero como el primer elemento es 0, necesitamos sumar 1 (por lo tanto _.+(1)
). Luego, todos los factoriales se comprimen con los coeficientes y se multiplican.
Python 2 , 39 bytes
p=i=1
while 1:print p*input();p*=i;i+=1
¡Pruébelo en línea!
La entrada y la salida son coeficientes, uno por línea, comenzando con el grado más pequeño (el cero más cercano).
Tomar en (coefficient, exponent)
parejas resulta un poco más largo.
p=1
while 1:x,i=input();print p*x;p*=i+1
¡Pruébelo en línea!
Raku , 15 bytes
*Z*1,|[\*] 1..*
¡Pruébelo en línea!
[\*] 1..*
es la secuencia infinita de factoriales que comienzan con 1!
. Se pega un 1
(para 0!
) adicional al frente, luego todo se comprime con multiplicación ( Z*
) con la única secuencia de entrada *
.
Japonés -m , 3 bytes
*Vl
Pruébalo aquí
R , 34 28 25 bytes
(x=scan())*gamma(seq(!x))
¡Pruébelo en línea!
Muy claro.
R carece de una función factorial abreviada, pero tiene gamma
.
Genera una secuencia junto x
con el truco de @Giuseppe .
JavaScript (ES6), 31 29 bytes
E / S: listas de coeficientes, de menor a mayor grado.
a=>a.map((v,i)=>v*=p=i?p*i:1)
¡Pruébelo en línea!
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
Guardado 4 bytes gracias a ovs !!!
lambda f:f.laplace(x,x)
¡Pruébelo en línea!
Toma una función de \$x\$como entrada y devuelve la transformada de Laplace en función de \$x\$.
Carbón , 12 bytes
IEA×ιΠ⊞Oυ∨κ¹
¡Pruébelo en línea! El enlace corresponde a una versión detallada del código. E / S es una lista de coeficientes de menor a mayor grado. Explicación:
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!*
Pruébelo en línea.
O alternativamente:
ā<!*
Pruébelo en línea.
Ambos toman una lista de coeficientes como entrada.
Explicación:
ε # 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)