बहुपद लाप्लास रूपांतरित होते हैं

Question

_{यह इस चुनौती का एक प्रतिनिधि है , जिसका उद्देश्य इसे शिथिलता I / O स्वरूपों और अद्यतन नियमों के लिए फिर से तैयार करना है}

तुम एक कार्यक्रम में एक पूर्णांक बहुपद लेता लिखने के लिए कर रहे हैं \$t\$इनपुट के रूप में और इस बहुपद के लाप्लास रूपांतरण को आउटपुट करता है । कुछ परिभाषाएँ और गुण:

• दिए गए फ़ंक्शन का लाप्लास रूपांतरण \$f(t)\$ है

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

• लाप्लास के बदलने \$f(t) = t^n, \, n = 0, 1, 2, ...\$ है

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

• लाप्लास रूपांतर इसके अतिरिक्त वितरित होते हैं:

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

• एक फ़ंक्शन द्वारा निरंतर गुणा का लाप्लास परिवर्तन, परिवर्तन द्वारा लगातार गुणा के बराबर होता है:

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

• पूर्णांक बहुपद एक बहुपद है जहां प्रत्येक शब्द में एक पूर्णांक गुणांक होता है, और एक गैर-नकारात्मक क्रम होता है

काम किया उदाहरण:

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

---

आप एक बहुपद के मानक प्रतिनिधित्व में इनपुट ले सकते हैं। कुछ उदाहरण ( \ के लिए)$3x^4+2x^2+x-4\$ एक उदाहरण के रूप में) हैं:

• गुणांक की एक सूची। [-4, 1, 2, 0, 3]या[3, 0, 2, 1, -4]
• गुणांक और शक्तियों के जोड़े। [[3, 4], [2, 2], [1, 1], [-4, 0]]और विभिन्न विभिन्न आदेश
• एक स्ट्रिंग, जो भी चर आपको पसंद है, का उपयोग करके। 3x^4+2x^2+x-4

इसी तरह, आउटपुट के रूप में, नकारात्मक आदेश के साथ एक बहुपद हो जाएगा आप कर सकते हैं इस तरह के रूप में इसी तरह प्रारूपों में निर्गम (का उपयोग कर \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):

• गुणांक की एक सूची। [72, 0, 4, 1, -4]या[-4, 1, 4, 0, 72]
• गुणांक और शक्तियों के जोड़े। [[72, -5], [4, -3], [1, -2], [-4, -1]]और विभिन्न विभिन्न आदेश (या शक्तियों के सकारात्मक संस्करण)
• एक स्ट्रिंग, जो भी चर आपको पसंद है, का उपयोग करके। 72s^-5+4s^-3+s^-2-4s^-1

यदि आपके पास एक वैकल्पिक I / O विधि है जिसके बारे में आप अनिश्चित हैं, तो कृपया नीचे टिप्पणी करने के लिए कहें।

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है।

Answer 1

हास्केल , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बहुत सीधा: [1,1,2,6,...]एक के साथ भाज्य की सूची तैयार scanlकरता है, फिर zipWith(*)इसी मूल्य के अनुसार इनपुट के प्रत्येक तत्व को गुणा करता है।

32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक बहुत तह-आधारित समाधान। (exponent, coefficient)जोड़े के रूप में इनपुट्स लेता है ।

Answer 2

संदेश , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

दो बाएँ कॉलम "1, 2, 3,… को शीर्ष पर कॉपी करते हैं *। शीर्ष दाईं ओर का मान उस प्रत्येक गोद से कई गुना अधिक हो जाता है, इसलिए हम प्राप्त करते हैं (एक अतिरिक्त 1 = 0 के साथ शुरू!) 1 !, 2 !, 3 !, ... नीचे में प्रतिलिपि बनाई गई है *। {इनपुट को पढ़ता है, इसे गुणकों से गुणा करता है और उन्हें आउटपुट करता है }।

Answer 3

जेली , 4 बाइट्स

J’!×

गुणांक की सूची के रूप में इनपुट लेता है।

स्पष्टीकरण

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

इसे ऑनलाइन आज़माएं!

Answer 4

एपीएल (डायलॉग यूनिकोड) , 3 बाइट्स

×∘!

इसे ऑनलाइन आज़माएं!

ले जाता है उदार आई / ओ चरम पर: बहुपद लेता है \$ 3x^4 + 2x^2+x-4 \$दो तर्कों के रूप में, बाईं ओर गुणांक और घटते क्रम में दाईं ओर की शक्तियां और शून्य शर्तों सहित, जैसे 3 0 2 1 ¯4 f 4 3 2 1 0। गुणांक के एक वेक्टर के रूप में बहुपद लौटाता है।

Answer 5

पॉवरशेल , 28 बाइट्स

गुणांक की एक सूची के रूप में इनपुट

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

इसे ऑनलाइन आज़माएं!

Answer 6

एपीएल (डायलॉग यूनिकोड) , 7 बाइट्स

⊢×!∘⍳∘≢

इसे ऑनलाइन आज़माएं!

उपयोग ⎕IO←0(0-अनुक्रमण)

गुणांक की एक सूची के रूप में इनपुट।

Answer 7

वोल्फ्राम भाषा (गणितज्ञ) , 10 बाइट्स

#2!#&@@@#&

इसे ऑनलाइन आज़माएं!

गुणांक / शक्ति युग्मों की एक सूची इनपुट करें, जिसमें शून्य गुणांक शामिल हैं, शक्ति द्वारा सॉर्ट किया गया है, और इसी गुणांक की सूची को आउटपुट करता है।

---

निर्मित में लंबा है: 23 बाइट्स

LaplaceTransform[#,t,]&

इसे ऑनलाइन आज़माएं!

के संदर्भ में एक बहुपद इनपुट tऔर के संदर्भ में एक आउटपुट Null।

Answer 8

रेटिना , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं! I / O न्यूनतम से उच्चतम डिग्री तक गुणांक की एक नई-सीमांकित सूची है। स्पष्टीकरण:

L$`.+ $&$:&*

प्रत्येक गुणांक के लिए, अपनी डिग्री के बराबर कई अंडरस्कोर जोड़ें।

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

जब तक कोई अंडरस्कोर नहीं रहता है, तब तक प्रत्येक अंडरस्कोर की संख्या से गुणांक को गुणा करें, प्रक्रिया में एक को हटा दें।

Answer 9

स्काला 3, 52 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट पूर्णांकों की सूची के रूप में, निम्नतम से उच्चतम डिग्री तक।

p.indicesहमें 0 से एक सीमा देता है p.size - 1। गुणन के साथ बायीं ओर स्कैन करना प्रत्येक सूचकांक में फैक्टरियल देता है, लेकिन चूंकि पहला तत्व 0 है, इसलिए हमें 1 (इसलिए _.+(1)) जोड़ना होगा । फिर सभी फैक्टरियों को गुणांक के साथ जोड़ दिया जाता है और एक साथ गुणा किया जाता है।

Answer 10

पायथन 2 , 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट गुणांक हैं, एक प्रति पंक्ति, सबसे छोटी डिग्री (निकटतम शून्य) से शुरू होती है।

(coefficient, exponent)जोड़े में लेना थोड़ा लंबा हो जाता है।

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

इसे ऑनलाइन आज़माएं!

Answer 11

Raku , 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

[\*] 1..*के साथ शुरू होने वाले गुटों का अनंत क्रम है 1!। एक अतिरिक्त 1(के लिए 0!) मोर्चे पर चिपकाया जाता है, फिर पूरी चीज को Z*एकमात्र इनपुट अनुक्रम के साथ ज़िपित-से-गुणा ( ) किया जाता है *।

Answer 12

जाप -m , 3 बाइट्स

*Vl

इसे यहाँ आज़माएँ

Answer 13

आर , 34 28 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बहुत सीधा।
आर में एक लघु-नामित फैक्टरियल फ़ंक्शन का अभाव है, लेकिन है gamma। @Giuseppe से चाल का उपयोग करने के
साथ अनुक्रम उत्पन्न करता है ।x

Answer 14

जावास्क्रिप्ट (ईएस 6),  31  29 बाइट्स

I / O: गुणांक की सूची, निम्नतम से उच्चतम डिग्री तक।

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

इसे ऑनलाइन आज़माएं!

टिप्पणी की

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

सेजमैथ , 27 23 बाइट्स

सहेजे गए 4 बाइट्स ओव्स के लिए धन्यवाद !!!

lambda f:f.laplace(x,x)

इसे ऑनलाइन आज़माएं!

के एक समारोह ले जाता है \$x\$इनपुट और रिटर्न के रूप में लाप्लास के एक समारोह के रूप में परिणत \$x\$।

Answer 16

चारकोल , 12 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। I / O न्यूनतम से उच्चतम डिग्री तक गुणांक की एक सूची है। स्पष्टीकरण:

  Ａ             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 बाइट्स

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