Polinom Laplace dönüşümü

Dec 26 2020

Bu, daha gevşek G / Ç formatları ve güncellenmiş kurallar için yenilemeyi amaçlayan bu zorluğun bir yeniden yayınlanmasıdır.

\ ' Ye bir tamsayı polinomu alan bir program yazacaksınız.$t\$bu polinomun Laplace dönüşümü girdi ve çıktı olarak . Bazı tanımlar ve özellikler:

  • Belirli bir fonksiyonun Laplace dönüşümü \$f(t)\$ dır-dir

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

  • Laplace dönüşümü \$f(t) = t^n, \, n = 0, 1, 2, ...\$ dır-dir

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

  • Laplace dönüşümleri toplamaya dağılır:

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

  • Bir sabitin Laplace dönüşümü bir fonksiyonla çarpılırsa, sabitin dönüşümle çarpılmasına eşittir:

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

  • Tam sayı polinomu, her terimin bir tam sayı katsayısına ve negatif olmayan bir düzene sahip olduğu bir polinomdur.

İşlenmiş bir örnek:

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


Bir polinomun standart bir temsilinde girdi alabilirsiniz. Bazı örnekler ( \$3x^4+2x^2+x-4\$ örnek olarak) şunlardır:

  • Katsayıların bir listesi. [-4, 1, 2, 0, 3]veya[3, 0, 2, 1, -4]
  • Katsayı ve güç çiftleri. [[3, 4], [2, 2], [1, 1], [-4, 0]]ve çeşitli farklı sıralamalar
  • İstediğiniz değişkeni kullanan bir dize. 3x^4+2x^2+x-4

Benzer şekilde, çıktı negatif dereceli bir polinom olacağından, benzer formatlarda çıktı alabilirsiniz, örneğin ( \ kullanarak$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):

  • Katsayıların bir listesi. [72, 0, 4, 1, -4]veya[-4, 1, 4, 0, 72]
  • Katsayı ve güç çiftleri. [[72, -5], [4, -3], [1, -2], [-4, -1]]ve çeşitli farklı sıralamalar (veya güçlerin olumlu versiyonları)
  • İstediğiniz değişkeni kullanan bir dize. 72s^-5+4s^-3+s^-2-4s^-1

Emin olmadığınız alternatif bir G / Ç yönteminiz varsa, sormak için lütfen aşağıya yorum yapın.

Bu kod golfü olduğundan bayt cinsinden en kısa kod kazanır.

Yanıtlar

7 xnor Dec 26 2020 at 08:42

Haskell , 25 bayt

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

Çevrimiçi deneyin!

Oldukça basit: faktöriyellerin listesini [1,1,2,6,...]a ile oluşturur scanl, ardından zipWith(*)girdinin her bir öğesini karşılık gelen değerle çarpmak için yapar .

32 bayt

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

Çevrimiçi deneyin!

Oldukça katlanır tabanlı bir çözüm. Girişleri (exponent, coefficient)çift ​​olarak alır.

6 xash Dec 26 2020 at 06:50

taşıma , 15 bayt

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

Çevrimiçi deneyin!

Soldaki iki sütun "1, 2, 3,… 'yi en üste kopyalar *. Sağ üstteki değer, her turda bununla çarpılır, böylece (fazladan 1 = 0! İle başlayarak) 1 !, 2 !, 3 !,… alta kopyalanır *. {girdiyi okur, onu faktöriyellerle çarpar ve çıkarır }.

5 GioD Dec 26 2020 at 12:34

Jöle , 4 bayt

J’!×

Girdiyi katsayı listesi olarak alır.

Açıklama

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

Çevrimiçi deneyin!

5 Bubbler Dec 28 2020 at 13:02

APL (Dyalog Unicode) , 3 bayt

×∘!

Çevrimiçi deneyin!

Liberal G / Ç'yi en uç noktaya taşır: polinomu alır \$ 3x^4 + 2x^2+x-4 \$iki argüman olarak, soldaki katsayılar ve sağdaki kuvvetler azalan sırada ve sıfır terimleri içerdiği gibi 3 0 2 1 ¯4 f 4 3 2 1 0. Polinomu bir katsayı vektörü olarak verir.

4 ZaelinGoodman Dec 28 2020 at 22:48

PowerShell , 28 bayt

Katsayı listesi olarak giriş

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

Çevrimiçi deneyin!

3 Razetime Dec 26 2020 at 12:56

APL (Dyalog Unicode) , 7 bayt

⊢×!∘⍳∘≢

Çevrimiçi deneyin!

Kullanımlar ⎕IO←0(0-indeksleme)

Katsayı listesi olarak giriş.

3 att Dec 26 2020 at 09:44

Wolfram Dili (Mathematica) , 10 bayt

#2!#&@@@#&

Çevrimiçi deneyin!

Güce göre sıralanmış, sıfır katsayılar dahil olmak üzere katsayı / güç çiftlerinin bir listesini girin ve karşılık gelen katsayıların bir listesini çıkarın.


Yerleşik daha uzun: 23 bayt

LaplaceTransform[#,t,]&

Çevrimiçi deneyin!

Bir polinom cinsinden girin ve cinsinden bir tçıktı verin Null.

2 Neil Dec 26 2020 at 06:40

Retina , 30 bayt

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

Çevrimiçi deneyin! G / Ç, en düşükten en yüksek dereceye kadar yeni satırla sınırlandırılmış katsayı listesidir. Açıklama:

L$`.+ $&$:&*

Her katsayı için, derecesine eşit sayıda alt çizgi ekleyin.

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

Alt çizgi kalmayıncaya kadar, her katsayıyı aşağıdaki alt çizgi sayısıyla çarpın ve işlemden birini silin.

2 user Dec 26 2020 at 06:36

Scala 3, 52 48 bayt

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

Çevrimiçi deneyin!

En düşükten en yükseğe doğru bir tam sayı listesi olarak girdi ve çıktı.

p.indicesbize 0 ile arası bir aralık verir p.size - 1. Çarpma ile sola taramak, her dizinde faktöriyel verir, ancak ilk öğe 0 olduğundan, 1 eklememiz gerekir (dolayısıyla _.+(1)). Daha sonra tüm faktöriyeller katsayılarla sıkıştırılır ve birlikte çarpılır.

2 xnor Dec 26 2020 at 08:27

Python 2 , 39 bayt

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

Çevrimiçi deneyin!

Girdi ve çıktı, en küçük dereceden (en yakın sıfır) başlayarak satır başına bir katsayılardır.

(coefficient, exponent)Çift olarak almak biraz daha uzun sürer.

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

Çevrimiçi deneyin!

2 Sean Dec 26 2020 at 13:16

Raku , 15 bayt

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

Çevrimiçi deneyin!

[\*] 1..*ile başlayan faktöriyellerin sonsuz dizisidir 1!. Ön tarafa ek bir 1(for 0!) yapıştırılır, ardından her şey Z*tek giriş dizisi ile çarpma ( ) ile sıkıştırılır *.

2 Shaggy Dec 26 2020 at 17:00

Japt -m , 3 bayt

*Vl

Burada deneyin

2 pajonk Dec 26 2020 at 16:59

R , 34 28 25 bayt

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

Çevrimiçi deneyin!

Oldukça basit.
R'nin kısa adı faktöriyel işlevi yoktur, ancak vardır gamma. @Giuseppe'den hile kullanarak
dizi üretir .x

2 Arnauld Dec 26 2020 at 06:15

JavaScript (ES6),  31  29 bayt

G / Ç: en düşükten en yüksek dereceye kadar katsayı listeleri.

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

Çevrimiçi deneyin!

Yorum yaptı

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 bayt

Ovs sayesinde 4 bayt tasarruf etti !!!

lambda f:f.laplace(x,x)

Çevrimiçi deneyin!

\ İşlevini alır$x\$girdi olarak ve Laplace dönüşümünü \ işlevinin bir işlevi olarak döndürür.$x\$.

1 Neil Dec 26 2020 at 23:46

Kömür , 12 bayt

IEA×ιΠ⊞Oυ∨κ¹

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı sürümüne yöneliktir. G / Ç, en düşükten en yüksek dereceye kadar katsayıların bir listesidir. Açıklama:

  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 bayt

εN!*

Çevrimiçi deneyin.

Veya alternatif olarak:

ā<!*

Çevrimiçi deneyin.

Her ikisi de girdi olarak katsayıların bir listesini alır.

Açıklama:

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