Trova il tasso di variazione in un punto su un polinomio


15

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 n + ax n-1 + ... + ax 1 + 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 è , 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

8
Algoritmo per chiunque non abbia il background matematico appropriato: la derivata di A x ^ B + C x ^ D + ... è (A B) * x ^ (B-1) + (C D) * x ^ ( D-1) + ...
Sparr

Non ho familiarità con il set W. È quello l'unione dei numeri naturali 0?
Alex A.

@AlexA., Sì, lo è.
Daniel


2
@PeterTaylor Penso che condividano un'idea simile, ma non credo che nessuna risposta da lì possa essere pubblicata qui senza modifiche molto, molto significative.
Alex A.

Risposte:


23

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


3
Vinci ora per 0 byte :-P
Luis Mendo l'

@LuisMendo Quando un ragazzo con un coltello da chef può legare con una mandolina in una gara di affettamento, darò il punto al ragazzo che usa il coltello. ;)
J ...

8

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

7

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.


3
Temevo che @AlexA. e Julia si sciolse, ma eccoli di nuovo, insieme in armonia <3
flawr

È possibile salvare altri tre byte se, invece di utilizzare i[2]>0&&per gestire il caso costante, si utilizza abs(i[2]-1)nell'esponente di x. E un trucco leggermente meno pulito per salvare altri tre byte è usare p%xinvece di f(p,x)- nota che puoi chiamarlo come %(p,x)se volessi usarlo in forma di funzione ... sfortunatamente, sembra che non funzioni su TIO (che apparentemente è in esecuzione Julia 0.4.6), sebbene funzioni sul mio Julia 0.5.0.
Glen O,

@GlenO Bello, grazie per i suggerimenti. Sono andato con la absparte, ma ridefinire gli operatori di infissione mi fa male fisicamente ...
Alex A.

5

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.


1
Credo che tu possa tralasciare il }:).
Adnan,

DIs<m**Oè di 8 byte, a seguito della risposta MATL fornita da @Luis Mendo.
Magic Octopus Urn

Ancora meglio, s¹<m**Oè di 7 byte. ( 05ab1e.tryitonline.net/… )
Magic Octopus Urn

Cambia sostanzialmente il formato di input mentre ho mantenuto quello originale. Ma sono d'accordo sul fatto che la manipolazione del formato di input consente risposte più brevi.
Osable,

@Sable true, ma altri hanno usato quella scappatoia;)
Magic Octopus Urn

4

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 .


Perché puoi sommare a*x**(b-1)invece di a*b*x**(b-1)? E inoltre, se $ x = 0 $?
1Darco1

@ 1Darco1 Hai ragione su entrambi. Lo cambierò tra poco
Luis Mendo l'

3

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.


1
Bello! Ho aggiunto un'altra risposta con lo stesso numero di byte. Tuttavia utilizza un approccio completamente diverso. R non è sorprendente?
Billywob,

1
Modifica: non è più lo stesso numero di byte :)
Billywob,

2

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)

2

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


2

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

È possibile utilizzare @(x,p)polyval(polyder(p),x)per ottenere un byte.
Flawr,

@flawr Beh, non dovrebbe ora perché l'hai appena pubblicato come una risposta; P
Alex A.

@flawr Grazie, ma è troppo diverso, dovresti pubblicarlo!
Luis Mendo,

1
Beh, penso che non l'avresti fatto comunque, perché guadagneresti un byte = D
flawr

@flawr Aww. Ho completamente frainteso, ahah
Luis Mendo il

2

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

Grazie per avermelo mostrato! Non avevo considerato la possibilità di avere l'input come espressione: questa è una soluzione davvero elegante.
rturnbull,

2

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.


Come diamine funziona?
gatto

@cat Esso calcola la derivata f'di f, quindi sostituisce nper x.
Paŭlo Ebermann,

2

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

Sembra che tu abbia cancellato tutti i conteggi dei byte. Qual è il numero effettivo di byte, quindi?
numbermaniac,

1
@numbermaniac grazie, fatto.
Karl Napf,

1

Haskell, 33 byte

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

Uso:

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

1

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

0

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

0

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

0

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

0

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.



0

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

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.


0

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.


0

Dyalog APL, 26 25 23 byte

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

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.