एक बहुपद पर एक बिंदु पर परिवर्तन की दर का पता लगाएं

Question

एक बहुपद और एक x- समन्वय के समीकरण को देखते हुए वक्र पर उस x-निर्देश पर बिंदु के परिवर्तन की दर ज्ञात करते हैं।

एक बहुपद के रूप में है: कुल्हाड़ी ⁿ + कुल्हाड़ी ^n-1 + ... + कुल्हाड़ी ¹ + ए, जहां एक ϵ क्यू और एन and डब्ल्यू। इस चुनौती के लिए, n भी 0 हो सकता है यदि आप नहीं करना चाहते हैं विशेष मामलों (स्थिरांक) से निपटने के लिए जहां कोई एक्स नहीं है।

उस x-निर्देशांक में परिवर्तन की दर ज्ञात करने के लिए, हम बहुपद के व्युत्क्रम को प्राप्त कर सकते हैं और x- निर्देशांक में प्लग कर सकते हैं।

इनपुट

बहुपद को किसी भी उचित रूप में लिया जा सकता है, लेकिन आपको यह बताना होगा कि वह प्रारूप स्पष्ट रूप से क्या है। उदाहरण के लिए, प्रपत्र की एक सरणी [..[coefficient, exponent]..]स्वीकार्य है।

उत्पादन

दिए गए x- समन्वय पर बिंदु के परिवर्तन की दर।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

उदाहरण

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

Comments

उपयुक्त गणित पृष्ठभूमि नहीं रखने वाले किसी भी व्यक्ति के लिए एल्गोरिथम: ए x ^ B + C x ^ D + ... का व्युत्पन्न (A B) * x ^ (B-1) + (C D) * x ^ ( D-1) + ...

— Spear

मैं सेट डब्ल्यू से परिचित नहीं हूं। क्या प्राकृतिक संख्या संघ 0 है?

— एलेक्स ए।

@ एलेक्सा।, हाँ, यह है।

— डैनियल

बॉर्डरलाइन डूप

— पीटर टेलर

@PeterTaylor मुझे लगता है कि वे एक समान विचार साझा करते हैं, लेकिन मुझे नहीं लगता कि वहां से कोई जवाब बहुत, बहुत महत्वपूर्ण संशोधन के बिना यहां पोस्ट किया जा सकता है।

— एलेक्स ए।

Answer 1

गणितज्ञ, 6 बाइट्स

#'@#2&

(बीट कि , Matl और 05AB1E)

पहला तर्क बहुपद होना चाहिए, #इसके चर के साथ और &अंत में (यानी एक शुद्ध कार्य बहुपद; उदाहरण के लिए 3 #^2 + # - 7 &)। दूसरा तर्क ब्याज बिंदु के एक्स-समन्वय का है।

व्याख्या

#'

पहले तर्क का व्युत्पन्न लें ( 1निहित है)।

... @#2&

दूसरे तर्क में प्लग करें।

प्रयोग

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

16134384838410

Comments

अब आप 0 बाइट्स से जीते हैं :-P

— लुइस मेंडो

@LuisMendo जब एक शेफ की चाकू के साथ एक आदमी एक स्लाइसिंग प्रतियोगिता में एक मैन्डोलिन के साथ टाई कर सकता है, तो मैं चाकू का उपयोग करके आदमी को बिंदु दूंगा। ;)

— जे ...

Answer 2

MATL , 8 6 बाइट्स

yq^**s

इनपुट है: घातांक की संख्या, संख्या, गुणांक का सरणी।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें: 1 , 2 3 , 4 , 5 ।

व्याख्या

उदाहरण आदानों पर विचार करें [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

Answer 3

जूलिया, 45 42 40 37 बाइट्स

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

यह एक ऐसा कार्य है जो टुपल्स और एक संख्या के वेक्टर को पकड़ता है और एक संख्या देता है। पूर्ण मान यह सुनिश्चित करने के लिए है कि घातांक नकारात्मक नहीं है, जो आवश्यक है क्योंकि जूलिया कष्टप्रद DomainErrorजब एक नकारात्मक घटक को पूर्णांक बढ़ाते हैं।

इसे ऑनलाइन आज़माएं! (सभी परीक्षण मामले शामिल हैं)

सुधार और बाइट्स के एक जोड़े के लिए ग्लेन ओ का धन्यवाद।

Comments

मुझे डर था कि @AlexA। और जूलिया टूट गया, लेकिन यहां वे फिर से, एक साथ सद्भाव में हैं <3

— दोष

यदि आप i[2]>0&&निरंतर मामले से निपटने के लिए उपयोग करने के बजाय, आप एक अतिरिक्त तीन बाइट्स को बचा सकते हैं , तो आप abs(i[2]-1)के घटक में उपयोग करें x। और एक और तीन बाइट्स को बचाने के लिए थोड़ा कम क्लीन ट्रिक है - p%xइसके बजाय का उपयोग करें f(p,x)- ध्यान दें कि आप इसे कॉल कर सकते हैं जैसे %(p,x)कि आप इसे फ़ंक्शन रूप में उपयोग करना चाहते हैं ... दुर्भाग्य से, ऐसा लगता है कि यह टीआईओ पर काम नहीं करता है (जो स्पष्ट रूप से है जूलिया 0.4.6 चल रहा है), हालांकि यह मेरे जूलिया 0.5.0 पर काम करता है।

— ग्लेन ओ

@GlenO अच्छा, सुझाव के लिए धन्यवाद। मैं absभाग के साथ गया था, लेकिन infix ऑपरेटरों को फिर से परिभाषित करने से शारीरिक रूप से मुझे पीड़ा होती है ...

— एलेक्स ए।

Answer 4

05AB1E ,12 11 बाइट्स

अदनान की बदौलत एक बाइट बची।

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

इसे ऑनलाइन आज़माएं!

Floating point precision is Python's. I currently swap stack values twice, maybe there is a way to avoid it and save some bytes.

Comments

I believe you can leave out the } :).

— Adnan

DIs<m**O is 8 bytes, following the MATL answer that @Luis Mendo provided.

— Magic Octopus Urn

Even better, s¹<m**O is 7 bytes. (05ab1e.tryitonline.net/…)

— Magic Octopus Urn

It changes substantially the input format while I kept the original one. But I agree that manipulating the input format enables shorter answers.

— Osable

@Osable true, but others have used that loophole ;)

— Magic Octopus Urn

Answer 5

Python 3, 41 bytes

6 bytes removed thanks to @AndrasDeak! In fact, this answer is now more his than mine...

Thanks also to @1Darco1 for two corrections!

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

Anonymous function that accepts a list of lists with coefficients and exponents (same format as described in the challenge) and a number.

Try it here.

Comments

Why can you sum a*x**(b-1) instead of a*b*x**(b-1) ? And further, what if $x=0$ ?

— 1Darco1

@1Darco1 You are right on both. I'll change it in a little while

— Luis Mendo

Answer 6

R, 31 bytes

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

Anonymous function that takes a vector of coefficients a, a vector of exponents n, and an x value.

Comments

Nice! I added another answer with the same byte count. It uses a completely different approach though. Isn't R amazing?

— Billywob

Edit: No longer the same byte count :)

— Billywob

Answer 7

Matlab, 27 bytes

This is an anonymous function that accepts a value x and a polyonmial p in the form of a list of coefficients, e.g. x^2 + 2 can be represented as [1,0,2].

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

Answer 8

JavaScript (ES7), 40 bytes

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

a is an array of the coefficients in ascending exponent order with zeros included e.g. x³-5 would be represented by [-5, 0, 0, 1].

Answer 9

MATLAB with Symbolic Math Toolbox, 26 bytes

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

This defines an anonymous function. Inputs are:

• a string p defining the polynomial, in the format '4*x^3-2*x^4+5*x^10'
• a number x

Example use:

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

Comments

You could use @(x,p)polyval(polyder(p),x) in order to gain a byte.

— flawr

@flawr Well, he shouldn't now because you just posted that as an answer ;P

— Alex A.

@flawr Thanks, but that's too different, you should post it!

— Luis Mendo

Well I think you wouldn't have done it anyway, 'cause you'd gain a byte =D

— flawr

@flawr Aww. I completely misunderstood, haha

— Luis Mendo

Answer 10

R, 31 27 bytes

Unnamed function taking two inputs p and x. p is assumed to be an R-expression of the polynomial (see example below) and x is simply the point of evaluation.

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

It works by calling the D which computes the symbolic derivative w.r.t. x and the evaluates the expression at x.

Example output

Assuming that the function is now named f it can be called in the following way:

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)

which respectively produces:

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

Comments

Thanks for showing me this! I hadn't considered the possibility of having the input as an expression - this is a really elegant solution.

— rturnbull

Answer 11

PARI/GP, 20 bytes

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

For example, a(4*x^3-2*x^4+5*x^10,19) yields 16134384838410.

Comments

How the heck does that work?

— cat

@cat It calculates the derivative f' of f, and then substitutes n for x.

— Paŭlo Ebermann

Answer 12

C++14, 165 138 133 112 110 bytes

Generic Variadic Lambda saves a lot. -2 bytes for #import and deleting the space before <

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

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

Comments

You seem to have crossed out all your byte counts. What's the actual byte count, then?

— numbermaniac

@numbermaniac thank you, done.

— Karl Napf

Answer 13

Haskell, 33 bytes

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

Usage:

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

Answer 14

dc, 31 bytes

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

Answer 15

DASH, 33 bytes

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

Usage:

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

Explanation

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

Answer 16

Scala, 46 bytes

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

Explanation:

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

Answer 17

Axiom 31 bytes

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

results

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

Answer 18

Python 2, 39 bytes

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

lambda function takes two inputs, p and x. p is the polynomial, given in the example format given in the question. x is the x-value at which to find the rate of change.

Answer 19

Pari/GP, 14 bytes

p->x->eval(p')

Usage:

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

Try it online!

Answer 20

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

Answer 21

Clojure, 53 bytes

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

The polynomial is expressed as a hash-map, keys being coefficients and values are exponents.

Answer 22

Casio Basic, 16 bytes

diff(a,x)|x=b

Input should be the polynomial in terms of x. 13 bytes for the code, +3 bytes to enter a,b as parameters.

Simply derives expression a in respect to x, then subs in x=b.

Answer 23

Dyalog APL, 26 25 23 bytes

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

Takes polynomial as right argument and value as left argument.