Transformée polynomiale de Laplace

Question

_{Ceci est une republication de ce défi, destiné à le réorganiser pour des formats d'E / S plus lâches et des règles mises à jour}

Vous devez écrire un programme qui prend un polynôme entier dans \$t\$comme entrée et sortie de la transformée de Laplace de ce polynôme. Quelques définitions et propriétés:

• La transformée de Laplace d'une fonction donnée \$f(t)\$ est

$$\mathcal{L}\{f(t)\} = F(s) = \int_0^\infty f(t)e^{-st}dt$$

• La transformée de Laplace de \$f(t) = t^n, \, n = 0, 1, 2, ...\$ est

$$\mathcal{L}\{t^n\} = \frac{n!}{s^{n+1}}$$

• Les transformations de Laplace distribuent sur l'addition:

$$\mathcal{L}\{f(t)+g(t)\} = \mathcal{L}\{f(t)\} + \mathcal{L}\{g(t)\}$$

• La transformée de Laplace d'une constante multipliée par une fonction est égale à la constante multipliée par la transformée:

$$\mathcal{L}\{af(t)\} = a\mathcal{L}\{f(t)\}$$

• Un polynôme entier est un polynôme où chaque terme a un coefficient entier et un ordre non négatif

Un exemple travaillé:

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

---

Vous pouvez prendre une entrée dans une représentation standard d'un polynôme. Quelques exemples (pour \$3x^4+2x^2+x-4\$ à titre d'exemple) sont:

• Une liste de coefficients. [-4, 1, 2, 0, 3]ou[3, 0, 2, 1, -4]
• Paires de coefficients et de puissances. [[3, 4], [2, 2], [1, 1], [-4, 0]]et divers ordres différents
• Une chaîne, utilisant la variable de votre choix. 3x^4+2x^2+x-4

De même, comme la sortie sera un polynôme avec des ordres négatifs, vous pouvez produire dans des formats similaires, tels que (en utilisant \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):

• Une liste de coefficients. [72, 0, 4, 1, -4]ou[-4, 1, 4, 0, 72]
• Paires de coefficients et de puissances. [[72, -5], [4, -3], [1, -2], [-4, -1]]et divers ordres différents (ou les versions positives des pouvoirs)
• Une chaîne, utilisant la variable de votre choix. 72s^-5+4s^-3+s^-2-4s^-1

Si vous avez une autre méthode d'E / S dont vous n'êtes pas sûr, veuillez commenter ci-dessous pour demander.

C'est du code-golf donc le code le plus court en octets l'emporte.

Answer 1

Haskell , 25 octets

zipWith(*)$scanl(*)1[1..]

Essayez-le en ligne!

Assez simple: génère la liste des factorielles [1,1,2,6,...]avec a scanl, puis zipWith(*)multiplie chaque élément de l'entrée par la valeur correspondante.

32 octets

foldr(\(i,x)r->x:map((i+1)*)r)[]

Essayez-le en ligne!

Une jolie solution basée sur le pliage. Prend les entrées par (exponent, coefficient)paires.

Answer 2

transporter , 15 octets

v"*<
0+1"
 1{*}

Essayez-le en ligne!

Les deux colonnes de gauche copient "1, 2, 3,… en haut *. La valeur en haut à droite est multipliée par cela à chaque tour, donc nous obtenons (en commençant par 1 supplémentaire = 0!) 1 !, 2 !, 3 !,… copié en bas *. {lit l'entrée, la multiplie par les factorielles et les sort }.

Answer 3

Gelée , 4 octets

J’!×

Prend l'entrée sous forme de liste de coefficients.

Explication

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

Essayez-le en ligne!

Answer 4

APL (Dyalog Unicode) , 3 octets

×∘!

Essayez-le en ligne!

Prend les E / S libérales à l'extrême: prend le polynôme \$ 3x^4 + 2x^2+x-4 \$comme deux arguments, les coefficients à gauche et les puissances à droite par ordre décroissant et incluant des termes nuls, comme dans 3 0 2 1 ¯4 f 4 3 2 1 0. Renvoie le polynôme sous forme de vecteur de coefficients.

Answer 5

PowerShell , 28 octets

Entrée sous forme de liste de coefficients

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

Essayez-le en ligne!

Answer 6

APL (Dyalog Unicode) , 7 octets

⊢×!∘⍳∘≢

Essayez-le en ligne!

Utilisations ⎕IO←0(indexation 0)

Entrée sous forme de liste de coefficients.

Answer 7

Wolfram Language (Mathematica) , 10 octets

#2!#&@@@#&

Essayez-le en ligne!

Entrez une liste de paires coefficient / puissance, y compris les coefficients nuls, triés par puissance, et sortez une liste de coefficients correspondants.

---

L'intégré est plus long: 23 octets

LaplaceTransform[#,t,]&

Essayez-le en ligne!

Entrez un polynôme en termes de t, et en sortie un en termes de Null.

Answer 8

Rétine , 30 octets

L$`.+ $&$:&* +`\d+_ $.(*$(_$%'

Essayez-le en ligne! E / S est une liste délimitée par une nouvelle ligne de coefficients allant du degré le plus bas au plus élevé. Explication:

L$`.+ $&$:&*

Pour chaque coefficient, ajoutez un nombre de traits de soulignement égal à son degré.

+`\d+_
$.(*$(_$%'

Jusqu'à ce qu'il ne reste aucun trait de soulignement, multipliez chaque coefficient par le nombre de traits de soulignement suivants, en supprimant un dans le processus.

Answer 9

Scala 3, 52 48 octets

p=>p.indices.scanLeft(1)(_*_.+(1))zip p map(_*_)

Essayez-le en ligne!

Entrée et sortie sous forme de liste d'entiers, du plus bas au plus haut degré.

p.indicesnous donne une plage de 0 à p.size - 1. Le balayage à gauche avec multiplication donne la factorielle à chaque indice, mais comme le premier élément est 0, nous devons ajouter 1 (donc _.+(1)). Ensuite, toutes les factorielles sont compressées avec les coefficients et multipliées ensemble.

Answer 10

Python 2 , 39 octets

p=i=1
while 1:print p*input();p*=i;i+=1

Essayez-le en ligne!

L'entrée et la sortie sont des coefficients, un par ligne, commençant par le plus petit degré (zéro le plus proche).

La prise par (coefficient, exponent)paires s'avère un peu plus longue.

p=1
while 1:x,i=input();print p*x;p*=i+1

Essayez-le en ligne!

Answer 11

Raku , 15 octets

*Z*1,|[\*] 1..*

Essayez-le en ligne!

[\*] 1..*est la suite infinie de factorielles commençant par 1!. Un 1(pour 0!) supplémentaire est collé sur le devant, puis le tout est zippé avec multiplication ( Z*) avec la seule séquence d'entrée *.

Answer 12

Japt -m , 3 octets

*Vl

Essayez-le ici

Answer 13

R , 34 28 25 octets

(x=scan())*gamma(seq(!x))

Essayez-le en ligne!

Assez simple.
R n'a pas de fonction factorielle nommée abrégée, mais en a gamma.
Génère une séquence en xutilisant l' astuce de @Giuseppe .

Answer 14

JavaScript (ES6),  31  29 octets

E / S: listes de coefficients, du plus bas au plus haut degré.

a=>a.map((v,i)=>v*=p=i?p*i:1)

Essayez-le en ligne!

Commenté

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

Answer 15

SageMath , 27 23 octets

Sauvegardé 4 octets grâce à ovs !!!

lambda f:f.laplace(x,x)

Essayez-le en ligne!

Prend une fonction de \$x\$en entrée et renvoie la transformée de Laplace en fonction de \$x\$.

Answer 16

Charbon , 12 octets

ＩＥＡ×ιΠ⊞Ｏυ∨κ¹

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Les E / S sont une liste de coefficients du degré le plus bas au degré le plus élevé. Explication:

  Ａ             Input array
 Ｅ              Map over elements
    ι           Current element
   ×            Multiplied by
     Π          Product of
        υ       Predefined empty list
      ⊞Ｏ        After pushing
         ∨      Logical Or of
          κ     Current index
           ¹    Literal 1
Ｉ               Cast to string
                Implicitly print

Answer 17

05AB1E , 4 octets

εN!*

Essayez-le en ligne.

Ou bien:

ā<!*

Essayez-le en ligne.

Les deux prennent une liste de coefficients comme entrée.

Explication:

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