Полиномиальное преобразование Лапласа

Dec 26 2020

Это репост этой проблемы, призванный обновить ее для более свободных форматов ввода-вывода и обновленных правил.

Вам нужно написать программу, которая принимает целочисленный многочлен от \$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

Если у вас есть альтернативный метод ввода-вывода, в котором вы не уверены, прокомментируйте его ниже.

Это кодовый гольф, поэтому побеждает самый короткий код в байтах.

Ответы

7 xnor Dec 26 2020 at 08:42

Haskell , 25 байт

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

Попробуйте онлайн!

Довольно просто: генерирует список факториалов [1,1,2,6,...]с a scanl, а затем zipWith(*)умножает каждый элемент ввода на соответствующее значение.

32 байта

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

Попробуйте онлайн!

Довольно складное решение. Принимает входные данные (exponent, coefficient)парами.

6 xash Dec 26 2020 at 06:50

передать , 15 байт

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

Попробуйте онлайн!

Два левых столбца копируют "1, 2, 3,… в верхнюю часть *. Значение в правом верхнем углу умножается на это значение на каждом круге, поэтому мы получаем (начиная с дополнительной 1 = 0!) 1 !, 2 !, 3 !,… копируемых в нижнюю часть *. {читает ввод, умножает его на факториалы и выводит их }.

5 GioD Dec 26 2020 at 12:34

Желе , 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

Попробуйте онлайн!

5 Bubbler Dec 28 2020 at 13:02

APL (Dyalog Unicode) , 3 байта

×∘!

Попробуйте онлайн!

Доводит либеральный ввод-вывод до крайности: принимает многочлен \$ 3x^4 + 2x^2+x-4 \$в качестве двух аргументов коэффициенты слева и степени справа в порядке убывания, включая нулевые члены, как в 3 0 2 1 ¯4 f 4 3 2 1 0. Возвращает полином как вектор коэффициентов.

4 ZaelinGoodman Dec 28 2020 at 22:48

PowerShell , 28 байт

Ввод в виде списка коэффициентов

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

Попробуйте онлайн!

3 Razetime Dec 26 2020 at 12:56

APL (Dyalog Unicode) , 7 байт

⊢×!∘⍳∘≢

Попробуйте онлайн!

Использует ⎕IO←0(0-индексация)

Введите как список коэффициентов.

3 att Dec 26 2020 at 09:44

Язык Wolfram Language (Mathematica) , 10 байт

#2!#&@@@#&

Попробуйте онлайн!

Введите список пар коэффициент / мощность, включая нулевые коэффициенты, отсортированный по мощности, и выведите список соответствующих коэффициентов.


Встроенный длиннее: 23 байта

LaplaceTransform[#,t,]&

Попробуйте онлайн!

Введите полином в единицах tи выведите один в единицах Null.

2 Neil Dec 26 2020 at 06:40

Retina , 30 байт

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

Попробуйте онлайн! I / O - это список коэффициентов, разделенных новой строкой, от самой низкой до самой высокой степени. Пояснение:

L$`.+ $&$:&*

Для каждого коэффициента добавьте подчеркивание, равное его степени.

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

Пока не останется знаков подчеркивания, умножьте каждый коэффициент на количество следующих знаков подчеркивания, удаляя один в процессе.

2 user Dec 26 2020 at 06:36

Scala 3, 52 48 байт

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

Попробуйте онлайн!

Ввод и вывод в виде списка целых чисел от самой низкой до самой высокой степени.

p.indicesдает нам диапазон от 0 до p.size - 1. Сканирование влево с умножением дает факториал по каждому индексу, но поскольку первый элемент равен 0, нам нужно добавить 1 (следовательно _.+(1)). Затем все факториалы заполняются коэффициентами и умножаются.

2 xnor Dec 26 2020 at 08:27

Python 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

Попробуйте онлайн!

2 Sean Dec 26 2020 at 13:16

Раку , 15 байт

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

Попробуйте онлайн!

[\*] 1..*бесконечная последовательность факториалов, начинающаяся с 1!. Дополнительный 1(for 0!) наклеивается на передний план, затем все это zip-with-multiplication ( Z*) с единственной входной последовательностью *.

2 Shaggy Dec 26 2020 at 17:00

Japt -m , 3 байта

*Vl

Попробуйте здесь

2 pajonk Dec 26 2020 at 16:59

R , 34 28 25 байт

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

Попробуйте онлайн!

Довольно просто.
В R отсутствует функция факториала с сокращенным именем, но есть gamma.
Создает последовательность xс помощью трюка от @Giuseppe .

2 Arnauld Dec 26 2020 at 06:15

JavaScript (ES6),  31  29 байт

Ввод / вывод: списки коэффициентов от низшей до высшей степени.

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()
2 Noodle9 Dec 26 2020 at 08:11

SageMath , 27 23 байта

Сохранено 4 байта благодаря ovs !!!

lambda f:f.laplace(x,x)

Попробуйте онлайн!

Принимает на себя функцию \$x\$в качестве входных данных и возвращает преобразование Лапласа как функцию от \$x\$.

1 Neil Dec 26 2020 at 23:46

Уголь , 12 байт

IEA×ιΠ⊞Oυ∨κ¹

Попробуйте онлайн! Ссылка на подробную версию кода. I / 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 байта

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