Dengan persamaan polinomial dan koordinat x, temukan laju perubahan titik pada koordinat x tersebut pada kurva.

Polinomial adalah dalam bentuk: kapak ⁿ + kapak ^n-1 + ... + kapak ¹ + a, di mana a ϵ Q dan n ϵ W. Untuk tantangan ini, n juga bisa 0 jika Anda tidak ingin memiliki untuk menangani kasus khusus (konstanta) di mana tidak ada x.

Untuk menemukan laju perubahan pada x-coord itu, kita bisa mendapatkan turunan dari polinomial dan menyambungkan x-coord.

Memasukkan

Polinomial dapat diambil dalam bentuk apa pun yang wajar, tetapi Anda harus menyatakan apa format itu secara eksplisit. Misalnya, array formulir[..[coefficient, exponent]..] dapat diterima.

Keluaran

Tingkat perubahan titik pada koordinat x yang diberikan.

Ini adalah kode-golf , jadi kode terpendek dalam byte menang.

Contohnya

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

#'@#2&

(Kalahkan ITU , MATL dan 05AB1E)

Argumen pertama harus polinomial, dengan #sebagai variabelnya dan dengan &di akhir (yaitu polinomial fungsi murni; misalnya 3 #^2 + # - 7 &). Argumen kedua adalah koordinat x dari tempat tujuan.

Penjelasan

#'

Ambil turunan dari argumen pertama ( 1tersirat).

... @#2&

Masukkan argumen kedua.

Pemakaian

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

16134384838410

MATL , 8 6 byte

yq^**s

Input adalah: array eksponen, jumlah, array koefisien.

Cobalah online! Atau verifikasi semua kasus uji: 1 , 2 3 , 4 , 5 .

Penjelasan

Perhatikan contoh input [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)

Ini adalah fungsi yang menerima vektor tupel dan angka dan mengembalikan angka. Nilai absolut adalah untuk memastikan bahwa eksponen tidak negatif, yang diperlukan karena Julia menjengkelkan DomainErrorketika menaikkan bilangan bulat ke eksponen negatif.

Cobalah online! (termasuk semua kasus uji)

Terima kasih kepada Glen O untuk beberapa koreksi dan byte.

05AB1E ,12 11 byte

Disimpan satu byte berkat 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

Cobalah online!

Presisi titik apung adalah Python. Saat ini saya menukar nilai tumpukan dua kali, mungkin ada cara untuk menghindarinya dan menyimpan beberapa byte.

Python 3, 41 byte

6 byte dihapus berkat @AndrasDeak ! Bahkan, jawaban ini sekarang lebih dari milikku ...

Terima kasih juga kepada @ 1Darco1 untuk dua koreksi!

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

Fungsi anonim yang menerima daftar daftar dengan koefisien dan eksponen (format yang sama seperti yang dijelaskan dalam tantangan) dan angka.

Coba di sini .

R, 31 byte

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

Fungsi anonim yang mengambil vektor koefisien a, vektor eksponen n, dan xnilai.

Matlab, 27 byte

Ini adalah fungsi anonim yang menerima nilai xdan polonmial pdalam bentuk daftar koefisien, misalnya x^2 + 2dapat direpresentasikan sebagai [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)

aadalah array dari koefisien dalam urutan eksponen naik dengan nol termasuk misalnya x ³-5 akan diwakili oleh [-5, 0, 0, 1].

MATLAB dengan Symbolic Math Toolbox, 26 byte

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

Ini mendefinisikan fungsi anonim. Inputnya adalah:

• Sebuah benang p defining the polynomial, in the format '4*x^3-2*x^4+5*x^10'
• sebuah angka x

Contoh penggunaan:

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

Fungsi yang tidak disebutkan namanya mengambil dua input pdan x. pdiasumsikan sebagai ekspresi-R dari polinomial (lihat contoh di bawah) dan xhanyalah titik evaluasi.

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

Ia bekerja dengan memanggil Dmana yang menghitung WRT derivatif simbolis xdan mengevaluasi ekspresi di x.

Contoh output

Dengan asumsi bahwa fungsi tersebut sekarang dinamai fdapat dipanggil dengan cara berikut:

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)

yang masing-masing menghasilkan:

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

Misalnya, a(4*x^3-2*x^4+5*x^10,19)hasil 16134384838410.

C++14, 165 138 133 112 110 bytes

Generic Variadic Lambda saves a lot. -2 bytes for #import and deleting the space before <

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

Usage:

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

Pemakaian:

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

dc, 31 byte

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

Pemakaian:

$ 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

Pemakaian:

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

Penjelasan

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

Pemakaian:

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

Penjelasan:

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

Aksioma 31 byte

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

hasil

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

lambdafungsi mengambil dua input, pdan x. padalah polinomial, diberikan dalam format contoh yang diberikan dalam pertanyaan. xadalah nilai x untuk menemukan tingkat perubahan.

Pari / GP , 14 byte

p->x->eval(p')

Pemakaian:

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

Cobalah online!

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

Polinomial dinyatakan sebagai peta hash, kunci menjadi koefisien dan nilai adalah eksponen.

Casio Basic, 16 byte

diff(a,x)|x=b

Masukan harus polinomial dalam hal x. 13 byte untuk kode, +3 byte untuk dimasukkan a,bsebagai parameter.

Turunkan ekspresi asehubungan dengan x, lalu masuk x=b.

Dyalog APL, 26 25 23 bytes

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

Mengambil polinomial sebagai argumen kanan dan nilai sebagai argumen kiri.