Trouver le taux de variation en un point d'un polynôme


15

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

8
Algorithme pour toute personne n'ayant pas la formation mathématique appropriée: La dérivée de A x ^ B + C x ^ D + ... est (A B) * x ^ (B-1) + (C D) * x ^ ( J-1) + ...
Sparr

Je ne connais pas l'ensemble W. Est-ce l'union des nombres naturels 0?
Alex A.

@AlexA., Oui, ça l'est.
Daniel


2
@PeterTaylor Je pense qu'ils partagent une idée similaire, mais je ne pense pas qu'une réponse puisse être publiée ici sans modification très, très importante.
Alex A.

Réponses:


23

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


3
Vous gagnez par 0 octets maintenant :-P
Luis Mendo

@LuisMendo Lorsqu'un gars avec un couteau de chef peut attacher avec une mandoline dans un concours de tranchage, je donnerai le point au gars qui utilise le couteau. ;)
J ...

8

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

7

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.


3
Je craignais que @AlexA. et Julia ont rompu, mais les voici à nouveau, ensemble en harmonie <3
flawr

Vous pouvez enregistrer trois octets supplémentaires si, au lieu d'utiliser i[2]>0&&pour traiter le cas constant, vous utilisez abs(i[2]-1)dans l'exposant de x. Et une astuce un peu moins propre pour économiser trois autres octets est d'utiliser p%xau lieu de f(p,x)- notez que vous pouvez l'appeler comme %(p,x)si vous vouliez l'utiliser sous forme de fonction ... malheureusement, il semble que cela ne fonctionne pas sur TIO (qui apparemment exécute Julia 0.4.6), bien que cela fonctionne sur mon Julia 0.5.0.
Glen O

@GlenO Nice, merci pour les suggestions. Je suis allé avec la abspartie, mais redéfinir les opérateurs d'infixe me fait physiquement mal ...
Alex A.

5

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.


1
Je pense que vous pouvez laisser de côté }:).
Adnan

DIs<m**Oest de 8 octets, suite à la réponse MATL fournie par @Luis Mendo.
Magic Octopus Urn

Encore mieux, s¹<m**Oc'est 7 octets. ( 05ab1e.tryitonline.net/… )
Urne Magic Octopus

Il change substantiellement le format d'entrée tandis que je garde celui d'origine. Mais je suis d'accord que la manipulation du format d'entrée permet des réponses plus courtes.
Osable

@Osable true, mais d'autres ont utilisé cette échappatoire;)
Magic Octopus Urn

4

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 .


Pourquoi pouvez-vous additionner a*x**(b-1)au lieu de a*b*x**(b-1)? Et de plus, que se passe-t-il si $ x = 0 $?
1Darco1

@ 1Darco1 Vous avez raison sur les deux. Je vais le changer dans peu de temps
Luis Mendo

3

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.


1
Agréable! J'ai ajouté une autre réponse avec le même nombre d'octets. Il utilise cependant une approche complètement différente. N'est-ce pas incroyable?
Billywob

1
Edit: n'est plus le même nombre d'octets :)
Billywob

2

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)

2

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


2

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

Vous pouvez utiliser @(x,p)polyval(polyder(p),x)pour gagner un octet.
flawr

@flawr Eh bien, il ne devrait pas maintenant parce que vous venez de poster cela comme réponse; P
Alex A.

@flawr Merci, mais c'est trop différent, vous devriez le poster!
Luis Mendo

1
Eh bien , je pense que vous ne l' auriez pas fait de toute façon, parce que vous voulez gagner un octet = D
flawr

@flawr Aww. J'ai complètement mal compris, haha
Luis Mendo

2

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

Merci de me l'avoir montré! Je n'avais pas envisagé la possibilité d'avoir l'entrée en tant qu'expression - c'est une solution vraiment élégante.
rturnbull

2

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.


Comment ça marche?
chat

@cat Il calcule la dérivée f'de f, et se substitue alors nà x.
Paŭlo Ebermann

2

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

Vous semblez avoir rayé tous vos comptes d'octets. Quel est alors le nombre réel d'octets?
numbermaniac

1
@numbermaniac merci, c'est fait.
Karl Napf

1

Haskell, 33 octets

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

Usage:

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

1

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

0

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

0

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

0

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

0

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.



0

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

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.


0

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.


0

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.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.