एक विशिष्ट मूल्य के लिए बहुपद के n-वें पुनरावृति की गणना करें; fⁿ (एक्स)

19

एक बहुपद समारोह f ( आरोही या अवरोही क्रम में वास्तविक गुणांक की सूची p के रूप में), एक गैर-नकारात्मक पूर्णांक n , और एक वास्तविक मान x , वापसी:

   f  n ( x )

यानी x पर f के n अनुप्रयोगों के लिए f ( f ( f (… f ( x )…))) का मान ।

उचित परिशुद्धता और गोलाई का उपयोग करें।

गुणांक की सूची के रूप में एफ लेने वाले समाधान संभवतः सबसे दिलचस्प होंगे, लेकिन अगर आप वास्तविक कार्य के रूप में एफ लेने में सक्षम हैं (जिससे तुच्छ "इस फ़ंक्शन को लागू करने के लिए चुनौती को कम करने के लिए एन बार लागू करें "), इसे शामिल करने के लिए स्वतंत्र महसूस करें। अपने गैर तुच्छ समाधान के बाद।

उदाहरण के मामले

p  = [1,0,0]या f  = x^2,  n  = 0,  x  = 3:  f  0 (3) =3

p  = [1,0,0]या f  = x^2,  n  = 1,  x  = 3:  f  1 (3) =9

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 0,  x  = 2.3:  f  0 (2.3) =2.3

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 1,  x  = 2.3:  f  1 (2.3) =-8.761

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 2,  x  = 2.3:  f  2 (2.3) =23.8258

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 3,  x  = 2.3:  f  3 (2.3) =-2.03244

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 4,  x  = 2.3:  f  4 (2.3) =1.08768

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 5,  x  = 2.3:  f  5 (2.3) =-6.38336

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 6,  x  = 2.3:  f  6 (2.3) =14.7565

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 7,  x  = 2.3:  f  7 (2.3) =-16.1645

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 8,  x  = 2.3:  f  8 (2.3) =59.3077

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 9,  x  = 2.3:  f  9 (2.3) =211.333

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 10,  x  = 2.3:  f  10 (2.3) =3976.08

p  = [0.1,-2.3,-4]या f  = 0.1x^2-2.3x-4,  n  = 11,  x  = 2.3:  f  11 (2.3) =1571775

p  = [-0.1,2.3,4]या f  = −0.1x^2+2.3x+4,  n  = 0,  x  = -1.1:  f  0 (-1.1) =-1.1

p  = [-0.1,2.3,4]या f  = −0.1x^2+2.3x+4,  n  = 1,  x  = -1.1:  f  1 (-1.1) =1.349

p  = [-0.1,2.3,4]या f  = −0.1x^2+2.3x+4,  n  = 2,  x  = -1.1:  f  2 (-1.1) =6.92072

p  = [-0.1,2.3,4]या f  = −0.1x^2+2.3x+4,  n  = 14,  x  = -1.1:  f  14 (-1.1) =15.6131

p  = [0.02,0,0,0,-0.05]या f  = 0.02x^4-0.05,  n  = 25,  x  = 0.1:  f  25 (0.1) =-0.0499999

p  = [0.02,0,-0.01,0,-0.05]या f  = 0.02x^4-0.01x^2-0.05,  n  = 100,  x  = 0.1:  f  100 (0.1) =-0.0500249

code-golf  math  sequence  polynomials 
— एडम
स्रोत
— Adám
क्या मेरा जेली जवाब जेली लिंक ले सकता है और इसे "फ़ंक्शन" मान सकता है, उदाहरण के लिए?
— आउटगॉल्फ
@EriktheOutgolfer मुझे मूल रूप से ऐसे तुच्छ समाधानों को रोकने के लिए गुणांक की सूची के रूप में इनपुट की आवश्यकता थी। हालाँकि, मैंने अनुरोध करके इसे आराम दिया। मेरा सुझाव है कि आप सूची संस्करण पोस्ट करें, और एक नोट (या विपरीत) के रूप में तुच्छ संस्करण जोड़ें।
— Adám
मैंने पहले ही सूची संस्करण पोस्ट कर दिया है, लेकिन फ़ंक्शन संस्करण बहुत छोटा है।
— आउटगॉल्फ
@EriktheOutgolfer हाँ, जाहिर है। मेरा जोड़ा नोट देखें।
— अड्म

जवाबों:

7

ऑक्टेव , 49 बाइट्स

@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)

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

या, गुणांक लेने:

ऑक्टेव , 75 57 बाइट्स

@(p,x,n)(f=@(f,n){@()polyval(p,f(f,n-1)),x}{~n+1}())(f,n)

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

StackOverflow पर Suever के लिए एक विशेष धन्यवाद, इस जवाब के लिए कुछ समय पहले मेरे एक सवाल पर, यह साबित करते हुए कि एक पुनरावर्ती अनाम फ़ंक्शन संभव है।

यह एक अनाम फ़ंक्शन को परिभाषित करता है, जो एक पुनरावर्ती अनाम फ़ंक्शन के लिए एक आवरण है ; ऐसा कुछ जो देशी ऑक्टेव अवधारणा नहीं है, और इसके लिए कुछ फैंसी सेल ऐरे इंडेक्सिंग की आवश्यकता होती है।

एक बोनस के रूप में, दूसरा संस्करण ऑक्टेव में वेरिएबल स्कूपिंग में एक अच्छा सबक है। सभी उदाहरणों को rकानूनी रूप से प्रतिस्थापित किया जा सकता है f, जो तब मौजूदा fको सबसे अधिक स्थानीय दायरे (जैसे के लिए n) में ओवरराइट कर देता है

व्याख्या

@(p,x,n)(f=@(r,m){@()p(r(r,m-1)),x}{~m+1}())(f,n)
@(p,x,n)         .                ..    .  ..   .   % Defines main anonymous function    
        (f=@(r,m).                ..    .  ).   .   % Defines recursive anonymous function
                 .                ..    .   .   .   %  r: Handle ('pointer') to recursive function
                 .                ..    .   .   .   %  m: Current recursion depth (counting from n to 0)
                 .                ..    .   (f,n)   % And call it, with
                 .                ..    .           %  r=f (handle to itself)
                 .                ..    .           %  m=n (initial recursion)
                 {                }{    }           % Create and index into cell array
                                    ~m+1            %  Index: for m>0: 1; for m==0: 2.
                                ,x                  %  Index 2: final recursion, just return x.
                  @()                               %  Index 1: define anonymous function, taking no inputs.
                     p(        )                    %   which evaluates the polynomial 
                       r(     )                     %    of the recursive function call
                         r,m-1                      %     which is called with r 
                                                    %     and recursion depth m-1 
                                                    %     (until m=0, see above)
                                         ()         % Evaluate the result of the cell array indexing operation.
                                                    %  which is either the anonymous function
                                                    %  or the constant `x`.

इसकी कुंजी यह है कि जब वे परिभाषित होते हैं तो अनाम कार्यों का मूल्यांकन नहीं किया जाता है। इसलिए, @()जो थोड़ा सा अतिरंजित लगता है क्योंकि यह एक अनाम फ़ंक्शन को परिभाषित करता है जिसे ()सीधे बाद कहा जाता है , वास्तव में सख्ती से आवश्यक है। इसे तब तक नहीं कहा जाता है जब तक कि इसे अनुक्रमण कथन द्वारा नहीं चुना जाता है।

ऑक्टेव , 39 बाइट्स (उबाऊ तरीका)

function x=f(p,x,n)for i=1:n;o=p(o);end

बस पूर्णता के लिए, सबसे कम बायटेकाउंट के साथ ऑक्टेव समाधान। जम्हाई। ।

— Sanchises
स्रोत
मैं इसे एक और बार पुन: प्रयास करने की कोशिश करूँगा, लेकिन मुझे अभी भी यह नहीं मिला है .. एक बड़े ऑक्टेव प्रशंसक के रूप में मैं केवल यह कह सकता हूं, महान काम +1।
— माइकल
2
@ मिचथन ने कोशिश की और बेहतर व्याख्या करूंगा, लेकिन यह अब तक का सबसे ट्रेंड ऑक्टेव है, जो मैंने लिखा है - आमतौर पर, फंक्शन नाम बाइट काउंट के बहुमत होते हैं। यह लगभग लिस्प है।
— Sanchises
1
@ मिचन को उम्मीद है, नई व्याख्या कुछ समझ में आती है, इसे एक 'विस्फोट' दृश्य में देख रही है।
— Sanchises
4

मेथेमेटिका, 56 47 28 बाइट्स

Nest[x\[Function]x#+#2&~Fold~#,##2]&

\[Function] UTF-8 में 3 बाइट्स लेता है।

क्रम में पैरामीटर लें p,x,n।

p (पैरामीटर 1) डिग्री के बढ़ते क्रम में है।

जाहिर है अगर fइसे एक फंक्शन के रूप में लिया जा सकता है तो इसे कम किया जा सकता है Nest।

— user202729
स्रोत
क्या आपको गुणांक को उलटने की आवश्यकता है?
— Giuseppe
@Giuseppe इसीलिए Reverseकोड में है।
— user202729
@ user202729 मुझे लगता है कि आप जिस भी क्रम में चाहें, गुणांक ले सकते हैं, या तो आरोही या अवरोही।
— आउटगॉल्फ
मेरा मानना ​​है कि उन्हें डिग्री के बढ़ते या घटते क्रम में ले जाने की अनुमति है। (मैं गणितज्ञ को बिल्कुल नहीं जानता)
— Giuseppe
हां, आप उन्हें वांछित क्रम में ले जा सकते हैं: आरोही या अवरोही क्रम में
— Adám
4

भूसी , 5 बाइट्स

←↓¡`B

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

यहाँ मुख्य विचार यह है कि एक बिंदु x पर एक बहुपद का मूल्यांकन आधार x से आधार रूपांतरण करने के बराबर है ।

Bजब आधार दिया जाता है और अंकों की सूची आधार रूपांतरण करती है। यहां हम इसके फ़्लिप किए गए संस्करण का उपयोग करते हैं, ताकि पहले अंकों की सूची ले सकें और आंशिक रूप से इस फ़ंक्शन को उस पर लागू कर सकें। हम तब एक फ़ंक्शन प्राप्त करते हैं जो एक बिंदु पर दिए गए बहुपद के मूल्य की गणना करता है, इस समाधान का दूसरा भाग इस फ़ंक्शन को सही मात्रा में पुनरावृत्त करने से संबंधित है:

भूसी , 3 बाइट्स

←↓¡

¡ "iterate" फ़ंक्शन है, यह एक फ़ंक्शन और एक प्रारंभिक बिंदु लेता है और फ़ंक्शन को पुनरावृत्त करने वाले प्राप्त मूल्यों की अनंत सूची देता है।

↓ एक संख्या (इस चुनौती का तीसरा तर्क) लेता है और सूची की शुरुआत से कई तत्वों को छोड़ देता है।

← परिणामी सूची का पहला तत्व देता है।

— सिंह
स्रोत
3

रूबी , 42 बाइट्स

->c,n,x{n.times{x=c.reduce{|s,r|s*x+r}};x}

C अवरोही क्रम में गुणांक की सूची है

तुच्छ संस्करण, जहां एफ एक लंबो फ़ंक्शन ( 26 बाइट्स ) है:

->f,n,x{n.times{x=f[x]};x}

# For example:
# g=->f,n,x{n.times{x=f[x]};x}
# p g[->x{0.02*x**4-0.01*x**2-0.05},100,0.1]

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

— जीबी
स्रोत
3

जावास्क्रिप्ट (ईएस 6),  52 49 44  42 बाइट्स

जीबी के लिए 5 बाइट्स और 2 और बाइट्स धन्यवाद नील को बचा लिया

वाक्य रचना currying के रूप में इनपुट लेता है (p)(n)(x), जहां पी अवरोही क्रम में गुणांकों की सूची है।

p=>n=>g=x=>n--?g(p.reduce((s,v)=>s*x+v)):x

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

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

— Arnauld
स्रोत
यदि पी अवरोही क्रम में है, तो आप s * x + v का उपयोग कम कर सकते हैं और i को अनदेखा कर सकते हैं।
— जीबी
उस मामले में, क्या आप ,0कम करने से चूक सकते हैं ?
— नील
@ नील अच्छा कैच। :-)
— अरनौलड
2

जे , 15 बाइट्स

0{(p.{.)^:(]{:)

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

बहुपद को आरोही शक्तियों के गुणांक की सूची के रूप में लेता है।

व्याख्या

0{(p.{.)^:(]{:)  Input: polynomial P (LHS), [x, n] (RHS)
            {:   Tail of [x, n], gets n
           ]     Right identity, passes n
  (    )^:       Repeat n times starting with g = [x, n]
     {.            Head of g
   p.              Evaluate P at that value
                   Return g = [P(head(g))]
0{               Return the value at index 0
— मील की दूरी पर
स्रोत
2

05AB1E , 10 9 बाइट्स

-1 बाइट थैंक्स टू एरिक द आउटगोलर

sF³gݨm*O

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

X को पहले तर्क के रूप में, n को दूसरे और p को तीसरे के रूप में आरोही क्रम में लेता है।

व्याख्या

sF³gݨm*O
s         # Forces the top two input arguments to get pushed and swaped on the stack
 F        # Do n times...
  ³        # Push the third input (the coefficients)
   g       # Get the length of that array...
    ݨ     # and create the range [0 ... length]
      m    # Take the result of the last iteration to these powers (it's just x for the first iteration)
       *   # Multiply the resuling array with the corresponding coefficients
         O # Sum the contents of the array
          # Implicit print
— Datboi
स्रोत
1
आप दूसरा निकाल सकते हैं ³।
— आउटगॉल्फ
यह (This is in case n is 0 so x is on the stack)भी गलत है, आपको अभी भी sगैर-शून्य n की आवश्यकता है।
— आउटगोल्फर
हाँ यह सच है। मैं जगह की तर्ज पर अधिक सोच रहा था ¹².with sतो यह एक बार में कम से कम पाश करने के लिए जरूरत के बिना ढेर 1 बाइट में किया करने के लिए एक्स धकेलने का काम हो जाता है। शायद कि बेहतर ^ ^ 'के लिए धन्यवाद देना चाहिए। -1 के लिए धन्यवाद!
— दत्ताबाई
मेरा मतलब था कि आपको अभी भी इसकी आवश्यकता होगी क्योंकि 05AB1E अंतर्निहित इनपुट के लिए अंतिम इनपुट का उपयोग करता है यदि सभी इनपुट पढ़े गए हैं।
— आउटगॉल्फ
" sF³gݨm³O" और स्पष्टीकरण में भी ...
— निकले हुए ऑगेलफेर
2

हास्केल , 15 बाइट्स

((!!).).iterate

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

दोनों समाधान से 11 बाइट्स के लिए पूरी तरह से अमानवीय के लिए धन्यवाद

यह एक टासिट फ़ंक्शन को परिभाषित करता है जो एक फ़ंक्शन को उसके पहले तर्क के nरूप में और दूसरे तर्क के रूप में लेता है , और उस फ़ंक्शन को स्वयं के nसमय के साथ बनाता है । फिर इसे xअंतिम मान प्राप्त करने के लिए एक तर्क के साथ बुलाया जा सकता है । करीने के जादू के लिए धन्यवाद, यह तीन तर्कों को लेने वाले एक फ़ंक्शन के बराबर है।

एक फ़ंक्शन तर्क के बजाय गुणांक की सूची लेना:

हास्केल , 53 बाइट्स

((!!).).iterate.(\p x->sum$zipWith(*)p[x^i|i<-[0..]])

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

यह उपरोक्त कोड के समान है, लेकिन लैम्बडा फ़ंक्शन से बना है जो गुणांक की एक सूची को एक बहुपद समारोह में परिवर्तित करता है। गुणांकों को उदाहरणों से रिवर्स ऑर्डर में लिया जाता है - के रूप में आरोही शक्तियों x।

— मै जाऊं
स्रोत
1
— पूरी तरह से
दूसरे के TIO को एक तर्क के रूप में एक सूची लेनी चाहिए, एक फ़ंक्शन नहीं;) हालांकि आप इस तरह से एक गुना का उपयोग करके मुट्ठी भर बाइट्स को बचा सकते हैं (ध्यान दें कि शून्य-बहुपद नहीं हो सकता है []लेकिन ऐसा कुछ [0]या समान होना चाहिए )।
— ।
2

एपीएल (डायलॉग) , 20 9 बाइट्स

{⊥∘⍵⍣⎕⊢⍺}

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

यह xबाएं तर्क, फ़ंक्शन के गुणांकों को सही तर्क के रूप में लेता है, और nएसटीडीआईएन से।

लंबे समय के बाद इस पर पीछे मुड़कर, मुझे एहसास हुआ कि मैं आधार रूपांतरण का उपयोग करके गणना को सरल बना सकता हूं ⊥।

APL (Dyalog), 5 बाइट्स

यदि हम फ़ंक्शन को Dyalog APL फ़ंक्शन के रूप में ले सकते हैं, तो यह 5 बाइट्स हो सकता है।

⎕⍣⎕⊢⎕

लेता है x, nऔर फिर STDIN से इनपुट के रूप में कार्य करता है।

— क्रिक्टी लिथोस
स्रोत
2

आर , 96 58 55 52 बाइट्स

f=function(n,p,x)`if`(n,f(n-1,p,x^(seq(p)-1)%*%p),x)

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

स्पष्टीकरण:

seq(p)सूची उत्पन्न करता है 1, 2, ..., length(p)जब p, एक वेक्टर है इसलिए seq(p)-1, बहुपद का घातांक है इसलिए x^(seq(p)-1)के बराबर है x^0(हमेशा 1 के बराबर) , x^1, x^2, ...और एक डॉट उत्पाद कंप्यूटिंग %*%के साथ pमूल्यांकन करता है पर बहुपद x।

इसके अतिरिक्त, यदि Pइसे एक फ़ंक्शन के रूप में लिया जाता है, तो यह 38 बाइट्स होगा:

function(n,P,x)`if`(n,f(n-1,P,P(x)),x)

और हम निश्चित रूप से हमेशा उत्पन्न कर सकते हैं Pद्वाराP=function(a)function(x)sum(x^(seq(a)-1)*a)

— ग्यूसेप
स्रोत
1

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

*⁹LḶ¤×⁹Sµ¡

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

इस क्रम में x, गुणांक को आरोही क्रम में ले जाता है।

4 निवाले

⁹v$¡

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

इस क्रम में x, जेली लिंक (उद्धृत / बच जाने की आवश्यकता हो सकती है), n।

— आउटग्रॉफर को एरिक करें
स्रोत
1

सी # (.NET कोर) , 82 बाइट्स

using System.Linq;f=(p,n,x)=>n<1?x:p.Select((c,i)=>c*Math.Pow(f(p,n-1,x),i)).Sum()

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

परीक्षण मामलों (विपरीत क्रम?) से विपरीत क्रम में गुणांक की एक सूची बनाता है ताकि सरणी में उनका सूचकांक शक्ति x के बराबर हो।

और 30 बाइट्स में तुच्छ संस्करण:

f=(p,n,x)=>n<1?x:f(p,n-1,p(x))

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

एक प्रतिनिधि लेता है और इसे पुन: लागू करता है n बार।

— कामिल दकरी
स्रोत
1

MATL , 11 बाइट्स

ii:"ZQ6Mw]&

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

मेरे ऑक्टेव उत्तर की तुलना में थोड़ा कम दिलचस्प है, हालांकि मुझे लगता है कि n=0उम्मीद के मुताबिक काम करने के लिए इनपुट के कुछ चतुर करतब हैं ।

— Sanchises
स्रोत
1

जूलिया 0.6.0 (78 बाइट्स)

using Polynomials;g(a,n,x)=(p=Poly(a);(n>0&&(return g(a,n-1,p(x)))||return x))

explainations:

पैकेज बहुपद बहुत आत्म व्याख्यात्मक है: यह बहुपद बनाता है। उसके बाद यह एक बहुत ही बुनियादी पुनरावृत्ति है।

बहुपद होने के लिए: -4.0 - 2.3 * x + 0.1 * x ^ 2 इनपुट aजैसा होना चाहिएa = [-4, -2.3, 0.1]

— Goysa
स्रोत
1

Axiom, 91 बाइट्स

f(n,g,x)==(for i in 1..n repeat(v:=1;r:=0;for j in 1..#g repeat(r:=r+v*g.j;v:=v*x);x:=r);x)

दांतेदार बना हुआ

fn(n,g,x)==
     for i in 1..n repeat
          v:=1; r:=0
          for j in 1..#g repeat(r:=r+v*g.j;v:=v*x)
          x:=r
     x

पोलिनेमी जी के लिए इनपुट यह व्यायाम के उदाहरण के विपरीत संख्याओं की एक सूची है। उदाहरण के लिए

[1,2,3,4,5]

यह पोलिनेमी का प्रतिनिधित्व करेगा

1+2*x+3*x^2+4*x^3+5*x^4

परीक्षा:

(3) -> f(0,[0,0,1],3)
   (3)  3
                                                    Type: PositiveInteger
(4) -> f(1,[0,0,1],3)
   (4)  9
                                                    Type: PositiveInteger
(5) -> f(0,[-4,-2.30,0.1],2.3)
   (5)  2.3
                                                              Type: Float
(6) -> f(1,[-4,-2.30,0.1],2.3)
   (6)  - 8.7610000000 000000001
                                                              Type: Float
(7) -> f(2,[-4,-2.30,0.1],2.3)
   (7)  23.8258121
                                                              Type: Float
(8) -> f(9,[-4,-2.30,0.1],2.3)
   (8)  211.3326335688 2052491
                                                              Type: Float
(9) -> f(9,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (9)  0.4224800431 1790652974 E 14531759
                                                              Type: Float
                                   Time: 0.03 (EV) + 0.12 (OT) = 0.15 sec
(10) -> f(2,[-4,-2.30,0.1,0,0,0,0,1],2.3)
   (10)  44199336 8495528344.36
                                                              Type: Float
— RosLuP
स्रोत
1

सी ++ 14, 71 बाइट्स

सामान्य अनाम लंबोदर के रूप में, xपैरामीटर के माध्यम से लौटते हुए :

[](auto C,int n,auto&x){for(auto t=x;t=0,n--;x=t)for(auto a:C)t=a+x*t;}

अघोषित और टेस्टकेस:

#include<iostream>
#include<vector>

using namespace std;

auto f=
[](auto C,int n,auto&x){
 for(
  auto t=x; //init temporary to same type as x
  t=0, n--; //=0 at loop start, also check n
  x=t       //apply the result
  )
  for(auto a:C)
   t=a+x*t; //Horner-Scheme
}
;


int main() {
 vector<double> C = {0.1,-2.3,-4};//{1,0,0};
 for (int i = 0; i < 10; ++i) {
  double x=2.3;
  f(C, i, x);
  cout << i << ": " << x << endl;
 }
}
— कार्ल नेफ
स्रोत
0

QBIC , 19 बाइट्स

[:|:=:*c^2+:*c+:}?c

इनपुट के रूप में लेता है

  • पुनरावृत्तियों की संख्या
  • x का आरंभिक मूल्य
  • फिर बहुपद के 3 भाग

नमूना उत्पादन:

Command line: 8 2.3 0.1 -2.3 -4
 59.30772
— steenbergh
स्रोत
0

क्लोजर, 66 बाइट्स

#(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%)

पूर्ण उदाहरण:

(def f #(nth(iterate(fn[v](apply +(map *(iterate(partial * v)1)%3)))%2)%))
(f 10 2.3 [-4 -2.3 0.1])
; 3976.0831439050253

एक समारोह की रचना 26 बाइट्स है:

#(apply comp(repeat % %2))

(def f #(apply comp(repeat % %2)))
((f 10 #(apply + (map * [-4 -2.3 0.1] (iterate (partial * %) 1)))) 2.3)
; 3976.0831439050253
— NikoNyrh
स्रोत
0

जाप , 18 बाइट्स

बहुत सीधा, टिन पर चुनौती क्या कहता है।

o r_VË*ZpVÊ-EÉÃx}W
o                  // Take `n` and turn it into a range [0,n).
  r_            }W // Reduce over the range with initial value of `x`.
    VË             // On each iteration, map over `p`, yielding the item
      *Z           // times the current reduced value
        pVÊ-EÉ     // to the correct power,
              Ãx   // returning the sum of the results.

क्रम में आदानों ले जाता है n, p, x।

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

— लीख
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.