По заданному уравнению многочлена и x-координаты найдите скорость изменения точки в этой x-координате на кривой.

Полином имеет вид: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, где a ϵ Q и n ϵ W. Для этой задачи n также может быть 0, если вы не хотите иметь иметь дело с особыми случаями (константами), где нет х.

Чтобы найти скорость изменения в этой x-координате, мы можем получить производную от многочлена и вставить x-координату.

вход

Полином может быть взят в любой разумной форме, но вы должны указать, что это за формат. Например, массив формы [..[coefficient, exponent]..]является приемлемым.

Выход

Скорость изменения точки при заданной координате х.

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

Примеры

[[4, 3], [-2, 4], [5, 10]]   19    ->   16134384838410
                  [[0, 4]]  400    ->   0
           [[4, 0], [5,1]]  -13    ->   5
      [[4.14, 4], [48, 2]]   -3    ->   -735.12
         [[1, 3], [-5, 0]]    5.4  ->   87.48

Mathematica, 6 байтов

#'@#2&

(Удар ЭТО , MATL и 05AB1E)

Первый аргумент должен быть полиномом, в #качестве его переменной и с &в конце (т. Е. Полиномиальной функцией; например 3 #^2 + # - 7 &). Второй аргумент - это x-координата интересующей точки.

объяснение

#'

Возьмем производную от первого аргумента ( 1подразумевается).

... @#2&

Подключите второй аргумент.

использование

#'@#2&[4 #^3 - 2 #^4 + 5 #^10 &, 19] (* The first test case *)

16134384838410

MATL , 8 6 байт

yq^**s

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

Попробуйте онлайн! Или проверьте все контрольные примеры: 1 , 2, 3 , 4 , 5 .

объяснение

Рассмотрим пример входов [3 4 10], 19, [4 -2 5].

y    % Take first two inputs implicitly and duplicate the first
     %   STACK: [3 4 10], 19, [3 4 10]
q    % Subtract 1, element-wise
     %   STACK: [3 4 10], 19, [2 3 9]
^    % Power, element-wise
     %   STACK: [3 4 10], [361 6859 322687697779]
*    % Multiply, element-wise
     %   STACK: [1083 27436 3226876977790]
*    % Take third input implicitly and multiply element-wise
     %   STACK: [4332 -54872 16134384888950]
s    % Sum of array
     %   STACK: 16134384838410

Юлия, 45 42 40 37 байт

f(p,x)=sum(i->prod(i)x^abs(i[2]-1),p)

Это функция, которая принимает вектор кортежей и число и возвращает число. Абсолютное значение должно гарантировать, что показатель степени не отрицателен, что необходимо, потому что раздражающая Джулия бросает a, DomainErrorповышая целое число до отрицательного показателя.

Попробуйте онлайн! (включает все тестовые случаи)

Спасибо Глену О за пару исправлений и байтов.

05AB1E ,12 11 байт

Сохранено один байт благодаря Аднану.

vy¤<²smsP*O

v          For each [coefficient, power] in the input array
 y         Push [coefficient, power]
  ¤<       Compute (power-1)
   ²       Push x value (second input entry)
    sms    Push pow(x, power-1)
       P   Push coefficient * power ( = coefficient of derivative)
        *  Push coefficient * power * pow(x, power-1)
         O Sum everything and implicitly display the result

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

Точность с плавающей точкой - это Python. В настоящее время я меняю значения стека дважды, возможно, есть способ избежать этого и сохранить несколько байтов.

Python 3, 41 байт

6 байтов удалено благодаря @AndrasDeak ! На самом деле, этот ответ теперь больше его, чем мой ...

Спасибо также @ 1Darco1 за две исправления!

lambda A,x:sum(a*b*x**(b-1) for a,b in A)

Анонимная функция, которая принимает список списков с коэффициентами и показателями степени (тот же формат, как описано в задании) и число.

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

R, 31 байт

function(a,n,x)sum(a*n*x^(n-1))

Анонимная функция, которая принимает вектор коэффициентов a, вектор показателей nи xзначение.

Matlab, 27 байт

Это анонимная функция, которая принимает значение xи многочлен pв виде списка коэффициентов, например, x^2 + 2может быть представлен как [1,0,2].

@(x,p)polyval(polyder(p),x)

JavaScript (ES7), 40 байт

(a,n)=>a.reduce((t,c,i)=>t+i*c*n**--i,0)

aявляется массивом коэффициентов в возрастающем порядке экспоненты с включенными нулями, например, x ³-5 будет представлен как [-5, 0, 0, 1].

MATLAB с символическим набором математических инструментов, 26 байтов

@(p,x)subs(diff(sym(p)),x)

Это определяет анонимную функцию. Входы:

• строка, pопределяющая полином в формате'4*x^3-2*x^4+5*x^10'
• число x

Пример использования:

>> f = @(p,x)subs(diff(sym(p)),x)
f = 
    @(p,x)subs(diff(sym(p)),x)

>> f('4*x^3-2*x^4+5*x^10', 19)
ans =
16134384838410

Р, 31 27 байт

Безымянная функция принимает два входа pи x. pПредполагается, что это R-выражение многочлена (см. пример ниже) и xявляется просто точкой оценки.

function(p,x)eval(D(p,"x"))

Это работает, вызывая Dкоторый вычисляет символическую производную поx и вычисляет выражение в x.

Пример вывода

Предполагая, что функция теперь названа, fее можно вызвать следующим образом:

f(expression(4*x^3-2*x^4+5*x^10),19)
f(expression(0*x^4),400)
f(expression(4*x^0+5*x^1),-13)
f(expression(4.14*x^4+48*x^2),-3)
f(expression(1*x^3-5*x^0),5.4)

который соответственно производит:

[1] 1.613438e+13
[1] 0
[1] 5
[1] -735.12
[1] 87.48

PARI / GP , 20 байтов

a(f,n)=subst(f',x,n)

Например, a(4*x^3-2*x^4+5*x^10,19)урожайность 16134384838410.

С ++ 14, 165 138 133 112 110 байт

Универсальный Variadic Lambda экономит много. -2 байта для #importи удаление места перед<

#import<cmath>
#define A auto
A f(A x){return 0;}A f(A x,A a,A b,A...p){return a*b*std::pow(x,b-1)+f(x,p...);}

Ungolfed:

#include <cmath>

auto f(auto x){return 0;}

auto f(auto x,auto a,auto b,auto...p){
    return a*b*std::pow(x,b-1)+f(x,p...);
}

Использование:

int main() {
 std::cout << f(19,4,3,-2,4,5,10) << std::endl;
 std::cout << f(400,0,4) << std::endl;
 std::cout << f(-13,4,0,5,1) << std::endl;
 std::cout << f(-3,4.14,4,48,2) << std::endl;
 std::cout << f(5.4,1,3,-5,0) << std::endl;
}

Haskell, 33 байта

f x=sum.map(\[c,e]->c*e*x**(e-1))

Использование:

> f 5.4 [[1, 3], [-5, 0]]
87.48000000000002

постоянный ток, 31 байт

??sx0[snd1-lxr^**ln+z2<r]srlrxp

Использование:

$ dc -e "??sx0[snd1-lxr^**ln+z2<r]srlrxp"
4.14 4 48 2
_3
-735.12

DASH , 33 байта

@@sum(->@* ^#1- :1#0 1(sS *)#0)#1

Использование:

(
  (
    @@sum(->@* ^#1- :1#0 1(sS *)#0)#1
  ) [[4;3];[_2;4];[5;10]]
) 19

объяснение

@@                             #. Curried 2-arg lambda
                               #. 1st arg -> X, 2nd arg -> Y
  sum                          #. Sum the following list:
    (map @                     #. Map over X
                               #. item list -> [A;B]
      * ^ #1 - :1#0 1(sS *)#0  #. This mess is just A*B*Y^(B-1)
    )#1                        #. X

Скала, 46 байт

s=>i=>s map{case(c,e)=>c*e*math.pow(i,e-1)}sum

Использование:

val f:(Seq[(Double,Double)]=>Double=>Double)=
  s=>i=>s map{case(c,e)=>c*e*math.pow(i,e-1)}sum
print(f(Seq(4.0 → 3, -2.0 → 4, 5.0 → 10))(19))

Объяснение:

s=>                        //define an anonymous function with a parameter s returning
  i=>                        //an anonymous function taking a paramater i and returning
    s map{                   //map each element of s:
      case(c,e)=>              //unpack the tuple and call the values c and e
        c*e*math.pow(i,e-1)    //calculate the value of the first derivate
    }sum                      //take the sum

Аксиома 31 байт

h(q,y)==eval(D(q,x),x,y)::Float

Результаты

 -> h(4*x^3-2*x^4+5*x^10, 19)
     161343 84838410.0

 -> h(4.14*x^4+48*x^2, -3)
     - 735.12

Python 2, 39 байт

lambda p,x:sum(c*e*x**~-e for c,e in p)

lambdaФункция принимает два входа, pи x. pявляется полиномом, приведенным в формате примера, приведенного в вопросе. xэто значение х, при котором можно найти скорость изменения.

Пари / ГП , 14 байтов

p->x->eval(p')

Использование:

? (p->x->eval(p'))(4*x^3 - 2*x^4 + 5*x^10)(19)
%1 = 16134384838410

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

C 78 байтов

f(int*Q,int*W,int S,int x){return Q[--S]*W[S]*pow(x,W[S]-1)+(S?f(Q,W,S,x):0);}

Clojure, 53 байта

#(apply +(for[[c e]%](apply * c e(repeat(dec e)%2))))

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

Casio Basic, 16 байтов

diff(a,x)|x=b

Ввод должен быть полиномом в терминах x. 13 байтов для кода, +3 байта для ввода в a,bкачестве параметров.

Просто получает выражение aпо отношению к x, а затем к югу от x=b.

Dyalog APL, 26 25 23 байта

{a←⍺⋄+/{×/⍵×a*2⌷⍵-1}¨⍵}

Принимает многочлен в качестве правого аргумента и значение в качестве левого аргумента.