Dada la ecuación de un polinomio y una coordenada x, encuentre la tasa de cambio del punto en esa coordenada x en la curva.

Un polinomio tiene la forma: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, donde a ϵ Q y n ϵ W. Para este desafío, n también puede ser 0 si no quieres tener para tratar casos especiales (constantes) donde no hay x.

Para encontrar la tasa de cambio en esa x-coord, podemos obtener la derivada del polinomio y enchufar la x-coord.

Entrada

El polinomio se puede tomar en cualquier forma razonable, pero debe indicar cuál es ese formato explícitamente. Por ejemplo, una matriz del formulario [..[coefficient, exponent]..]es aceptable.

Salida

La tasa de cambio del punto en la coordenada x dada.

Este es el código de golf , por lo que gana el código más corto en bytes.

Ejemplos

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

(Golpe QUE , MAT y 05AB1E)

El primer argumento debe ser un polinomio, con #su variable y &al final (es decir, una función pura polinomial; por ejemplo 3 #^2 + # - 7 &). El segundo argumento es la coordenada x del punto de interés.

Explicación

#'

Tome la derivada del primer argumento ( 1está implícito).

... @#2&

Conecta el segundo argumento.

Uso

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

16134384838410

MATL , 8 6 bytes

yq^**s

La entrada es: matriz de exponentes, número, matriz de coeficientes.

Pruébalo en línea! O verifique todos los casos de prueba: 1 , 2 3 , 4 , 5 .

Explicación

Considere entradas ejemplo [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)

Esta es una función que acepta un vector de tuplas y un número y devuelve un número. El valor absoluto es asegurar que el exponente no sea negativo, lo cual es necesario porque Julia molesta arroja un DomainErroral elevar un entero a un exponente negativo.

Pruébalo en línea! (incluye todos los casos de prueba)

Gracias a Glen O por un par de correcciones y bytes.

05AB1E ,12 11 bytes

Salvó un byte gracias a 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

Pruébalo en línea!

La precisión de coma flotante es la de Python. Actualmente cambio los valores de la pila dos veces, tal vez hay una manera de evitarlo y guardar algunos bytes.

Python 3, 41 bytes

¡6 bytes eliminados gracias a @AndrasDeak ! De hecho, esta respuesta ahora es más suya que mía ...

¡Gracias también a @ 1Darco1 por dos correcciones!

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

Función anónima que acepta una lista de listas con coeficientes y exponentes (el mismo formato que se describe en el desafío) y un número.

Pruébalo aquí .

R, 31 bytes

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

Función anónima que toma un vector de coeficientes a, un vector de exponentes ny un xvalor.

Matlab, 27 bytes

Esta es una función anónima que acepta un valor xy un polonmial pen forma de una lista de coeficientes, por ejemplo, x^2 + 2se puede representar como [1,0,2].

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

JavaScript (ES7), 40 bytes

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

aes una matriz de los coeficientes en orden de exponente ascendente con ceros incluidos, por ejemplo, x ³-5 estaría representado por [-5, 0, 0, 1].

MATLAB con Symbolic Math Toolbox, 26 bytes

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

Esto define una función anónima. Las entradas son:

• una cuerda p define el polinomio, en el formato'4*x^3-2*x^4+5*x^10'
• un número x

Ejemplo de uso:

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

Función sin nombre que toma dos entradas p y x. pse supone que es una expresión R del polinomio (ver ejemplo a continuación) y xes simplemente el punto de evaluación.

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

Funciona llamando al Dque calcula la derivada simbólica wrt xy evalúa la expresión enx .

Salida de ejemplo

Suponiendo que la función ahora se llama, fse puede llamar de la siguiente manera:

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)

que produce respectivamente:

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

Por ejemplo, a(4*x^3-2*x^4+5*x^10,19)rendimientos 16134384838410.

C ++ 14, 165 138 133 112 110 bytes

El genérico Variadic Lambda ahorra mucho. -2 bytes para #importy eliminando el espacio antes<

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

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

Uso:

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

Uso:

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

dc, 31 bytes

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

Uso:

$ 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

Uso:

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

Explicación

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

Uso:

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

Explicación:

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

Axioma 31 bytes

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

resultados

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

lambdaLa función toma dos entradas, py x. pes el polinomio, dado en el formato de ejemplo dado en la pregunta. xes el valor de x para encontrar la tasa de cambio.

Pari / GP , 14 bytes

p->x->eval(p')

Uso:

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

Pruébalo en línea!

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

El polinomio se expresa como un mapa hash, las claves son coeficientes y los valores son exponentes.

Casio Basic, 16 bytes

diff(a,x)|x=b

La entrada debe ser el polinomio en términos de x. 13 bytes para el código, +3 bytes para ingresar a,bcomo parámetros.

Simplemente deriva la expresión acon respecto a x, luego suscribe en x=b.

Dyalog APL, 26 25 23 bytes

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

Toma el polinomio como argumento derecho y el valor como argumento izquierdo.