Wielomianowa transformata Laplace'a

Dec 26 2020

To jest repost z tego wyzwania, mający na celu jego przebudowę pod kątem luźniejszych formatów we / wy i zaktualizowanych reguł

Masz napisać program, który przyjmuje wielomian liczb całkowitych w \$t\$jako wejście i wyjścia transformata Laplace'a tego wielomianu. Niektóre definicje i właściwości:

  • Transformata Laplace'a danej funkcji \$f(t)\$ jest

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

  • Transformata Laplace'a \$f(t) = t^n, \, n = 0, 1, 2, ...\$ jest

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

  • Rozkład transformacji Laplace'a na dodawanie:

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

  • Transformata Laplace'a stałej pomnożonej przez funkcję równa się stałej pomnożonej przez transformację:

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

  • Wielomian całkowity to wielomian, w którym każdy wyraz ma współczynnik w postaci liczby całkowitej i nieujemną kolejność

Sprawdzony przykład:

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


Możesz wziąć dane wejściowe w standardowej reprezentacji wielomianu. Kilka przykładów (dla \$3x^4+2x^2+x-4\$ jako przykład) są:

  • Lista współczynników. [-4, 1, 2, 0, 3]lub[3, 0, 2, 1, -4]
  • Pary współczynników i potęg. [[3, 4], [2, 2], [1, 1], [-4, 0]]i różne zamówienia
  • Ciąg, wykorzystujący dowolną zmienną, którą lubisz. 3x^4+2x^2+x-4

Podobnie, ponieważ wynik będzie wielomianem o ujemnych rzędach, możesz wyprowadzić w podobnych formatach, takich jak (używając \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):

  • Lista współczynników. [72, 0, 4, 1, -4]lub[-4, 1, 4, 0, 72]
  • Pary współczynników i potęg. [[72, -5], [4, -3], [1, -2], [-4, -1]]i różne różne porządki (lub pozytywne wersje uprawnień)
  • Ciąg, wykorzystujący dowolną zmienną, którą lubisz. 72s^-5+4s^-3+s^-2-4s^-1

Jeśli masz alternatywną metodę wejścia / wyjścia, co do której nie jesteś pewien, skomentuj poniżej, aby zapytać.

To jest code-golf, więc wygrywa najkrótszy kod w bajtach.

Odpowiedzi

7 xnor Dec 26 2020 at 08:42

Haskell , 25 bajtów

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

Wypróbuj online!

Całkiem proste: generuje listę silni [1,1,2,6,...]z a scanl, a następnie zipWith(*)mnoży każdy element danych wejściowych przez odpowiednią wartość.

32 bajty

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

Wypróbuj online!

Całkiem rozwiązanie oparte na składaniu. Przyjmuje dane wejściowe jako (exponent, coefficient)pary.

6 xash Dec 26 2020 at 06:50

przekazać , 15 bajtów

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

Wypróbuj online!

Dwie lewe kolumny kopiują "1, 2, 3,… na górę *. Wartość w prawym górnym rogu jest mnożona przez to co okrążenie, więc otrzymujemy (zaczynając od dodatkowego 1 = 0!) 1 !, 2!, 3 !,… kopiowane na dół *. {czyta dane wejściowe, mnoży je przez silnie i wyprowadza je }.

5 GioD Dec 26 2020 at 12:34

Galaretka , 4 bajty

J’!×

Przyjmuje dane wejściowe jako listę współczynników.

Wyjaśnienie

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

Wypróbuj online!

5 Bubbler Dec 28 2020 at 13:02

APL (Dyalog Unicode) , 3 bajty

×∘!

Wypróbuj online!

Doprowadza liberalne I / O do ekstremum: przyjmuje wielomian \$ 3x^4 + 2x^2+x-4 \$jako dwa argumenty, współczynniki po lewej stronie i potęgi po prawej stronie w porządku malejącym, w tym wyrażenia zerowe, jak w 3 0 2 1 ¯4 f 4 3 2 1 0. Zwraca wielomian jako wektor współczynników.

4 ZaelinGoodman Dec 28 2020 at 22:48

PowerShell , 28 bajtów

Wprowadź jako listę współczynników

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

Wypróbuj online!

3 Razetime Dec 26 2020 at 12:56

APL (Dyalog Unicode) , 7 bajtów

⊢×!∘⍳∘≢

Wypróbuj online!

Zastosowania ⎕IO←0(indeksowanie 0)

Wprowadź jako listę współczynników.

3 att Dec 26 2020 at 09:44

Język Wolfram (Mathematica) , 10 bajtów

#2!#&@@@#&

Wypróbuj online!

Wprowadź listę par współczynnik / moc, w tym współczynniki zerowe, posortowaną według potęgi i wyświetl listę odpowiednich współczynników.


Wbudowany jest dłuższy: 23 bajty

LaplaceTransform[#,t,]&

Wypróbuj online!

Wprowadź wielomian w postaci ti wyprowadź jeden w zakresie Null.

2 Neil Dec 26 2020 at 06:40

Retina , 30 bajtów

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

Wypróbuj online! I / O to rozdzielana znakami nowej linii lista współczynników od najniższego do najwyższego stopnia. Wyjaśnienie:

L$`.+ $&$:&*

Dla każdego współczynnika dodaj liczbę podkreśleń równą jego stopniowi.

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

Dopóki nie pozostaną żadne znaki podkreślenia, pomnóż każdy współczynnik przez liczbę następujących po nim podkreśleń, usuwając jeden w trakcie procesu.

2 user Dec 26 2020 at 06:36

Scala 3, 52 48 bajtów

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

Wypróbuj online!

Dane wejściowe i wyjściowe jako lista liczb całkowitych, od najniższego do najwyższego stopnia.

p.indicesdaje nam zakres od 0 do p.size - 1. Skanowanie po lewej stronie z mnożeniem daje silnię przy każdym indeksie, ale ponieważ pierwszy element ma wartość 0, musimy dodać 1 (stąd _.+(1)). Następnie wszystkie silnie są spakowane ze współczynnikami i pomnożone razem.

2 xnor Dec 26 2020 at 08:27

Python 2 , 39 bajtów

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

Wypróbuj online!

Dane wejściowe i wyjściowe to współczynniki, po jednym w wierszu, zaczynając od najmniejszego stopnia (najbliższe zero).

Przyjmowanie w (coefficient, exponent)parach okazuje się nieco dłuższe.

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

Wypróbuj online!

2 Sean Dec 26 2020 at 13:16

Raku , 15 bajtów

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

Wypróbuj online!

[\*] 1..*jest nieskończoną sekwencją silni zaczynających się od 1!. Dodatkowy 1(for 0!) jest wklejany z przodu, a następnie całość jest spakowana z mnożeniem ( Z*) z jedyną sekwencją wejściową *.

2 Shaggy Dec 26 2020 at 17:00

Japt -m , 3 bajty

*Vl

Spróbuj tutaj

2 pajonk Dec 26 2020 at 16:59

R , 34 28 25 bajtów

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

Wypróbuj online!

Całkiem proste.
R nie ma funkcji silni o krótkiej nazwie, ale ma gamma.
Generuje sekwencję wraz xz trikiem z @Giuseppe .

2 Arnauld Dec 26 2020 at 06:15

JavaScript (ES6),  31  29 bajtów

I / O: listy współczynników, od najniższego do najwyższego stopnia.

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

Wypróbuj online!

Skomentowano

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 bajty

Zapisano 4 bajty dzięki OVS !!!

lambda f:f.laplace(x,x)

Wypróbuj online!

Przyjmuje funkcję \$x\$jako dane wejściowe i zwraca transformatę Laplace'a jako funkcję \$x\$.

1 Neil Dec 26 2020 at 23:46

Węgiel , 12 bajtów

IEA×ιΠ⊞Oυ∨κ¹

Wypróbuj online! Link prowadzi do pełnej wersji kodu. I / O to lista współczynników od najniższego do najwyższego stopnia. Wyjaśnienie:

  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 bajty

εN!*

Wypróbuj online.

Lub alternatywnie:

ā<!*

Wypróbuj online.

Oba przyjmują listę współczynników jako dane wejściowe.

Wyjaśnienie:

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