स्थानीय मैक्सिमा और मिनीमा का पता लगाएं

14

परिभाषा

किसी दिए गए फ़ंक्शन की मैक्सिमा और मिनीमा फ़ंक्शन के सबसे बड़े और सबसे छोटे मूल्य या तो दिए गए रेंज के भीतर या फ़ंक्शन के पूरे डोमेन के भीतर हैं।

चुनौती

किसी भी पद्धति का उपयोग करके किसी भी बहुपद समारोह के स्थानीय मैक्सिमा और मिनीमा को ढूंढना चुनौती है । चिंता न करें, मैं पूरी कोशिश करूंगा कि चुनौती को समझा जा सके और इसे यथासंभव सरल रखा जा सके।

इनपुट में एकल चर बहुपद के सभी गुणांकों में शक्ति का घटता या बढ़ता क्रम (आप तक) होता है। उदाहरण के लिए,

  • [3,-7,1] प्रतिनिधित्व करेंगे 3x2 - 7x + 1 = 0
  • [4,0,0,-3] प्रतिनिधित्व करेंगे 4x3-3=0.

कैसे हल करें (डेरिवेटिव का उपयोग करके)?

अब, मान लें कि हमारा इनपुट है [1,-12,45,8], जो फ़ंक्शन के अलावा कुछ भी नहीं है ।x3 - 12x2 + 45x + 8

  1. पहला कार्य उस फ़ंक्शन के व्युत्पन्न का पता लगाना है। चूंकि यह एक बहुपद समारोह है, इसलिए यह वास्तव में एक सरल कार्य है।

    का व्युत्पन्न है । किसी भी स्थिर शब्द के साथ मौजूद गुणन केवल गुणा किए जाते हैं। इसके अलावा, यदि शब्द जोड़े गए / घटाए गए हैं, तो उनके डेरिवेटिव को भी क्रमशः जोड़ा या घटाया जाता है। याद रखें, किसी भी स्थिर संख्यात्मक मान का व्युत्पन्न शून्य है। कुछ उदाहरण निम्नलिखित हैं:xnn*xn-1xn

    • x3 -> 3x2
    • 9x4 -> 9*4*x3 = 36x3
    • -5x2 -> -5*2*x = - 10x
    • 2x3 - 3x2 + 7x -> 6x2 - 6x + 7
    • 4x2 - 3 -> 8x - 0 = 8x

  2. अब नए बहुपद को शून्य से समीकरण को हल करें और केवल x के अभिन्न मान प्राप्त करें।

  3. मूल फ़ंक्शन में x के उन मानों को रखें और परिणाम लौटाएं। यही आउटपुट होना चाहिए ।

उदाहरण

आइए हम पहले बताए गए उदाहरण को लें, यानी [1,-12,45,8]।

  • इनपुट: [1,-12,45,8]
  • समारोह: x3 - 12x2 + 45x + 8
  • व्युत्पन्न -> 3x2 - 24x + 45 + 0 -> [3,-24,45]
  • समीकरण को हल करते हुए , हम प्राप्त करते हैं या ।3x2 - 24x + 45 = 0x = 3x = 5
  • अब डालते हैं x = 3और x = 5फ़ंक्शन में, हमें मान मिलते हैं (62,58)।
  • आउटपुट -> [62,58]

मान्यताओं

  1. मान लें कि सभी इनपुट गुणांक पूर्णांक हैं । वे शक्ति के बढ़ते या घटते क्रम में हो सकते हैं।

  2. इनपुट को कम से कम 2-डिग्री बहुपद मान लें । यदि बहुपद में पूर्णांक समाधान नहीं है, तो आप कुछ भी वापस कर सकते हैं।

  3. मान लें कि अंतिम परिणाम पूर्णांक ही होगा।

  4. आप किसी भी क्रम में परिणाम प्रिंट कर सकते हैं। इनपुट बहुपद की डिग्री 5 से अधिक नहीं होगी, ताकि आपका कोड इसे संभाल सके।

  5. इनपुट मान्य होगा ताकि x के समाधानों में काठी बिंदु न हों।

इसके अलावा, आप इसे व्युत्पन्न विधि से करने के लिए मजबूर नहीं हैं। आप अपनी इच्छानुसार किसी भी विधि का उपयोग कर सकते हैं

नमूना इनपुट और आउटपुट

[2,-8,0] -> (-8)
[2,3,-36,10] -> (91,-34)
[1,-8,22,-24,8] -> (-1,0,-1) 
[1,0,0] -> (0)

स्कोरिंग

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

code-golf  number  integer  polynomials  equation 
— मनीष कुंडू
स्रोत
1
अगर मैं सही ढंग से समझता हूं: उदाहरण में " सॉल्विंग समीकरण " कदम आंशिक रूप से आप की यह पिछली चुनौती होगी ? इसके अलावा, चरण " अब फ़ंक्शन में x = 3 और x = 5 डालते हैं " का अर्थ है " फ़ंक्शन " पर मूल फ़ंक्शन और " व्युत्पन्न " पर फ़ंक्शन नहीं , सही?
— केविन क्रूज़सेन
1
नमूना I / O 3 के लिए, मैं प्राप्त कर रहा हूं (-1, 0, 1), जो मुझे विश्वास है कि वास्तविक सही उत्तर है ... हालांकि निश्चित नहीं है। अगर आप मुझसे चैट में पिंग करते हैं तो आप मुझसे असहमत हैं।
— हायपरनेट्रिनो ३१'१r
1
The input will be valid so that the solutions of x are not saddle pointsमामला [1,0,0,3]एक काठी बिंदु देता है।
— जुन्गवान मिन
1
@JungHwanMin आह कि नियम बनाने से पहले उदाहरण जोड़ा गया था। अब निकाल दिया।
— मनीष कुंडू
1
x^3 - 12x^2 + 45x + 8 = 0 , हालांकि व्यक्तिगत रूप से मैं पसंद आप इसे के रूप में लिखने f(x)=x^3-12x^2+45x+8के बिना =0क्योंकि =0मतलब नहीं है, क्योंकि हम एक समारोह के साथ काम कर रहे हैं एक समीकरण को हल नहीं।
— वीजुन झोउ

जवाबों:

4

जेली , 20 बाइट्स

ASŒRḅ@Ðḟ
J’U×µṖÇḅ@€³

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

व्याख्या

ASŒRḅ@Ðḟ     Helper Function; find all integer solutions to a polynomial
             All integer roots are within the symmetric range of the sum of the absolute values of the coefficients
A            Absolute Value (Of Each)
 S           Sum
  ŒR         Symmetric Range; `n -> [-n, n]`
      Ðḟ     Filter; keep elements where the result is falsy for:
    ḅ@       Base conversion, which acts like the application of the polynomial
J’U×µṖÇḅ@€³  Main Link
J                             Range of length
 ’                    Lowered
  U          Reversed
   ×         Multiplied with the original list (last value is 0)
    µ        Begin new monadic chain
     Ṗ       Pop; all but the last element
      Ç      Apply last link (get all integer solutions of the derivative)
       ḅ@€³  Base conversion of the polynomial into each of the solutions; apply polynomial to each solution of the derivative.

इस कार्यक्रम में सहायक समारोह श्री Xcoder के यहाँ से लिया गया था जो लुइस के यहाँ उत्तर से दूर था

— HyperNeutrino
स्रोत
@JungHwanMin मैं बताता हूं कि ओपी को। यह इस कथन का सीधा उल्लंघन है कि इसमें कोई काठी बिंदु नहीं होगा क्योंकि बहुपद की व्युत्पत्ति इस समय 3है 0। संपादित करें ओह, आप पहले से ही nvm किया था सिर्फ टिप्पणी को
— उखाड़ फेंका
3

जावास्क्रिप्ट (ईएस 7), 129 120 बाइट्स

शक्ति के बढ़ते क्रम में गुणांक लेता है।

a=>(g=x=>x+k?(A=g(x-1),h=e=>a.reduce((s,n,i)=>s+n*(e||i&&i--)*x**i,0))()?A:[h(1),...A]:[])(k=Math.max(...a.map(n=>n*n)))

परीक्षण के मामलों

कोड स्निपेट दिखाएं

टिप्पणी की गई

a => (                        // given the input array a[]
  g = x =>                    // g = recursive function checking whether x is a solution
    x + k ? (                 //   if x != -k:
      A = g(x - 1),           //     A[] = result of a recursive call with x - 1
      h = e =>                //     h = function evaluating the polynomial:
        a.reduce((s, n, i) => //       for each coefficient n at position i:
          s +                 //         add to s
          n                   //         the coefficient multiplied by
          * (e || i && i--)   //         either 1 (if e = 1) or i (if e is undefined)
          * x**i,             //         multiplied by x**i or x**(i-1)
          0                   //         initial value of s
        )                     //       end of reduce()
      )() ?                   //     if h() is non-zero:
        A                     //       just return A[]
      :                       //     else:
        [h(1), ...A]          //       prepend h(1) to A[]
    :                         //   else:
      []                      //     stop recursion
  )(k = Math.max(             // initial call to g() with x = k = maximum of
    ...a.map(n => n * n)      // the squared coefficients of the polynomial
  ))                          // (Math.abs would be more efficient, but longer)
— Arnauld
स्रोत
1
के लिए विफल रहता है 0,0,1(x ^ 2 = 0)
— betseg
@betseg इसे रिपोर्ट करने के लिए धन्यवाद। फिक्स्ड।
— अरनौलद
3

जूलिया 0.6 ( Polynomialsपैकेज के साथ ), 57 बाइट्स

using Polynomials
x->map(Poly(x),roots(polyder(Poly(x))))

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

बढ़ते क्रम में गुणांक लेता है, यानी पहला इनपुट स्थिर शब्द है।

उदाहरण रन:

julia> using Polynomials

julia> g = x -> map(Poly(x), roots(polyder(Poly(x))))
(::#1) (generic function with 1 method)

julia> g([8,45,-12,1])
2-element Array{Float64,1}:
 58.0
 62.0
— Rɪᴋᴇʀ
स्रोत
3

जावा 8, 364 239 227 226 218 बाइट्स

a->{int l=a.length,A[]=a.clone(),s=0,i,r,f=l,p;for(;f>0;A[--f]*=f);for(int n:A)s+=n<0?-n:n;for(r=~s;r++<s;){for(p=0,i=f=1;i<l;f*=r)p+=A[i++]*f;if(p==0){for(f=i=0;i<l;f+=a[i++]*Math.pow(r,p++));System.out.println(f);}}}

मेरे इस जवाब से उसी कार्यक्षमता का उपयोग करता है।

-8 बाइट्स उल्टे क्रम में सरणी लेकर @ ओलिवियरग्रेगायर के लिए धन्यवाद ।

स्पष्टीकरण:

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

a->{                  // Method with integer-varargs parameter and integer return-type
  int l=a.length,     //  The length of the input-array
      A[]=a.clone(),  //  Copy of the input-array
      s=0,            //  Sum-integer, starting at 0
      i,              //  Index-integer
      r,              //  Range-integer
      f=l,            //  Factor-integer, starting at `l`
      p;              //  Polynomial-integer
  for(;f>0;           //  Loop over the copy-array
    A[--f]*=f);       //   And multiply each value with it's index
                      //   (i.e. [8,45,-12,1] becomes [0,45,-24,3])
  for(int n:A)        //  Loop over this copy-array:
    s+=n<0?-n:n;      //   And sum their absolute values
  for(r=~s;r++<s;){   //  Loop `r` from `-s` up to `s` (inclusive) (where `s` is the sum)
    for(p=0,          //   Reset `p` to 0
        i=f=1;        //   and `f` to 1
                      //   (`i` is 1 to skip the first item in the copy-array)
        i<l;          //   Inner loop over the input again, this time with index (`i`)
        f*=r)         //     After every iteration: multiply `f` with the current `r`
      p+=             //    Sum the Polynomial-integer `p` with:
         A[i++]       //     The value of the input at index `i`,
               *f;}   //     multiplied with the current factor `f`
    if(p==0){         //   If `p` is now 0:
      for(f=i=0;      //    Use `f` as sum, and reset it to 0
          i<l;        //    Loop over the input-array
        f+=a[i++]*Math.pow(r,p++));
                      //     Fill in `r` in the parts of the input-function
      System.out.println(f);}}}
                      //    And print the sum
— केविन क्रूज़सेन
स्रोत
2
के लिए विफल रहता है 1,0,0(x ^ 2 = 0)
— betseg
@betseg धन्यवाद! फिक्स्ड और गोल्फ।
— केविन क्रूज़सेन
1
आपको इस तरह अपनी गिनती कम करने के लिए इनपुट को उल्टे क्रम में स्वीकार करना चाहिए (यह स्पष्ट रूप से अनुमति है) int... ,i, ...; for(;f>0;)A[--f]*=f;। जब तक मैं गलत नहीं हूं, तब तक आपको कम से कम 4 बाइट बचानी चाहिए। यदि आप ऐसा करते हैं, तो इनपुट के लिए अपने सभी एक्सेस को पलटना सुनिश्चित करें।
— ओलिवियर ग्रेजायर 15
@ OlivierGrégoire धन्यवाद, 8 बाइट्स बचाए गए!
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.