अंतर कलन के साथ मेरी मदद करो!

Question

मुझे प्रोग्रामिंग बहुत पसंद है और मैं हर भाषा जानता हूं, लेकिन मैं गणित में चूसता हूं। दुर्भाग्य से, मेरे स्कूल को यह आवश्यक है कि कंप्यूटर के छात्रों को एक वर्ष का पथरी लेना चाहिए। अगले हफ्ते एक परीक्षा होनी है, और मुझे डेरिवेटिव्स के किसी भी फॉर्मूले का पता नहीं है!

कृपया मुझे सूत्र खोजने में मदद करें। मुझे एक चीट शीट की आवश्यकता है - एक प्रोग्राम (जितना संभव हो उतना कम मेरे शिक्षक इसे नोटिस नहीं करेंगे) जो 4*x^3-2इनपुट के रूप में एक अभिव्यक्ति (जैसे ) लेता है और व्युत्पन्न को आउटपुट करता है। (अगर इनपुट और आउटपुट कमांड लाइन आर्ग्युमेंट्स, STDIN, STDOUT, या जो भी हो, मैं इस बात की परवाह नहीं करता हूं, क्योंकि मैं सभी गणना मेरे सिर में वैसे भी कर रहा हूं।)

परीक्षण निम्न प्रकार के कार्यों को शामिल करता है:

• लगातार, जैसे -3या8.5
• पावर फ़ंक्शंस, जैसे x^0.5याx^-7
• घातीय कार्य, जैसे 0.5^xया 7^x(आधार हमेशा सकारात्मक होता है)
• एक फंक्शन, जैसे 3*x^5या के द्वारा एक गुणा-0.1*0.3^x
• कई कार्यों का योग और अंतर, जैसे -5*x^2+10-3^x

मेरे शिक्षक हमेशा अपने प्रश्नों को ठीक उसी तरह से प्रारूपित करते हैं, जैसा कि ऊपर दिखाया गया है। वह किसी अंश, संख्या जैसे pi या e , या वास्तव में बड़ी संख्या (1,000 से अधिक) का उपयोग नहीं करता है । वह कभी भी कोष्ठक का उपयोग नहीं करता है, और हमेशा तारांकन ( *) का उपयोग करके गुणा दिखाता है । उपयोग किया जाने वाला एकमात्र चर हमेशा x होता है ।

दूसरी ओर, मेरे शिक्षक उत्तर के बारे में बहुत उदार हैं। उन्हें बिल्कुल भी सरलीकृत करने की आवश्यकता नहीं है या जैसा कि ऊपर दिखाया गया है, जब तक कि यह स्पष्ट नहीं है कि उत्तर क्या कह रहा है।

जब मैं किसी भी भाषा का उपयोग कर सकता हूं, तो याद रखें कि मैं अपने आप से डेरिवेटिव का पता नहीं लगा सकता। इसलिए यदि कार्यक्रम समीकरणों से निपटने या डेरिवेटिव की गणना करने के लिए अंतर्निहित कार्यों का उपयोग करता है, तो मैं इसका उपयोग करने में सक्षम नहीं होगा।

परीक्षण के दौरान, मेरे पास इंटरनेट या किसी भी फाइल के अलावा चीट शीट पर कार्यक्रम तक पहुंच नहीं होगी।

नोट: यह परिदृश्य पूरी तरह से काल्पनिक है। वास्तविक जीवन में, दूसरों को धोखा देने और धोखा देने में मदद करना गलत है और ऐसा कभी नहीं करना चाहिए।

Comments

क्या हम उम्मीद कर सकते हैं कि xहमेशा अंतर करने के लिए चर है?

— काइल कानोस

क्या उत्तर सरल होना चाहिए? क्या हमें शब्दों की तरह जोड़ने की जरूरत है?

— रेनबोल्ट

मुझे लगता है कि यह मेरे गणना प्रोजेक्ट के लिए स्क्रैबलनड्रिड 3.जीथब्यू .io / Javascript-CAS में चमकने का समय है अगर मैं वास्तव में इसे गोल्फ कर सकता हूं

— स्क्रैब्नल 3

क्या हमें यह मान लेना चाहिए कि कोई परगना नहीं हैं?

— चार्ल्स

मैंने अपने संपादन में इनमें से अधिकांश सवालों के जवाब दिए हैं । कोई वैज्ञानिक संकेतन या उत्पाद नियम नहीं है।

— यपनीप

Answer 1

वोल्फ्राम 136 134 109 _{[नीचे टिप्पणी करने के लिए कैले का धन्यवाद]}

उत्पाद और श्रृंखला नियमों के लिए सीमित समर्थन।

n=n_?NumberQ;d[v_Plus]:=d/@v;d[v_]:=v/.{x_^n:>x^(n-1)d[x]n,n^x_:>Log[n]d[x]n^x,x_*y__:>d[x]y+d[y]x,n:>0,x:>1}

उदाहरण:

d[3^(x^2)*(x^3+2*x)^2]
>> 2*3^x^2*(2+3*x^2)*(2*x+x^3) + 2*3^x^2*x*(2*x+x^3)^2*Log[3]

ध्यान दें कि यह समीकरणों से निपटने या व्युत्पन्न गणना करने के लिए किसी भी "अंतर्निहित कार्यों" का उपयोग नहीं करता है: केवल पैटर्न-मिलान शामिल है *।

_{[* ठीक है ... तकनीकी तौर पर दुभाषिया पर्स भी लेता है और इनपुट से एएसटी का एक प्रकार भी बनाता है]}

---

Ungolfed:

d[expr_Plus] := d /@ expr;
d[expr_] := expr /. {
   Power[x_, n_?NumberQ] :> n Power[x, n - 1] d[x],
   Power[n_?NumberQ, x_] :> Log[n] Power[n, x] d[x],
   Times[x_, y__] :> d[x] y + d[y] x,
   n_?NumberQ :> 0,
   x :> 1
}

Comments

यह एक और संस्करण है । आपको आईडीके आदि लिखने की जरूरत नहीं है Power, Timesहालांकि यह आपके गोल्फ संस्करण को कितना बेहतर बनाएगा, लेकिन आपके पास कम से कम एक Timesहै जिससे आप हार सकते हैं। कुछ पात्रों को बचाएं। यह भी ध्यान दें कि आपके अनगुल्ड संस्करण में यह कहा गया है d[expr_]:= v/...।

@Calle "IDK कि आपके गोल्फ संस्करण में कितना सुधार होगा" - 25 बाइट्स! चीयर्स!

— सरन

Answer 2

पर्ल - 121 122

(+2 के लिए -p)

s/(?<![-\d.*^])-?[\d.]+(?![*^\d.])/0/g;s/(?<!\^)x(?!\^)/1/g;s/x\^(-?[\d.]+)/"$1*x^".($1-1)/ge;s/([\d.]+)\^x/ln($1)*$&/g

परीक्षा:

$ perl -p diff.pl << EOF
> -3
> 8.5
> x^0.5
> x^-7
> 0.5^x
> 7^x
> 3*x^5
> -0.1*0.3^x
> -5*x^2+10-3^x
> EOF
0
0
0.5*x^-0.5
-7*x^-8
ln(0.5)*0.5^x
ln(7)*7^x
3*5*x^4
-0.1*ln(0.3)*0.3^x
-5*2*x^1+0-ln(3)*3^x

Comments

फिर भी मुझे रेगेक्स सीखने का एक और कारण ...

— काइल कानोस

@KyleKanos मत। रेगेक्स खराब है, रेगेक्स भयानक है।

— मनिीप

मेह, मुझे हरा दो। बुरा नहीं! (PS: regex सुंदर है)

— मार्टिन एंडर

मुझे नहीं पता कि यहां क्या हो रहा है। +1

— क्वीन

स्पष्टीकरण: लगातार -> 0, x -> 1, x ^ n -> n * x ^ (n-1), एक ^ x -> ln (ए) * a ^ x

— n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 3

हास्केल 38 चार्ट

फ़ंक्शन dएक फ़ंक्शन लेता है और एक फ़ंक्शन देता है। इसे एक शक्ति श्रृंखला के रूप में इनपुट किया जाता है , और इसे उसी तरह से आउटपुट किया जाता है (जो भी एक प्रकार का है।)

d=zipWith(*)[1..].tail

उदाहरण के लिए, यदि हम इनपुट करते हैं x->x^2, तो हम प्राप्त करते हैं x->2*x।

λ <Prelude>: d [0,0,1]
[0,2]

और घातीय कार्य के लिए।

λ <Prelude>: take 10 exp --exp redefined above to be in power series notation
[1.0,1.0,0.5,0.16666666666666666,4.1666666666666664e-2,8.333333333333333e-3,1.388888888888889e-3,1.984126984126984e-4,2.48015873015873e-5,2.7557319223985893e-6]
λ <Prelude>: let d=zipWith(*)[1..].tail in take 10 $ d exp
[1.0,1.0,0.5,0.16666666666666666,4.1666666666666664e-2,8.333333333333333e-3,1.388888888888889e-3,1.984126984126984e-4,2.48015873015873e-5,2.7557319223985893e-6]

Comments

लेकिन ओपी कोई गणित नहीं जानता है! क्या हम उनसे शक्ति श्रृंखला के रूप में अपने घातीय इनपुट को व्यक्त करने की उम्मीद कर सकते हैं?

— सरन

खैर वह स्पष्ट रूप से संकेतन जानता है। वह सिर्फ व्युत्पन्न ऑपरेशन करना नहीं जानता है।

— प्यरुलेज़

क्या यह संभाल सकता है 2^x?

— काइल कानोस

यह कौन सा जादू टोना है?

— क्रिस्टोफर ओहेलसन

मैं यह नहीं देखता कि यह " 4*x^3-2इनपुट के रूप में एक अभिव्यक्ति (जैसे ) कैसे लेता है ", जैसा कि ओपी द्वारा आवश्यक है।

— गाबे

Answer 4

प्रस्तावना 176

d(N,0):-number(N).
d(x,1).
d(-L,-E):-d(L,E).
d(L+R,E+F):-d(L,E),d(R,F).
d(L-R,E-F):-d(L,E),d(R,F).
d(L*R,E*R+L*F):-d(L,E),d(R,F).
d(L^R,E*R*L^(R-1)+ln(L)*F*L^R):-d(L,E),d(R,F).

समर्थित ऑपरेटर: बाइनरी +, बाइनरी -, बाइनरी *, बाइनरी ^, यूनेरी -। ध्यान दें कि एकता +समर्थित नहीं है।

नमूना रन:

49 ?- d(-3,O).
O = 0.

50 ?- d(8.5,O).
O = 0.

51 ?- d(x^0.5,O).
O = 1*0.5*x^ (0.5-1)+ln(x)*0*x^0.5.

52 ?- d(x^-7,O).
ERROR: Syntax error: Operator expected
ERROR: d(x
ERROR: ** here **
ERROR: ^-7,O) . 
52 ?- d(x^ -7,O).
O = 1* -7*x^ (-7-1)+ln(x)*0*x^ -7.

53 ?- d(x,O).
O = 1.

54 ?- d(0.5^x,O).
O = 0*x*0.5^ (x-1)+ln(0.5)*1*0.5^x.

55 ?- d(7^x,O).
O = 0*x*7^ (x-1)+ln(7)*1*7^x.

56 ?- d(3*x^5,O).
O = 0*x^5+3* (1*5*x^ (5-1)+ln(x)*0*x^5).

57 ?- d(-0.1*0.3^x,O).
O = 0*0.3^x+ -0.1* (0*x*0.3^ (x-1)+ln(0.3)*1*0.3^x).

58 ?- d(-5*x^2+10-3^x,O).
O = 0*x^2+ -5* (1*2*x^ (2-1)+ln(x)*0*x^2)+0- (0*x*3^ (x-1)+ln(3)*1*3^x).

जब यह ^-क्रम में चलता है तो प्रोलॉग भ्रमित हो जाता है। अभिव्यक्ति को सही ढंग से पार्स करने के लिए इसके बीच ^और इसके -लिए एक स्थान डाला जाना चाहिए ।

आशा है कि आपका शिक्षक समीकरण की गड़बड़ी का बुरा नहीं मानता।

मस्ती का समय:

59 ?- d(x^x,O).
O = 1*x*x^ (x-1)+ln(x)*1*x^x.

60 ?- d((x^2-x+1)*4^ -x,O).
O = (1*2*x^ (2-1)+ln(x)*0*x^2-1+0)*4^ -x+ (x^2-x+1)* (0* -x*4^ (-x-1)+ln(4)* - 1*4^ -x).

Answer 5

सी, 260

अरे, मुझे लगता है कि मैं आपके शिक्षक को जानता हूं! क्या ऐसा नहीं है कि जिनके पास अपने सिर में पुस्तकालय पैटर्न-मिलान कार्यों को निष्पादित करने वाले छात्रों का पता लगाने की अलौकिक क्षमता है?

इसलिए, उपयोग sscanfकरना सवाल से बाहर है ... लेकिन चिंता न करें:

#define P s--||printf(
q=94,s,c,t,a;main(){char i[999],*p=i,*e=p;gets(i);for(;c=*p++,t=q^94|c^45?c%26==16?c%16/3:c/46:1,s=(a="30PCqspP#!C@ #cS` #!cpp#q"[s*5+t])/16-3,a&1&&(p[-1]=0),t||(P"*0"),P"/x"),P"/x*%s",e),P"*ln(%s)",e),s=0),a&2&&(e=p),c;putchar(q=c));}

चल रहे उदाहरण (इनपुट ऑन stdin; आउटपुट जाता है stdout):

4 * x ^ 3-2

4*x^3/x*3-2*0

यह प्रारूप केवल की तुलना में बहुत बेहतर है 12*x^2, क्योंकि इस तरह से आपके शिक्षक यह सुनिश्चित कर सकते हैं कि आपने स्वयं उत्तर की गणना की है और इसे किसी और से कॉपी करके धोखा नहीं दिया है!

x + 2 ^ x

x/x+2^x*ln(2)

आउटपुट में एक मामूली डोमेन समस्या है x=0, लेकिन यह लगभग हर जगह सही है !

संदर्भ के लिए, यहाँ एक ungolfed, पठनीय (मात्र नश्वर द्वारा) संस्करण है। यह 5 राज्यों और इनपुट पात्रों की 5 श्रेणियों के साथ एक राज्य मशीन का उपयोग करता है।

void deriv(char* input)
{
    char* p = input; // current position
    char* exp = p; // base or exponent
    char q = '^'; // previous character

    // State machine has 5 states; here are examples of input:
    // state 0: 123
    // state 1: 123*
    // state 2: 123*x
    // state 3: 123*x^456
    // state 4: 123^x
    int state = 0;

    // Control bits for state machine:
    // bit 0: special action: stop recording base or exponent
    // bit 1: special action: start recording base or exponent
    // bits 4-7: if first column, specify how to calculate the derivative:
    //              3 - multiply the constant term by 0
    //              4 - divide x by x
    //              5 - divide x^n by x and multiply by n
    //              6 - multiply n^x by ln(n)
    // bits 4-7: if not first column, specify the next state
    //              (plus 3, to make the character printable)
    const char* control =
        "\x33\x30\x50\x43\x71"
        "\x73\x70\x50\x23\x21"
        "\x43\x40\x20\x23\x63"
        "\x53\x60\x20\x23\x21"
        "\x63\x70\x70\x23\x71";

    for (;;) {
        int c = *p++;

        // Convert a char to a category:
        // category 0: // - +
        // category 3: // *
        // category 2: // x
        // category 4: // ^
        // category 1: // numbers: 0...9 and decimal point
        int category;
        int action;    

        if (q == '^' && c == '-')
            category = 1; // unary minus is a part of a number
        else
            category = c%26==16?c%16/3:c/46; // just does it

        // Load new state and action to do
        action = control[state * 5 + category];

        if (action & 1)
            p[-1] = 0;
        state = (action >> 4) - 3;
        if (category == 0)
        {
            if (state == 0)
                printf("*0");
            if (state == 1)
                printf("/x");
            if (state == 2)
                printf("/x*%s", exp);
            if (state == 3)
                printf("*ln(%s)", exp);
            state = 0;
        }
        if (action & 2)
            exp = p;

        if (c == 0 || c == '\n') // either of these can mark end of input
            break;

        putchar(c);
        q = c;
    }
}

पुनश्च उस getsसमारोह के लिए बाहर देखो : यह एक सुरक्षा भेद्यता है जो आपके शिक्षक को बहुत लंबे समय तक प्रदान करके आपके दिमाग में एक रूटकिट निष्पादित कर सकता है:

Answer 6

लुआ 296 268 263

function d(a)l=""i=a:find"x" if i then if a:sub(i-1,i-1)=="^"then l="log("..a:sub(1,i-2)..")*"..a elseif a:sub(i+1,i+1)=="^"then l=a:sub(i+2).."*"..a:sub(1,i)p=a:sub(i+2)-1 if p~=1 then l= l..a:sub(i+1,i+1)..p end else l=a:sub(1,i-2)end else l="0"end return l end

बहुत गोल्फ नहीं है और वर्तमान में कई शर्तों को संभाल नहीं सकता है (आप इसे केवल कुछ बार, सही तरीके से चला सकते हैं?), लेकिन यह संभाल सकता है n^x, x^nऔर nइनपुट के रूप में।

---

Ungolfed ...

function d(a)
   l=""
   i=a:find"x"
   if i then
      if a:sub(i-1,i-1)=="^" then
         l="log("..a:sub(1,i-2)..")*"..a
      elseif a:sub(i+1,i+1)=="^" then
         l=a:sub(i+2).."*"..a:sub(1,i)
         p=a:sub(i+2)-1 -- this actually does math here
         if p~=1 then
            l= l..a:sub(i+1,i+1)..p
         end
      else
         l=a:sub(1,i-2)
      end
   else
      l="0"
   end
   return l
end

Comments

str.func(str,...)== str:func(...), इसीलिए तार को सब के बाद मिलाप हुआ ...

— maniip

@ मिनीप: अभी भी लुआ सीख रहा है। पारितोषिक के लिए धन्यवाद।

— काइल कानोस

चूंकि ओपी केवल कोड की तलाश में है "वह अपने सिर में गणना कर सकता है", मैं एक फ़ंक्शन को परिभाषित करने और lस्थानीय घोषित करने से परेशान नहीं होता । बस उम्मीद है कि इनपुट को स्टोर किया जाएगा aऔर कहा जाएगा कि आउटपुट को स्टोर किया जाएगा l।

— मार्टिन एंडर

आप कोष्ठक को छोड़ सकते हैं a:find("x"), यह भी ध्यान दें कि 1then

— मनिप

@mniip: वाह, यह बहुत अच्छा है कि ()वैकल्पिक है। 1thenबस के रूप में मैं 5.2 की जरूरत नहीं है (किसी भी सीपीयू अपडेट होने तक शोध प्रबंध के बाद बी / सी मैं गड़बड़ कुछ भी नहीं करना चाहते किया जाता है नहीं कर रहा) तय हुई थी।

— काइल कानोस

Answer 7

ECMAScript 6, 127 बाइट्स

यहाँ मेरा रेगेक्स प्रयास है (रिप्लेसमेंट कॉलबैक में एकल रेगेक्स और कुछ तर्क का उपयोग करके):

i.replace(/(^|[*+-])(\d+|(?:([\d.]+)\^)?(x)(?:\^(-?[\d.]+))?)(?![.*^])/g,(m,s,a,b,x,e)=>s+(b?'ln'+b+'*'+a:e?e--+'*x^'+e:x?1:0))

यह इनपुट स्ट्रिंग को संग्रहीत करने की अपेक्षा करता है iऔर बस परिणाम देता है। ECMAScript 6 अनुरूप कंसोल (जैसे फ़ायरफ़ॉक्स) में इसे आज़माएँ।

Answer 8

सेड, ११०

बहुत ही शाब्दिक रूप से "उन्हें बिल्कुल भी सरल बनाने की आवश्यकता नहीं है या जैसा कि ऊपर दिखाया गया है, जब तक कि यह स्पष्ट नहीं है कि प्रारूप क्या कह रहा है,":

s/.*/__&_/;s/x\^(-?[0-9.]+)/\1*x^(\1-1)/g;s/([0-9.]+)\^/ln\1*\1^/g;s/([^(][-+_])[0-9.]+([-+_])/\10\2/g;s/_//g

बाइट की गिनती में rध्वज के लिए 1 शामिल है ।

टिप्पणियों के साथ असंगठित:

# Add underscores before and after the string, to help with solo-constant recognition
s/.*/__&_/
# Power rule: replace x^c with c*x^(c-1) where c is a number
s/x\^(-?[0-9.]+)/\1*x^(\1-1)/g
# Exponentials: replace c^ with lnc*c^ where c is a number
# (This assumes that there will be an x after the ^)
s/([0-9.]+)\^/ln\1*\1^/g
# Constants: replace ?c? with ?0? where c is a number and ? is +, -, or _
# Except if it's prededed by a parenthesis then don't, because this matches c*x^(c-1)!
s/([^(][-+_])[0-9.]+([-+_])/\10\2/g
# Get rid of the underscores
s/_//g

नमूना रन:

$ cat derivatives.txt
-3
8.5
x^0.5
x^-7
0.5^x
7^x
3*x^5
-0.1*0.3^x
-5*x^2+10-3^x

$ sed -re 's/.*/__&_/;s/x\^(-?[0-9.]+)/\1*x^(\1-1)/g;s/([0-9.]+)\^/ln\1*\1^/g;s/([^(][-+_])[0-9.]+([-+_])/\10\2/g;s/_//g' derivatives.txt
-0
0
0.5*x^(0.5-1)
-7*x^(-7-1)
ln0.5*0.5^x
ln7*7^x
3*5*x^(5-1)
-0.1*ln0.3*0.3^x
-5*2*x^(2-1)+0-ln3*3^x

मुझे यकीन है कि इसे और आगे बढ़ाया जा सकता है; यह मेरी पहली कोशिश है sed। आनंद!

Answer 9

रूबी, 152

... या 150 अगर आपको प्रिंट करने की आवश्यकता नहीं है ... या 147 यदि आप भी एक सरणी के साथ ठीक हैं, जिसे आपको खुद से जुड़ने की आवश्यकता है।

साथ दौड़ो ruby -nal

p gsub(/(?<!\^)([-+])/,'#\1').split(?#).map{|s|s[/x\^/]?$`+$'+"x^(#{$'}-1)":s[/-?(.*)\^(.*)x/]?s+"*ln(#{$1}*#{$2[0]?$2:1})":s[/\*?x/]?($`[0]?$`:1):p}*''

ungolfed:

p gsub(/(?<!\^)([-+])/,'#\1').split(?#). # insert a # between each additive piece, and then split.
map{ |s|                                 
    if s[/x\^/]                          # if it's c*x^a
        $` + $' + "x^(#{$'}-1)"          #      return c*ax^(a-1)
    elsif s[/-?(.*)\^(.*)x/]             # if it's c*b^(a*x)
        ln = $1 + ?* + ($2[0] ? $2 : 1)  #      return c*b^(a*x)*ln(b*a)
        s+"*ln(#{ln})"
    elsif s[/\*?x/]                      # if it's c*x
        ($`[0] ? $` : 1)                 #      return c
    else                                 # else (constant)
        nil                              #      return nil
    end
}*''

इस एक के साथ मेरी मुख्य समस्या यह है कि उचित विभाजन वाले पात्रों की संख्या कितनी है। केवल एक और तरीका है split(/(?<!\^)([-+])/)जिसके बारे में मैं सोच सकता था वह है +और -उनके अपने परिणाम। एक बेहतर समाधान के लिए कोई संकेत?

इसके अलावा, sअगर यह खाली नहीं है, तो लौटने का एक छोटा तरीका है , लेकिन अन्यथा वापस लौटें y? मैंने उपयोग किया है s[0]?y:s? जेएस में मैं बस करूँगा s||y, लेकिन ""रूबी में सच्चाई है।

Comments

क्या ऐसा दिखने में मदद मिलेगी split(/(?<!\^)(?=[-+])/)?

— DLosc