Biorąc pod uwagę równanie wielomianu i współrzędnej x, znajdź szybkość zmiany punktu na tej współrzędnej x na krzywej.

Wielomian ma postać: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, gdzie a ϵ Q i n ϵ W. Dla tego wyzwania n może również wynosić 0, jeśli nie chcesz mieć radzić sobie ze specjalnymi przypadkami (stałymi), w których nie ma x.

Aby znaleźć szybkość zmian dla tej współrzędnej x, możemy uzyskać pochodną wielomianu i podłączyć współrzędną x.

Wejście

Wielomian można przyjąć w dowolnej rozsądnej formie, ale należy wyraźnie określić, jaki jest ten format. Na przykład [..[coefficient, exponent]..]dopuszczalna jest tablica formularza .

Wynik

Szybkość zmiany punktu na podanej współrzędnej x.

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach.

Przykłady

[[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 bajtów

#'@#2&

(Pokonaj THAT , MATL i 05AB1E)

Pierwszy argument musi być wielomianem, z #jego zmienną i &na końcu (tj. Czystą funkcją wielomianową; np 3 #^2 + # - 7 &.). Drugi argument to współrzędna x punktu zainteresowania.

Wyjaśnienie

#'

Weź pochodną pierwszego argumentu ( 1jest to dorozumiane).

... @#2&

Podłącz drugi argument.

Stosowanie

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

16134384838410

MATL , 8 6 bajtów

yq^**s

Dane wejściowe to: tablica wykładników, liczba, tablica współczynników.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe: 1 , 2 3 , 4 , 5 .

Wyjaśnienie

Rozważmy przykładowe wejść [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

Julia, 45 42 40 37 bajtów

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

Jest to funkcja, która pobiera wektor krotek i liczbę i zwraca liczbę. Absolutną wartością jest upewnienie się, że wykładnik nie jest ujemny, co jest konieczne, ponieważ denerwująca Julia rzuca a DomainError, podnosząc liczbę całkowitą do wykładnika ujemnego.

Wypróbuj online! (obejmuje wszystkie przypadki testowe)

Dzięki Glen O za kilka poprawek i bajtów.

05AB1E ,12 11 bajtów

Oszczędność jednego bajtu dzięki Adnanowi.

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

Wypróbuj online!

Dokładność zmiennoprzecinkowa należy do Pythona. Obecnie zamieniam wartości stosu dwa razy, być może istnieje sposób, aby tego uniknąć i zaoszczędzić trochę bajtów.

Python 3, 41 bajtów

Usunięto 6 bajtów dzięki @AndrasDeak ! W rzeczywistości ta odpowiedź jest teraz bardziej jego niż moja ...

Dziękujemy również @ 1Darco1 za dwie poprawki!

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

Anonimowa funkcja, która akceptuje listę list ze współczynnikami i wykładnikami (taki sam format, jak opisano w wyzwaniu) i liczbą.

Wypróbuj tutaj .

R, 31 bajtów

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

Anonimowa funkcja, która pobiera wektor współczynników a, wektor wykładników ni xwartość.

Matlab, 27 bajtów

Jest to anonimowa funkcja, która przyjmuje wartość xi wielomian pw postaci listy współczynników, np. x^2 + 2Może być reprezentowana jako [1,0,2].

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

JavaScript (ES7), 40 bajtów

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

ajest tablicą współczynników w rosnącym porządku wykładniczym z zawartymi zerami, np. x ³-5 byłoby reprezentowane przez [-5, 0, 0, 1].

MATLAB z Symbolic Math Toolbox, 26 bajtów

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

Definiuje to anonimową funkcję. Dane wejściowe to:

• ciąg pdefiniujący wielomian w formacie'4*x^3-2*x^4+5*x^10'
• numer x

Przykładowe zastosowanie:

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

R, 31 27 bajtów

Nienazwana funkcja pobierająca dwa wejścia pi x. pzakłada się, że jest wyrażeniem R wielomianu (patrz przykład poniżej) i xjest po prostu punktem oceny.

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

Działa poprzez wywołanie metody, Dktóra oblicza symboliczną pochodną wrt xi ocenia wyrażenie na x.

Przykładowe dane wyjściowe

Zakładając, że funkcja ma teraz nazwę f, można ją wywołać w następujący sposób:

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)

który odpowiednio wytwarza:

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

PARI / GP , 20 bajtów

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

Na przykład a(4*x^3-2*x^4+5*x^10,19)daje 16134384838410.

C ++ 14, 165 138 133 112 110 bajtów

Generyczna Variadic Lambda wiele oszczędza. -2 bajty dla #importi usuwanie poprzedniej spacji<

#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...);}

Nie golfowany:

#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...);
}

Stosowanie:

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 bajty

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

Stosowanie:

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

dc, 31 bajtów

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

Stosowanie:

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

DASH , 33 bajty

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

Stosowanie:

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

Wyjaśnienie

@@                             #. 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

Scala, 46 bajtów

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

Stosowanie:

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

Wyjaśnienie:

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

Axiom 31 bajtów

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

wyniki

 -> 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 bajtów

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

lambdafunkcja przyjmuje dwa wejścia, pa x. pjest wielomianem podanym w przykładowym formacie podanym w pytaniu. xto wartość x, przy której można znaleźć szybkość zmian.

Pari / GP , 14 bajtów

p->x->eval(p')

Stosowanie:

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

Wypróbuj online!

C, 78 bajtów

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 bajty

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

Wielomian jest wyrażony jako mapa mieszania, klucze są współczynnikami, a wartości są wykładnikami.

Casio Basic, 16 bajtów

diff(a,x)|x=b

Dane wejściowe powinny być wielomianem pod względem x. 13 bajtów dla kodu, +3 bajty do wprowadzenia a,bjako parametry.

Po prostu czerpie wyrażenie aw odniesieniu do x, a następnie sub x=b.

Dyalog APL, 26 25 23 bajtów

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

Traktuje wielomian jako argument prawy, a wartość jako argument lewy.