Bestimmen Sie anhand der Gleichung aus einem Polynom und einer x-Koordinate die Änderungsrate des Punktes an dieser x-Koordinate auf der Kurve.

Ein Polynom hat die Form: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, wobei a ϵ Q und n ϵ W. Für diese Herausforderung kann n auch 0 sein, wenn Sie nicht möchten um spezielle Fälle (Konstanten) zu behandeln, in denen es kein x gibt.

Um die Änderungsrate an dieser x-Koordinate zu finden, können wir die Ableitung des Polynoms erhalten und die x-Koordinate einstecken.

Eingang

Das Polynom kann in jeder vernünftigen Form genommen werden, aber Sie müssen ausdrücklich angeben, welches Format dies ist. Beispielsweise ist ein Array des Formulars [..[coefficient, exponent]..]zulässig.

Ausgabe

Die Änderungsrate des Punktes an der x-Koordinate ist angegeben.

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Beispiele

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

#'@#2&

(Beat THAT , MATL und 05AB1E)

Das erste Argument muss ein Polynom sein, mit #als Variable und mit &am Ende (dh ein reines Funktionspolynom; zB 3 #^2 + # - 7 &). Das zweite Argument ist die x-Koordinate des Points of Interest.

Erläuterung

#'

Nehmen Sie die Ableitung des ersten Arguments ( 1impliziert).

... @#2&

Stecken Sie das zweite Argument ein.

Verwendung

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

16134384838410

MATL , 8 6 Bytes

yq^**s

Eingabe ist: Array von Exponenten, Anzahl, Array von Koeffizienten.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle: 1 , 2, 3 , 4 , 5 .

Erläuterung

Betrachten wir beispielsweise Eingänge [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 Bytes

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

Dies ist eine Funktion, die einen Vektor aus Tupeln und einer Zahl akzeptiert und eine Zahl zurückgibt. Der absolute Wert soll sicherstellen, dass der Exponent nicht negativ ist, was notwendig ist, da Julia DomainErrorbeim Erhöhen einer Ganzzahl auf einen negativen Exponenten nervig ein wirft .

Probieren Sie es online! (beinhaltet alle Testfälle)

Vielen Dank an Glen O für ein paar Korrekturen und Bytes.

05AB1E ,12 11 Bytes

Dank Adnan ein Byte gespart.

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

Probieren Sie es online!

Die Gleitkommapräzision ist die von Python. Momentan tausche ich Stack-Werte zweimal aus. Vielleicht gibt es eine Möglichkeit, dies zu vermeiden und einige Bytes zu sparen.

Python 3, 41 Bytes

6 Bytes entfernt dank @AndrasDeak ! Tatsächlich ist diese Antwort jetzt eher seine als meine ...

Danke auch an @ 1Darco1 für zwei Korrekturen!

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

Anonyme Funktion, die eine Liste von Listen mit Koeffizienten und Exponenten (dasselbe Format wie in der Challenge beschrieben) und einer Zahl akzeptiert.

Probieren Sie es hier aus .

R, 31 Bytes

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

Anonyme Funktion, die einen Koeffizientenvektor a, einen Exponentenvektor nund einen xWert verwendet.

Matlab, 27 Bytes

Dies ist eine anonyme Funktion, die einen Wert xund ein Polyonmial pin Form einer Liste von Koeffizienten akzeptiert , z. B. x^2 + 2dargestellt werden kann als [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)

a ist eine Anordnung der Koeffizienten in aufsteigender Exponentenreihenfolge mit eingeschlossenen Nullen, z x ³-5 dargestellt werden würde [-5, 0, 0, 1].

MATLAB mit Symbolic Math Toolbox, 26 Byte

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

Dies definiert eine anonyme Funktion. Eingänge sind:

• ein Faden p , der das Polynom im Format definiert'4*x^3-2*x^4+5*x^10'
• eine Zahl x

Beispiel Verwendung:

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

Unbenannte Funktion mit zwei Eingaben pund x. pwird als R-Ausdruck des Polynoms angenommen (siehe Beispiel unten) und xist einfach der Bewertungspunkt.

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

Es funktioniert durch Aufrufen des DBefehls , der die symbolische Ableitung wrt berechnet xund den Ausdruck bei auswertet x.

Beispielausgabe

Unter der Annahme, dass die Funktion jetzt benannt ist f, kann sie folgendermaßen aufgerufen werden:

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)

die jeweils produziert:

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

PARI / GP , 20 Bytes

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

Zum Beispiel a(4*x^3-2*x^4+5*x^10,19)Ausbeuten 16134384838410.

C ++ 14, 165 138 133 112 110 Bytes

Generisches Variadic Lambda spart viel. -2 Bytes für #importund Löschen des Leerzeichens vorher<

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

Verwendung:

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 Bytes

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

Verwendung:

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

Gleichstrom, 31 Bytes

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

Verwendung:

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

DASH , 33 Bytes

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

Verwendung:

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

Erläuterung

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

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

Verwendung:

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

Erläuterung:

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 Bytes

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

Ergebnisse

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

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

lambdaFunktion nimmt zwei Eingänge pund x. pist das Polynom, angegeben in dem in der Frage angegebenen Beispielformat. xist der x-Wert, bei dem die Änderungsrate ermittelt wird.

Pari / GP , 14 Bytes

p->x->eval(p')

Verwendung:

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

Probieren Sie es online!

C 78 Bytes

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 Bytes

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

Das Polynom wird als Hash-Map ausgedrückt, wobei Schlüssel Koeffizienten und Werte Exponenten sind.

Casio Basic, 16 Bytes

diff(a,x)|x=b

Die Eingabe sollte das Polynom in Bezug auf sein x . 13 Bytes für den Code, +3 Bytes für die Eingabea,b als Parameter.

Leiten Sie einfach den Ausdruck ain Bezug auf ab x, und schließen Sie dann ab x=b.

Dyalog APL, 26 25 23 Bytes

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

Nimmt Polynom als rechtes Argument und Wert als linkes Argument.