Étant donné l'équation d'un polynôme et d'une coordonnée x, trouver le taux de changement du point à cette coordonnée x sur la courbe.

Un polynôme se présente sous la forme: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, où a ϵ Q et n ϵ W. Pour ce défi, n peut aussi être 0 si vous ne voulez pas avoir pour traiter des cas particuliers (constantes) où il n'y a pas de x.

Pour trouver le taux de changement à cette coordonnée x, nous pouvons obtenir la dérivée du polynôme et brancher la coordonnée x.

Contribution

Le polynôme peut être pris sous toute forme raisonnable, mais vous devez indiquer explicitement ce format. Par exemple, un tableau du formulaire [..[coefficient, exponent]..]est acceptable.

Production

Le taux de changement du point à la coordonnée x donnée.

C'est le code-golf , donc le code le plus court en octets l'emporte.

Exemples

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

#'@#2&

(Beat THAT , MATL et 05AB1E)

Le premier argument doit être un polynôme, avec #comme variable et avec &à la fin (c'est-à-dire un polynôme à fonction pure; par exemple 3 #^2 + # - 7 &). Le deuxième argument est la coordonnée x du point d'intérêt.

Explication

#'

Prenez la dérivée du premier argument ( 1est implicite).

... @#2&

Branchez le deuxième argument.

Usage

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

16134384838410

MATL , 8 6 octets

yq^**s

L'entrée est: tableau d'exposants, nombre, tableau de coefficients.

Essayez-le en ligne! Ou vérifiez tous les cas de test: 1 , 2 3 , 4 , 5 .

Explication

Tenez compte des entrées par exemple [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 octets

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

Il s'agit d'une fonction qui accepte un vecteur de tuples et un nombre et renvoie un nombre. La valeur absolue est de s'assurer que l'exposant n'est pas négatif, ce qui est nécessaire car Julia gênant lance un DomainErroren élevant un entier à un exposant négatif.

Essayez-le en ligne! (inclut tous les cas de test)

Merci à Glen O pour quelques corrections et octets.

05AB1E ,12 11 octets

Un octet enregistré grâce à 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

Essayez-le en ligne!

La précision en virgule flottante est celle de Python. J'échange actuellement les valeurs de la pile deux fois, il y a peut-être un moyen de l'éviter et d'économiser quelques octets.

Python 3, 41 octets

6 octets supprimés grâce à @AndrasDeak ! En fait, cette réponse est désormais plus la sienne que la mienne ...

Merci également à @ 1Darco1 pour deux corrections!

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

Fonction anonyme qui accepte une liste de listes avec des coefficients et des exposants (même format que celui décrit dans le défi) et un nombre.

Essayez-le ici .

R, 31 octets

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

Fonction anonyme qui prend un vecteur de coefficients a, un vecteur d'exposants net une xvaleur.

Matlab, 27 octets

Il s'agit d'une fonction anonyme qui accepte une valeur xet un polyonmial psous la forme d'une liste de coefficients, par exemple x^2 + 2peut être représenté par [1,0,2].

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

JavaScript (ES7), 40 octets

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

aest un tableau des coefficients dans l'ordre des exposants ascendants avec des zéros inclus, par exemple x ³-5 serait représenté par [-5, 0, 0, 1].

MATLAB avec Symbolic Math Toolbox, 26 octets

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

Cela définit une fonction anonyme. Les entrées sont:

• une chaîne pdéfinissant le polynôme, au format'4*x^3-2*x^4+5*x^10'
• un numéro x

Exemple d'utilisation:

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

Fonction sans nom prenant deux entrées pet x. pest supposé être une expression R du polynôme (voir l'exemple ci-dessous) et xest simplement le point d'évaluation.

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

Il fonctionne en appelant le Dqui calcule la dérivée symbolique wrt xet évalue l'expression à x.

Exemple de sortie

En supposant que la fonction est désormais nommée, felle peut être appelée de la manière suivante:

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)

qui produit respectivement:

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

PARI / GP , 20 octets

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

Par exemple, les a(4*x^3-2*x^4+5*x^10,19)rendements 16134384838410.

C ++ 14, 165 138 133 133 112 110 octets

Generic Variadic Lambda économise beaucoup. -2 octets pour#import et supprimer l'espace avant<

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

Non golfé:

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

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

Usage:

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

dc, 31 octets

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

Usage:

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

DASH , 33 octets

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

Usage:

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

Explication

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

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

Usage:

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

Explication:

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

Axiome 31 octets

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

résultats

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

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

lambdala fonction prend deux entrées, pet x. pest le polynôme, donné dans le format d'exemple donné dans la question. xest la valeur x à laquelle trouver le taux de variation.

Pari / GP , 14 octets

p->x->eval(p')

Usage:

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

Essayez-le en ligne!

C, 78 octets

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 octets

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

Le polynôme est exprimé comme une carte de hachage, les clés étant des coefficients et les valeurs sont des exposants.

Casio Basic, 16 octets

diff(a,x)|x=b

L'entrée doit être le polynôme en termes de x. 13 octets pour le code, +3 octets à saisir a,bcomme paramètres.

Dérive simplement l'expression apar rapport à x, puis s'abaisse x=b.

Dyalog APL, 26 25 23 octets

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

Prend le polynôme comme argument de droite et la valeur comme argument de gauche.