Transformada polinomial de Laplace

Dec 26 2020

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

7 xnor Dec 26 2020 at 08:42

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.

6 xash Dec 26 2020 at 06:50

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

5 GioD Dec 26 2020 at 12:34

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!

5 Bubbler Dec 28 2020 at 13:02

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.

4 ZaelinGoodman Dec 28 2020 at 22:48

PowerShell , 28 bytes

Ingrese como una lista de coeficientes

$p++;$args|%{$p*$_;$p*=++$i}

¡Pruébelo en línea!

3 Razetime Dec 26 2020 at 12:56

APL (Dyalog Unicode) , 7 bytes

⊢×!∘⍳∘≢

¡Pruébelo en línea!

Usos ⎕IO←0(indexación 0)

Ingrese como una lista de coeficientes.

3 att Dec 26 2020 at 09:44

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 ty genere uno en términos de Null.

2 Neil Dec 26 2020 at 06:40

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.

2 user Dec 26 2020 at 06:36

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.indicesnos 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.

2 xnor Dec 26 2020 at 08:27

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!

2 Sean Dec 26 2020 at 13:16

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 *.

2 Shaggy Dec 26 2020 at 17:00

Japonés -m , 3 bytes

*Vl

Pruébalo aquí

2 pajonk Dec 26 2020 at 16:59

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 xcon el truco de @Giuseppe .

2 Arnauld Dec 26 2020 at 06:15

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()
2 Noodle9 Dec 26 2020 at 08:11

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\$.

1 Neil Dec 26 2020 at 23:46

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
1 KevinCruijssen Jan 07 2021 at 14:57

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)