9

इस चुनौती का लक्ष्य फॉर्म एफ ⁽ⁿ⁾ (x) = c के अंतर समीकरण के हल का अनुमान लगाने के लिए यूलर की विधि का उपयोग करना है । ^†

इनपुट पूर्णांकों की एक सूची होगी जिसमें n वें मान f ⁽ⁿ⁾ (0) के मान को दर्शाता है । पहला पूर्णांक f (0), दूसरा f '(0) है, और इसी तरह। इस सूची में अंतिम पूर्णांक स्थिर है और हमेशा समान रहेगा।

इनपुट के रूप में प्रदान किया जाने वाला एक धनात्मक (नॉनजेरो) पूर्णांक x होगा , जो लक्ष्य मान का प्रतिनिधित्व करता है (आप f (x) का अनुमान लगाने का प्रयास कर रहे हैं)। यूलर की विधि का चरण आकार हमेशा 1 होगा। इस प्रकार, आपको कुल x कदम उठाने होंगे।

यदि आप यूलर की विधि से अपरिचित हैं, तो इनपुट के लिए स्पष्टीकरण के साथ यहां एक विस्तृत उदाहरण है [4, -5, 3, -1], x = 8।

x       f(x)      f'(x)     f''(x)    f'''(x)
0          4         -5          3         -1
1   4-5 = -1  -5+3 = -2   3-1 =  2         -1
2  -1-2 = -3  -2+2 =  0   2-1 =  1         -1
3  -3+0 = -3   0+1 =  1   1-1 =  0         -1
4  -3+1 = -2   1+0 =  1   0-1 = -1         -1
5  -2+1 = -1   1-1 =  0  -1-1 = -2         -1
6  -1+0 = -1   0-2 = -2  -2-1 = -3         -1
7  -1-2 = -3  -2-3 = -5  -3-1 = -4         -1
8  -3-5 = -8

अनिवार्य रूप से, उत्पन्न तालिका में प्रत्येक कोशिका उसके ऊपर और ऊपर और दाईं ओर सेल का योग है। तो, एफ (ए) = एफ (ए -1) + एफ '(ए -1); f '(a) = f' (a-1) + f '' (a-1); और f '' (a) = f '(a-1) + f' '' (a-1)। अंतिम उत्तर f (8) answer -8 है। ^††

इनपुट सूची में हमेशा 2 या अधिक तत्व होंगे, जिनमें से सभी में 10. x is 1 से कम पूर्ण मान होंगे, इसकी भी गारंटी है। आउटपुट एक पूर्णांक है, एफ (एक्स) का अनुमान। इनपुट या तो आदेश (से पहले सूची में लिया जा सकता है एक्स , या एक्स सूची से पहले)। यदि वांछित हो तो x भी सूची का पहला या अंतिम तत्व हो सकता है।

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

[4, -5, 3, -1], x = 8 => -8
[1, 2, 3, 4, 5, 6], x = 10 => 3198
[1, 3, 3, 7], x = 20 => 8611
[-3, 3, -3, 3, -3, 3, -3, 3, -3], x = 15 => -9009
[1, 1], x = 1 => 2

^{Not: यह उल्लेखनीय है कि इस स्थिति में एक सन्निकटन विधि का उपयोग करना, वास्तव में, बेवकूफ है। हालाँकि, इस चुनौती के प्रयोजनों के लिए सबसे सरल संभव कार्य चुना गया था।}

^{††: वास्तविक मूल्य -25 †† होता है, जो कि इस अनुमान को "बहुत अच्छा नहीं" कहेगा।}

— Doorknob
स्रोत

2

बहुत बारीकी से संबंधित

— पीटर टेलर

2

साथ ही बहुत करीबी संबंधित।

— xnor

3

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

l%n|n<1=l!!0|m<-n-1=l%m+tail(l++[0])%m

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

39 बाइट्स से बेहतर:

l%0=l!!0
l%n=l%(n-1)+tail(l++[0])%(n-1)

पुनरावर्ती रूप से आउटपुट को व्यक्त करता है l%n। ऊपर nबढ़ना डिक्रिमेंटिंग से मेल खाता है , और दाएं घूमने tail lसे सभी सूची तत्वों को एक स्थान छोड़ दिया गया है। तो, आउटपुट l%nऊपर मूल्य है l%(n-1), प्लस ऊपर और दाईं ओर मूल्य है(tail l)%(n-1)

आधार n==0सूची पहली सूची तत्व को लेना है।

आदर्श रूप से, इनपुट को अनंत रूप से कई शून्य के साथ दाईं ओर रखा जाएगा, क्योंकि एक बहुपद का व्युत्पत्ति अंततः शून्य होता है। 0जब हम लेते हैं तो हम इसे जोड़कर अनुकरण करते हैं tail।

अजीब कुल 41:

(iterate(\q l->q l+q(tail l++[0]))head!!)

— XNOR
स्रोत

3

MATL , 9 बाइट्स

:"TTZ+]1)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

:"      % Implicitly input x. Do the following x times
  TT    %   Push [1 1]
  Z+    %   Convolution, keeping size. Implicitly inputs array the first time
]       % End
1)      % Get first entry. Implictly display

— लुइस मेंडो
स्रोत

3

जेली , 6 5 बाइट्स

Ḋ+$¡Ḣ

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

-1 बाइट @ डॉकोर्नोब के लिए धन्यवाद

व्याख्या

Ḋ+$¡Ḣ  - Main dyadic link. First input list, second x
       - (implicit) on the previous iteration (starting at input list)
Ḋ      - Dequeue. e.g. [-5,3,-1]
 +     - Add this to
       - (implicit) the previous iteration. e.g. [4+(-5),-5+3,3+(-1),-1+0]
  $¡   - apply this successively x times
    Ḣ  - get the first element from the resultant list

— fireflame241
स्रोत

3

ब्रेकीलॉग , 13 12 बाइट्स

{,0s₂ᶠ+ᵐ}ⁱ⁾h

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

यह काम किस प्रकार करता है

{,0s₂ᶠ+ᵐ}ⁱ⁾h
{       }ⁱ⁾   iterate the previous predicate
              to the array specified by first element of input
              as many times as the second element of input
           h  and get the first element

              example input to predicate: [4, _5, 3, _1]
 ,0           append 0: [4, _5, 3, _1, 0]
   s₂ᶠ        find all substrings with length 2:
              [[4, _5], [_5, 3], [3, _1], [_1, 0]]
      +ᵐ      "add all the elements" mapped to each subarray:
              [_1, _2, _2, _1]

पिछला 13-बाइट समाधान

{b,0;?z+ᵐ}ⁱ⁾h

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

यह काम किस प्रकार करता है

{b,0;?z+ᵐ}ⁱ⁾h
{        }ⁱ⁾   iterate the previous predicate
               to the array specified by first element of input
               as many times as the second element of input
            h  and get the first element

               example input to predicate: [4, _5, 3, _1]
 b             remove the first element: [_5, 3, _1]
  ,0           append 0: [_5, 3, _1, 0]
    ;?         pair with input: [[_5, 3, _1, 0], [4, _5, 3, _1]]
      z        zip: [[_5, 4], [3, _5], [_1, 3], [0, _1]]
       +ᵐ      "add all the elements" mapped to each subarray:
               [_1, _2, _2, _1]

— लीक नन
स्रोत

2

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

#&@@Nest[#+Rest@#~Append~0&,##]&

                               &  make a pure function
    Nest[                 &,##]   call inner function as many times as specified
           Rest@#                 drop the first element of the list
                 ~Append~0        and add a 0 to get [b,c,d,0]
         #+                       add original list to get [a+b,b+c,c+d,d]
#&@@                              take the first element after x iterations

— Doorknob
स्रोत

2

पायथन , 80 58 बाइट्स

इस चुनौती के लिए गणित से प्यार करें।

f=lambda a,x:x and f(map(sum,zip(a,a[1:]+[0])),x-1)or a[0]

यह कैसे काम करता है (केवल अजगर 2 के साथ काम करता है):

f=lambda a,x:                                              - new lambda function
             x and                                         - iterate itself x times
                     map(sum,zip(a,a[1:]+[0]))             - e.g; f(a) = f(a-1) + f'(a-1)
                   f(                         ,x-1)        - iterate new array into itself
                                                   or a[0] - return first element

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

पास्कल त्रिकोण के उपयोग के साथ 100 बाइट वैकल्पिक

from math import factorial as F
f=lambda a,x:sum([(a+[0]*x)[i]*F(x)/(F(x-i)*F(i))for i in range(x)])

यह कैसे काम करता है (अजगर 2 और 3 के लिए काम करता है):

sum([                                                ]) - take the sum of array
     (a+[0]*x)                                        - append x zeros
              [i]*F(x)/(F(x-i)*F(i))                  - multiply each element by x choose i
                                    for i in range(x) - do this for every element

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

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

करने के लिए बिग धन्यवाद OVS एक पुनरावर्ती समारोह में पाश परिवर्तित करके 22 बाइट्स कम करने के लिए

— Graviton
स्रोत

यहाँ एक बेहतर संस्करण है। मैं एक पुनरावर्ती क्रिया करने के लिए पाश के लिए परिवर्तित

— OVS

आह, बहुत अच्छा विचार @ovs

— Graviton

यहां तक कि कम ध्यान दें कि यह केवल

— python2 के

1

हास्केल, 52 45 बाइट्स

l#n=iterate(zipWith(+)=<<tail.(++[0]))l!!n!!0

प्रयोग उदाहरण: [-3,3,-3,3,-3,3,-3,3,-3] # 15-> -9009। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

iterate(      )l          -- apply the function again and again starting with l
                          -- and collect the intermediate results in a list
                          -- the function is
          (++[0])         -- append a zero 
  zipWith(+)=<<tail       -- and build list of neighbor sums
                     !!0  -- take the first element from
                  !!n     -- the nth result

संपादित करें: @xnor ने 7 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

मुझे लगता है कि iterated फंक्शन हो सकता है zipWith(+)=<<tail.(++[0]), यानी बाद की बजाय पहले से सूची को ठीक कर लें।

— xnor

@xnor: हाँ, यह बहुत सारे बाइट्स बचाता है। धन्यवाद!

— nimi

मैं सिर्फ =<<यहाँ के उपयोग के आसपास अपने दिमाग को लपेट नहीं सकता , यह पागल है :)

— 17'17

@flawr: =<<फ़ंक्शन संदर्भ में उपयोग किया जाता है और इसे इस प्रकार परिभाषित किया जाता है (=<<) f g x = f (g x) x:। यहां हम =<<infix का उपयोग करते हैं: के (f =<< g) xसाथ f = zipWith(+)और g = tail, जो कि अनुवाद करता है zipWith(+) (tail x) x।

— nimi

विस्तृत विवरण के लिए धन्यवाद, मुझे फ़ंक्शन मोनाड के बारे में पता नहीं था!

— flawr

1

CJam , 12 बाइट्स

q~{_(;.+}*0=

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

व्याख्या

कोड सीधे चुनौती में वर्णित प्रक्रिया को लागू करता है।

q~            e# Read input and evaluate. Pushes the array and the number x
  {     }*    e# Do the following x times
   _          e# Duplicate array
    (;        e# Remove first element
      .+      e# Vectorized sum. The last element in the first array, which doesn't 
              e# have a corresponding entry in the second, will be left as is
          0=  e# Get first element. Implicitly display

— लुइस मेंडो
स्रोत

1

अजगर , 10 बाइट्स

s.e*b.cQkE

परीक्षण सूट।

यह काम किस प्रकार करता है

s.e*b.cQkE
 .e      E   for (b,k) in enumerated(array):
     .cQk        (input) choose (k)
   *b            * b
s            sum

— लीक नन
स्रोत

1

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

{0=⍺:⊃⍵
(⍺-1)∇(+/¨2,/⍵),¯1↑⍵}

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

यह एक पुनरावर्ती डीएफएन है, लेकिन यह बहुत अधिक क्रियाशील है। प्रगति में गोल्फ ...

— user41805
स्रोत

1

दरअसल , 7 बाइट्स

;lr(♀█*

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

यह काम किस प्रकार करता है

;lr(♀█*  input:
         8, [4, -5, 3, -1]
         top of stack at the right
;        duplicate
         8, [4, -5, 3, -1], [4, -5, 3, -1]
 l       length
         8, [4, -5, 3, -1], 4
  r      range
         8, [4, -5, 3, -1], [0, 1, 2, 3]
   (     rotate stack
         [4, -5, 3, -1], [0, 1, 2, 3], 8
    ♀█   map "n choose r"
         [4, -5, 3, -1], [1, 8, 28, 56]
      *  dot product
         -8

— लीक नन
स्रोत

1

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

@(a,x)conv(a,diag(flip(pascal(x+1))))(x+1)

यह एक अनाम फ़ंक्शन को परिभाषित करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

इनपुट सरणी और परिणामी सरणियों के साथ बार-बार समाधान करके समाधान की गणना की जा सकती है [1, 1]। लेकिन दो बार convolving, या तीन बार, या ... के साथ [1, 1]साथ एक बार convolving से मेल खाती है [1, 2 ,1], या [1, 3, 3, 1], या ...; यह पास्कल त्रिकोण की एक पंक्ति के साथ है। यह ऑर्डर के पास्कल मैट्रिक्स के विरोधी-विकर्ण के रूप में प्राप्त किया जाता है x+1।

— लुइस मेंडो
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 41 बाइट्स

f=(a,x,[b,...c]=a)=>x--?f(a,x)+f(c,x):b|0

पोर्ट ऑफ @ xnor का उत्कृष्ट हास्केल उत्तर। पिछला 47-बाइट समाधान।

f=(a,x)=>x--?f(a.map((e,i)=>e+~~a[i+1]),x):a[0]

— नील
स्रोत

0

पाइथन 3 के साथ नॉम्पी , 82 बाइट्स

import numpy
def f(a,x):
 for n in range(x):a=numpy.convolve(a,[1,1])
 return a[x]

मेरे MATL उत्तर के समान , लेकिन पूर्ण-आकार के कनवल्शन का उपयोग करते हुए, और इस प्रकार परिणाम xअंतिम सरणी का -th प्रविष्टि है।

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

— लुइस मेंडो
स्रोत

0

पायथन , 51 बाइट्स

f=lambda l,n:n and f(l,n-1)+f(l[1:]+[0],n-1)or l[0]

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

यह मेरे हास्केल उत्तर का एक बंदरगाह है ।

— XNOR
स्रोत

यूलर की विधि को लागू करें

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

MATL , 9 बाइट्स

व्याख्या

जेली , 6 5 बाइट्स

ब्रेकीलॉग , 13 12 बाइट्स

यह काम किस प्रकार करता है

पिछला 13-बाइट समाधान

यह काम किस प्रकार करता है

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

पायथन , 80 58 बाइट्स

हास्केल, 52 45 बाइट्स

CJam , 12 बाइट्स

व्याख्या

अजगर , 10 बाइट्स

यह काम किस प्रकार करता है

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

दरअसल , 7 बाइट्स

यह काम किस प्रकार करता है

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

व्याख्या

जावास्क्रिप्ट (ईएस 6), 41 बाइट्स

पाइथन 3 के साथ नॉम्पी , 82 बाइट्स

पायथन , 51 बाइट्स