Cho phương trình của một đa thức và tọa độ x tìm tốc độ thay đổi của điểm tại tọa độ x đó trên đường cong.

Một đa thức có dạng: ax ⁿ + ax ^{n - 1} + ... + ax ¹ + a, trong đó a ϵ Q và n ϵ W. Đối với thử thách này, n cũng có thể là 0 nếu bạn không muốn có để giải quyết các trường hợp đặc biệt (hằng số) khi không có x.

Để tìm tốc độ thay đổi tại tọa độ x đó, chúng ta có thể lấy đạo hàm của đa thức và cắm vào tọa độ x.

Đầu vào

Đa thức có thể được thực hiện dưới bất kỳ hình thức hợp lý nào, nhưng bạn phải nói rõ định dạng đó là gì. Ví dụ, một mảng của biểu mẫu [..[coefficient, exponent]..]được chấp nhận.

Đầu ra

Tốc độ thay đổi của điểm tại tọa độ x đã cho.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Ví dụ

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

Toán học, 6 byte

#'@#2&

(Đánh bại THAT , MATL và 05AB1E)

Đối số đầu tiên phải là một đa thức, với #tư cách là biến của nó và &ở cuối (nghĩa là một đa thức hàm thuần túy, vd 3 #^2 + # - 7 &). Đối số thứ hai là tọa độ x của điểm quan tâm.

Giải trình

#'

Lấy đạo hàm của đối số đầu tiên ( 1được ngụ ý).

... @#2&

Cắm đối số thứ hai.

Sử dụng

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

16134384838410

MATL , 8 6 byte

yq^**s

Đầu vào là: mảng số mũ, số, mảng hệ số.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp kiểm tra: 1 , 2 3 , 4 , 5 .

Giải trình

Hãy xem xét ví dụ đầu vào [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 byte

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

Đây là một hàm lấy một vectơ và một số và trả về một số. Giá trị tuyệt đối là để đảm bảo rằng số mũ không âm, điều này cần thiết bởi vì Julia gây phiền nhiễu DomainErrorkhi ném một số nguyên lên số mũ âm.

Hãy thử trực tuyến! (bao gồm tất cả các trường hợp thử nghiệm)

Cảm ơn Glen O cho một vài chỉnh sửa và byte.

05AB1E ,12 11 byte

Đã lưu một byte nhờ Adnan.

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

Hãy thử trực tuyến!

Độ chính xác của dấu phẩy động là của Python. Tôi hiện trao đổi giá trị ngăn xếp hai lần, có thể có một cách để tránh nó và lưu một số byte.

Python 3, 41 byte

6 byte bị xóa nhờ @AndrasDeak ! Trên thực tế, câu trả lời này bây giờ nhiều hơn của tôi ...

Cũng xin cảm ơn @ 1Darco1 vì đã sửa hai lần!

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

Hàm ẩn danh chấp nhận danh sách các danh sách có hệ số và số mũ (cùng định dạng như được mô tả trong thử thách) và một số.

Hãy thử nó ở đây .

R, 31 byte

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

Hàm ẩn danh có một vectơ hệ số a, vectơ số mũ nvà xgiá trị.

Matlab, 27 byte

Đây là một hàm ẩn danh chấp nhận một giá trị xvà một đa giác pdưới dạng một danh sách các hệ số, ví dụ x^2 + 2có thể được biểu diễn dưới dạng [1,0,2].

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

JavaScript (ES7), 40 byte

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

alà một mảng các hệ số theo thứ tự lũy thừa tăng dần với các số 0 được bao gồm, ví dụ x ³-5 sẽ được biểu diễn bởi [-5, 0, 0, 1].

MATLAB với Hộp công cụ Toán học tượng trưng, ​​26 byte

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

Điều này xác định một chức năng ẩn danh. Đầu vào là:

• một chuỗi pxác định đa thức, theo định dạng'4*x^3-2*x^4+5*x^10'
• một số x

Ví dụ sử dụng:

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

Hàm không tên lấy hai đầu vào pvà x. pđược giả sử là biểu thức R của đa thức (xem ví dụ bên dưới) và xchỉ đơn giản là điểm đánh giá.

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

Nó hoạt động bằng cách gọi cái Dmà tính toán wrt phái sinh tượng trưng xvà đánh giá biểu thức tại x.

Ví dụ đầu ra

Giả sử rằng hàm bây giờ được đặt tên, fnó có thể được gọi theo cách sau:

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)

mà tương ứng tạo ra:

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

PARI / GP , 20 byte

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

Ví dụ, a(4*x^3-2*x^4+5*x^10,19)sản lượng 16134384838410.

C ++ 14, 165 138 133 112 110 byte

Chung Variadic Lambda tiết kiệm rất nhiều. -2 byte cho #importvà xóa không gian trước<

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

Ung dung:

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

Sử dụng:

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 byte

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

Sử dụng:

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

dc, 31 byte

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

Sử dụng:

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

DASH , 33 byte

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

Sử dụng:

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

Giải trình

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

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

Sử dụng:

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

Giải trình:

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

Tiên đề 31 byte

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

các kết quả

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

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

lambdaHàm có hai đầu vào, pvà x. plà đa thức, được đưa ra trong định dạng ví dụ được đưa ra trong câu hỏi. xlà giá trị x để tìm tốc độ thay đổi.

Pari / GP , 14 byte

p->x->eval(p')

Sử dụng:

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

Hãy thử trực tuyến!

C, 78 byte

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 byte

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

Đa thức được biểu thị dưới dạng bản đồ băm, các khóa là hệ số và giá trị là số mũ.

Casio cơ bản, 16 byte

diff(a,x)|x=b

Đầu vào phải là đa thức về mặt x. 13 byte cho mã, +3 byte để nhậpa,b làm tham số.

Đơn giản chỉ cần xuất phát biểu thức aliên quan đến x, sau đó đăng ký x=b.

APL Dyalog, 26 25 23 byte

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

Lấy đa thức làm đối số phải và giá trị như đối số trái.