Transformada de Laplace polinomial

Dec 26 2020

Este é um relançamento deste desafio, com a intenção de renová-lo para formatos de I / O mais flexíveis e regras atualizadas

Você deve escrever um programa que recebe um polinômio inteiro em \$t\$como entrada e produz a transformada de Laplace deste polinômio. Algumas definições e propriedades:

  • A transformada de Laplace de uma determinada função \$f(t)\$ é

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

  • A transformação de Laplace de \$f(t) = t^n, \, n = 0, 1, 2, ...\$ é

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

  • As transformações de Laplace são distribuídas sobre a adição:

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

  • A transformada de Laplace de uma constante multiplicada por uma função é igual à constante multiplicada pela transformação:

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

  • Um polinômio inteiro é um polinômio onde cada termo tem um coeficiente inteiro e uma ordem não negativa

Um exemplo trabalhado:

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


Você pode obter a entrada em uma representação padrão de um polinômio. Alguns exemplos (para \$3x^4+2x^2+x-4\$ como exemplo) são:

  • Uma lista de coeficientes. [-4, 1, 2, 0, 3]ou[3, 0, 2, 1, -4]
  • Pares de coeficientes e potências. [[3, 4], [2, 2], [1, 1], [-4, 0]]e vários pedidos diferentes
  • Uma string, usando qualquer variável que você quiser. 3x^4+2x^2+x-4

Da mesma forma, como a saída será um polinômio com ordens negativas, você pode produzir em formatos semelhantes, como (usando \$\mathcal{L}\{3x^4+2x^2+x-4\} = \frac{72}{s^5}+\frac4{s^3}+\frac1{s^2}-\frac4s\$):

  • Uma lista de coeficientes. [72, 0, 4, 1, -4]ou[-4, 1, 4, 0, 72]
  • Pares de coeficientes e potências. [[72, -5], [4, -3], [1, -2], [-4, -1]]e várias ordens diferentes (ou as versões positivas dos poderes)
  • Uma string, usando qualquer variável que você quiser. 72s^-5+4s^-3+s^-2-4s^-1

Se você tiver um método de E / S alternativo sobre o qual não tem certeza, comente abaixo para perguntar.

Este é o código-golfe, então o código mais curto em bytes vence.

Respostas

7 xnor Dec 26 2020 at 08:42

Haskell , 25 bytes

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

Experimente online!

Muito simples: Gera a lista de fatoriais [1,1,2,6,...]com um e scanl, a seguir, zipWith(*)multiplica cada elemento da entrada pelo valor correspondente.

32 bytes

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

Experimente online!

Uma solução bastante baseada em dobradura. Aceita entradas como (exponent, coefficient)pares.

6 xash Dec 26 2020 at 06:50

transmitir , 15 bytes

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

Experimente online!

As duas colunas da esquerda copiam "1, 2, 3,… para o topo *. O valor no canto superior direito é multiplicado por isso a cada volta, então obtemos (começando com um 1 extra = 0!) 1 !, 2 !, 3 !, ... copiado para o fundo *. {lê a entrada, multiplica-a com os fatoriais e os produz }.

5 GioD Dec 26 2020 at 12:34

Gelatina , 4 bytes

J’!×

Aceita a entrada como lista de coeficientes.

Explicação

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

Experimente online!

5 Bubbler Dec 28 2020 at 13:02

APL (Dyalog Unicode) , 3 bytes

×∘!

Experimente online!

Leva o I / O liberal ao extremo: leva o polinômio \$ 3x^4 + 2x^2+x-4 \$como dois argumentos, os coeficientes à esquerda e as potências à direita em ordem decrescente e incluindo termos zero, como em 3 0 2 1 ¯4 f 4 3 2 1 0. Retorna o polinômio como um vetor de coeficientes.

4 ZaelinGoodman Dec 28 2020 at 22:48

PowerShell , 28 bytes

Insira como uma lista de coeficientes

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

Experimente online!

3 Razetime Dec 26 2020 at 12:56

APL (Dyalog Unicode) , 7 bytes

⊢×!∘⍳∘≢

Experimente online!

Usos ⎕IO←0(indexação 0)

Insira como uma lista de coeficientes.

3 att Dec 26 2020 at 09:44

Linguagem Wolfram (Mathematica) , 10 bytes

#2!#&@@@#&

Experimente online!

Insira uma lista de pares de coeficiente / potência, incluindo coeficientes zero, classificados por potência, e produza uma lista de coeficientes correspondentes.


O integrado é maior: 23 bytes

LaplaceTransform[#,t,]&

Experimente online!

Insira um polinômio em termos de te produza um em termos de Null.

2 Neil Dec 26 2020 at 06:40

Retina , 30 bytes

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

Experimente online! I / O é uma lista delimitada por nova linha de coeficientes do grau mais baixo ao mais alto. Explicação:

L$`.+ $&$:&*

Para cada coeficiente, acrescente um número de sublinhados igual ao seu grau.

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

Até que nenhum sublinhado permaneça, multiplique cada coeficiente pelo número de sublinhados seguintes, excluindo um no processo.

2 user Dec 26 2020 at 06:36

Scala 3, 52 48 bytes

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

Experimente online!

Entrada e saída como uma lista de inteiros, do grau mais baixo ao mais alto.

p.indicesnos dá um intervalo de 0 a p.size - 1. A varredura para a esquerda com a multiplicação fornece o fatorial em cada índice, mas como o primeiro elemento é 0, precisamos adicionar 1 (portanto _.+(1)). Em seguida, todos os fatoriais são compactados com os coeficientes e multiplicados juntos.

2 xnor Dec 26 2020 at 08:27

Python 2 , 39 bytes

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

Experimente online!

A entrada e a saída são coeficientes, um por linha, começando com o menor grau (mais próximo de zero).

Ficar em (coefficient, exponent)pares acaba sendo um pouco mais longo.

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

Experimente online!

2 Sean Dec 26 2020 at 13:16

Raku , 15 bytes

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

Experimente online!

[\*] 1..*é a sequência infinita de fatoriais começando com 1!. Um adicional 1(para 0!) é colado na frente, então tudo é compactado com multiplicação ( Z*) com a única sequência de entrada *.

2 Shaggy Dec 26 2020 at 17:00

Japt -m , 3 bytes

*Vl

Experimente aqui

2 pajonk Dec 26 2020 at 16:59

R , 34 28 25 bytes

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

Experimente online!

Bem direto.
R não tem uma função fatorial abreviada, mas tem gamma.
Gera sequência xusando truque de @Giuseppe .

2 Arnauld Dec 26 2020 at 06:15

JavaScript (ES6),  31  29 bytes

I / O: listas de coeficientes, do menor ao maior grau.

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

Experimente online!

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

Economizei 4 bytes graças ao ovs !!!

lambda f:f.laplace(x,x)

Experimente online!

Desempenha uma função de \$x\$como entrada e retorna a transformada de Laplace como uma função de \$x\$.

1 Neil Dec 26 2020 at 23:46

Carvão , 12 bytes

IEA×ιΠ⊞Oυ∨κ¹

Experimente online! O link é para a versão detalhada do código. I / O é uma lista de coeficientes do grau mais baixo ao mais alto. Explicação:

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

Experimente online.

Ou alternativamente:

ā<!*

Experimente online.

Ambos recebem uma lista de coeficientes como entrada.

Explicação:

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