Bir polinom ve bir x-koordinat denklemi verildiğinde, eğrideki o x-koordinatındaki noktanın değişim oranını bulur.

Bir polinom şu şekildedir: balta ⁿ + balta ^n-1 + ... + balta ¹ + a, burada bir ϵ Q ve n ϵ W Bu meydan okuma için, istemiyorsanız, n da 0 olabilir x olmayan özel durumlar (sabitler) ile uğraşmak.

Bu x-koordinatındaki değişim oranını bulmak için, polinomun türevini alabilir ve x-koordinatını takabiliriz.

Giriş

Polinom herhangi bir makul biçimde alınabilir, ancak bu formatın ne olduğunu açıkça belirtmelisiniz. Örneğin, formun bir dizisi [..[coefficient, exponent]..]kabul edilebilir.

Çıktı

Verilen x koordinatındaki noktanın değişim oranı.

Bu kod golf , bayt en kısa kod kazanır.

Örnekler

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

#'@#2&

( BU , MATL ve 05AB1E'yi yendi)

İlk argüman #, değişkeni ve &sonunda olan bir polinom olmalıdır (yani saf bir fonksiyon polinomu; örneğin 3 #^2 + # - 7 &). İkinci argüman, ilgilenilen noktanın x koordinatıdır.

açıklama

#'

İlk argümanın türevini alın ( 1ima edilir).

... @#2&

İkinci argümanı takın.

kullanım

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

16134384838410

MATL , 8 6 bayt

yq^**s

Girdi: üs dizisi, sayı, katsayı dizisi.

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın: 1 , 2 3 , 4 , 5 .

açıklama

Örnek giriş göz önünde [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 bayt

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

Bu, bir tuples vektörü ve bir sayıya ulaşan ve bir sayı döndüren bir işlevdir. Mutlak değer, üssün negatif olmamasını sağlamaktır, bu da Julia'nın can sıkıcı birDomainError olması, negatif bir üsse bir tamsayıyı yükseltirken bir .

Çevrimiçi deneyin! (tüm test senaryolarını içerir)

Birkaç düzeltme ve bayt için Glen O'ya teşekkürler.

05AB1E ,12 11 bayt

Adnan sayesinde bir bayt kurtardı.

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

Çevrimiçi deneyin!

Kayan nokta hassasiyeti Python'dur. Şu anda yığın değerlerini iki kez değiştirdim, belki bundan kaçınmanın ve bazı baytları kaydetmenin bir yolu var.

Python 3, 41 bayt

@AndrasDeak sayesinde 6 bayt kaldı ! Aslında, bu cevap artık benimkinden daha fazla ...

Ayrıca iki düzeltme için @ 1Darco1'e teşekkürler !

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

Katsayıları ve üsleri (meydan okumada açıklananla aynı format) ve bir sayı içeren listelerin listesini kabul eden anonim işlev.

Burada deneyin .

R, 31 bayt

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

Katsayıların abir vektörünü, üslerin bir vektörünü nve bir xdeğeri alan anonim işlev .

Matlab, 27 bayt

Bu değer kabul anonim fonksiyonudur xve polyonmial pkatsayılarının bir liste şeklinde, örneğin x^2 + 2olarak temsil edilebilir [1,0,2].

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

JavaScript (ES7), 40 bayt

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

asıfır, örneğin dahil ile üstel artan düzende katsayılarının bir dizidir x ³-5 ile temsil edilecektir [-5, 0, 0, 1].

Sembolik Matematik Araç Kutusu ile MATLAB, 26 bayt

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

Bu anonim bir işlevi tanımlar. Girişler:

• pformatında polinomu tanımlayan bir dize'4*x^3-2*x^4+5*x^10'
• bir sayı x

Örnek kullanım:

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

İki giriş alarak Adsız fonksiyonu pve x. p"Polinom" un bir R-ifadesi olduğu varsayılmaktadır (aşağıdaki örneğe bakınız) ve xsadece değerlendirme noktasıdır.

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

DHangi sembolik türev wrt hesaplar xve ifadesini değerlendirir çağırarak çalışır x.

Örnek çıktı

İşlevin şimdi adlandırıldığı varsayılarak f, aşağıdaki şekilde çağrılabilir:

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)

sırasıyla:

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

PARI / GP , 20 bayt

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

Örneğin, a(4*x^3-2*x^4+5*x^10,19)verim 16134384838410.

C ++ 14, 165 138 133 112 110 bayt

Jenerik Variadic Lambda çok tasarruf sağlar. -2 bayt #importve önceki boşluğu silme<

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

Kullanımı:

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 bayt

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

Kullanımı:

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

dc, 31 bayt

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

Kullanımı:

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

DASH , 33 bayt

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

Kullanımı:

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

açıklama

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

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

Kullanımı:

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

Açıklama:

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 bayt

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

Sonuçlar

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

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

lambdaişlevi iki giriş alır pve x. psoruda verilen örnek formatta verilen polinomdur. xdeğişimin oranını bulmak için kullanılan x değeridir.

Pari / GP , 14 bayt

p->x->eval(p')

Kullanımı:

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

Çevrimiçi deneyin!

C, 78 bayt

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 bayt

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

Polinom bir karma harita olarak ifade edilir, anahtarlar katsayılar ve değerler üstür.

Casio Basic, 16 bytes

diff(a,x)|x=b

Input should be the polynomial in terms of x. 13 bytes for the code, +3 bytes to enter a,b as parameters.

Simply derives expression a in respect to x, then subs in x=b.

Dyalog APL, 26 25 23 bytes

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

Takes polynomial as right argument and value as left argument.