Data l'equazione di un polinomio e una coordinata x, trova la velocità di variazione del punto in corrispondenza di quella coordinata x sulla curva.

Un polinomio è nella forma: ax ⁿ + ax ^n-1 + ... + ax ¹ + a, dove ϵ Q e n ϵ W. Per questa sfida, n può anche essere 0 se non si desidera avere per trattare casi speciali (costanti) in cui non è presente x.

Per trovare la velocità di variazione in quel x-coord, possiamo ottenere la derivata del polinomio e collegare l'x-coord.

Ingresso

Il polinomio può essere assunto in qualsiasi forma ragionevole, ma è necessario indicare in modo esplicito quel formato. Ad esempio, un array del modulo [..[coefficient, exponent]..]è accettabile.

Produzione

Il tasso di variazione del punto in corrispondenza dell'x-coord indicato.

Questo è code-golf , quindi vince il codice più breve in byte.

Esempi

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

(Batti QUELLO , MATL e 05AB1E)

Il primo argomento deve essere un polinomio, con #come sua variabile e con &alla fine (cioè un polinomio di pura funzione; ad esempio 3 #^2 + # - 7 &). Il secondo argomento è la coordinata x del punto di interesse.

Spiegazione

#'

Prendi la derivata del primo argomento ( 1è implicito).

... @#2&

Inserisci il secondo argomento.

uso

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

16134384838410

MATL , 8 6 byte

yq^**s

L'input è: matrice di esponenti, numero, matrice di coefficienti.

Provalo online! Oppure verifica tutti i casi di test: 1 , 2 3 , 4 , 5 .

Spiegazione

Considerare input di esempio [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)

Questa è una funzione che accetta un vettore di tuple e un numero e restituisce un numero. Il valore assoluto è garantire che l'esponente non sia negativo, il che è necessario perché Julia dà fastidio DomainErrorquando lancia un intero a un esponente negativo.

Provalo online! (include tutti i casi di test)

Grazie a Glen O per un paio di correzioni e byte.

05AB1E ,12 11 byte

Salvato un byte grazie ad 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

Provalo online!

La precisione in virgola mobile è di Python. Attualmente scambio due volte i valori dello stack, forse c'è un modo per evitarlo e salvare alcuni byte.

Python 3, 41 byte

6 byte rimossi grazie a @AndrasDeak ! In effetti, questa risposta è ora più sua che mia ...

Grazie anche a @ 1Darco1 per due correzioni!

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

Funzione anonima che accetta un elenco di elenchi con coefficienti ed esponenti (stesso formato descritto nella sfida) e un numero.

Provalo qui .

R, 31 byte

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

Funzione anonima che accetta un vettore di coefficienti a, un vettore di esponenti ne un xvalore.

Matlab, 27 byte

Questa è una funzione anonima che accetta un valore xe un polionomio psotto forma di un elenco di coefficienti, ad esempio x^2 + 2può essere rappresentato come [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è una matrice dei coefficienti in ordine crescente esponente con zeri inclusi, ad esempio x ³-5 sarebbe rappresentato da [-5, 0, 0, 1].

MATLAB con Symbolic Math Toolbox, 26 byte

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

Questo definisce una funzione anonima. Gli input sono:

• una stringa che pdefinisce il polinomio, nel formato'4*x^3-2*x^4+5*x^10'
• un numero x

Esempio di utilizzo:

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

Funzione senza nome che accetta due input pe x. psi presume che sia un'espressione R del polinomio (vedi esempio sotto) ed xè semplicemente il punto di valutazione.

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

Funziona chiamando il Dche calcola il wrt di derivata simbolica xe valuta l'espressione in x.

Esempio di output

Supponendo che la funzione sia ora denominata f, può essere chiamata nel modo seguente:

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)

che produce rispettivamente:

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

Ad esempio, i a(4*x^3-2*x^4+5*x^10,19)rendimenti 16134384838410.

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

La Variadic Lambda generica risparmia molto. -2 byte per #imported eliminazione dello spazio prima<

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

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 byte

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

Uso:

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

dc, 31 byte

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

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

Uso:

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

Spiegazione

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

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

Spiegazione:

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 byte

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

risultati

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

lambdala funzione accetta due ingressi pe x. pè il polinomio, dato nel formato di esempio fornito nella domanda. xè il valore x al quale trovare il tasso di variazione.

Pari / GP , 14 byte

p->x->eval(p')

Uso:

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

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

Il polinomio è espresso come una mappa hash, le chiavi essendo coefficienti e valori sono esponenti.

Casio Basic, 16 byte

diff(a,x)|x=b

L'input dovrebbe essere il polinomio in termini di x. 13 byte per il codice, +3 byte da inserire a,bcome parametri.

Deriva semplicemente espressione arispetto a x, quindi si abbassa x=b.

Dyalog APL, 26 25 23 byte

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

Prende il polinomio come argomento giusto e il valore come argomento sinistro.