จากสมการของพหุนามและพิกัด x พบว่าอัตราการเปลี่ยนแปลงของจุดที่ x-coord บนเส้นโค้ง

พหุนามอยู่ในรูปแบบ: ax ⁿ + ax ^n-1 + ... + ax ¹ + a โดยที่ ϵ Q และ n ϵ W. สำหรับความท้าทายนี้ n สามารถเป็น 0 ได้หากคุณไม่ต้องการ เพื่อจัดการกับกรณีพิเศษ (ค่าคงที่) ที่ไม่มี x

เพื่อหาอัตราการเปลี่ยนแปลงที่ x-coord เราสามารถหาอนุพันธ์ของพหุนามและเสียบเข้าไปใน x-coord

อินพุต

พหุนามสามารถใช้ในรูปแบบที่สมเหตุสมผลใด ๆ แต่คุณต้องระบุว่ารูปแบบนั้นชัดเจนหรือไม่ ตัวอย่างเช่นอาร์เรย์ของฟอร์ม[..[coefficient, exponent]..]เป็นที่ยอมรับ

เอาท์พุต

อัตราการเปลี่ยนแปลงของจุดที่ x-coord ที่กำหนด

นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ตัวอย่าง

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

Julia, 45 42 40 37 ไบต์

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

นี่คือฟังก์ชันที่ acceps เวกเตอร์ของ tuples และตัวเลขและส่งกลับตัวเลข ค่าสัมบูรณ์คือเพื่อให้แน่ใจว่าเลขชี้กำลังไม่เป็นลบซึ่งจำเป็นเพราะจูเลียน่ารำคาญพ่นDomainErrorเมื่อยกจำนวนเต็มเป็นเลขชี้กำลังเป็นลบ

ลองออนไลน์! (รวมถึงกรณีทดสอบทั้งหมด)

ขอบคุณ Glen O สำหรับการแก้ไขและไบต์สองสามข้อ

05AB1E ,12 11 ไบต์

บันทึกหนึ่งไบต์ต้องขอบคุณ 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

ลองออนไลน์!

ความแม่นยำจุดลอยตัวคือไพ ธ อน ขณะนี้ฉันสลับค่าสแต็กสองครั้งอาจมีวิธีหลีกเลี่ยงและบันทึกบางไบต์

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และ polyonmial 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

R, 31 27 ไบต์

ไม่มีชื่อสละฟังก์ชั่นทั้งสองปัจจัยการผลิตและp สันนิษฐานว่าเป็นนิพจน์ R ของพหุนาม (ดูตัวอย่างด้านล่าง) และเป็นเพียงจุดของการประเมินxpx

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

มันทำงานโดยการเรียกDซึ่งคำนวณ WRT อนุพันธ์สัญลักษณ์และประเมินการแสดงออกที่xx

ตัวอย่างผลลัพธ์

สมมติว่าตอนนี้ชื่อฟังก์ชั่น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อัตราผลตอบแทน

C ++ 14, 165 138 133 112 110 ไบต์

Generad 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

dc, 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คือค่า x ที่จะหาอัตราการเปลี่ยนแปลง

Pari / GP 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))))

พหุนามแสดงเป็น hash-map, กุญแจที่มีค่าสัมประสิทธิ์และค่าเป็นเลขชี้กำลัง

Casio Basic, 16 ไบต์

diff(a,x)|x=b

อินพุตควรเป็นพหุนามในแง่ของ xการป้อนข้อมูลที่ควรจะเป็นพหุนามในแง่ของ13 ไบต์สำหรับรหัส +3 ไบต์เพื่อป้อนa,bเป็นพารามิเตอร์

เพียงแค่มาแสดงออกaในแง่แล้วผู้ใต้บังคับบัญชาในxx=b

Dyalog APL, 26 25 23 ไบต์

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

ใช้พหุนามเป็นอาร์กิวเมนต์ขวาและค่าเป็นอาร์กิวเมนต์ซ้าย