आंशिक रूप से संक्रमित

23

पूर्णांकों की एक सूची के आंशिक योग [एक 1 , एक 2 , एक 3 , ..., एक एन ] कर रहे हैं

एस 1 = एक 1
रों 2 = एक 1 + एक 2
रों 3 = एक 1 + एक 2 + एक 3
...
रों n = एक 1 + एक 2 + ... + एक n

फिर हम आंशिक रकम [s 1 , s 2 , s 3 , ..., s n ] की सूची ले सकते हैं और एक नई सूची बनाने के लिए अपने आंशिक रकमों की फिर से गणना कर सकते हैं, और इसी तरह।

संबंधित: आगे के मतभेदों को दोहराया

इनपुट:

  • पूर्णांकों की एक गैर-रिक्त सूची
  • पुनरावृत्तियों की एक सकारात्मक संख्या,

आउटपुट: पूर्णांक की सूची को प्रिंट करें या वापस लौटाएं, जो कई बार आंशिक रकम लेने के परिणामस्वरूप होता है।

सबसे कम बाइट्स जीतता है। बिल्ट-इन ठीक हैं भले ही वे समस्या को हल कर दें।

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

f([-3, 4, 7, -1, 15], 1) == [-3, 1, 8, 7, 22]
f([-3, 4, 7, -1, 15], 3) == [-3, -5, 1, 14, 49]

लीडरबोर्ड:

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

code-golf  number  arithmetic  sequence  array-manipulation 
— XNOR
स्रोत
क्या तर्कों को उसी क्रम में होना चाहिए, या संख्याओं की सूची से पहले पुनरावृत्तियों की संख्या आ सकती है?
— kirbyfan64sos
@ kirbyfan64sos या तो आदेश।
— xnor

जवाबों:

14

जे, 5 बाइट्स

+/\^:

इसे जे जे पर ऑनलाइन प्रयास करें ।

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

  • /\ एक क्रियाविशेषण (फ़ंक्शन जो एक बाएं तर्क लेता है) जो संचयी रूप से अपने तर्क से कम करता है।

  • इस प्रकार +/\है संचयी योग क्रिया।

  • ^:है बिजली संयोजन ; कुल बार (f ^: n) yलागू होता fहै ।ny

  • क्रिया-संयोजन ट्रेन +/\^:एक क्रिया विशेषण बनाती है जो +/\अपने (बाएं) तर्क में निर्दिष्ट के रूप में कई बार दोहराता है।

    x (+/\^:) yके रूप में पार्स किया जाता है (x (+/\^:)) y, जो निष्पादन के बराबर है (+/\^:x) y।

स्पष्टीकरण के साथ उनकी मदद के लिए @Zgarb को धन्यवाद।

— डेनिस
स्रोत
13

मैथेमेटिका, 19 बाइट्स

ठीक है, अगर बिल्ट-इन ठीक है ...

Accumulate~Nest~##&

चुनौती में उदाहरण के रूप में एक ही हस्ताक्षर के साथ एक समारोह को परिभाषित करता है। मुझे पूरा यकीन है, लंबे नाम के लिए धन्यवाद Accumulateकि यह आसानी से गोल्फ भाषाओं और एपीएल-परिवार द्वारा पीटा जाएगा, हालांकि। :)

जो गणितज्ञ नहीं हैं उनके लिए LegionMammal978 की टिप्पणी पर विस्तार से:

##फ़ंक्शन के मापदंडों के एक अनुक्रम का प्रतिनिधित्व करता है (जो एक सूची की तरह है जो स्वचालित रूप से "छपता है" जहां कहीं भी डाला जाता है, यदि आप अपनी भाषा की पसंद से उस शब्द से अधिक परिचित हैं)। ~इन्फ़िक्स समारोह मंगलाचरण के लिए वाक्यात्मक चीनी हैं, इसलिए यदि हम मानकों के साथ फ़ंक्शन को कॉल करें listऔर nऔर सब कुछ का विस्तार, हम पाते हैं:

Accumulate~Nest~##
Nest[Accumulate, ##]
Nest[Accumulate, list, n]

जो ठीक उसी तरह से होता है जैसा कि तर्क द्वारा अपेक्षित होता है Nest।

— मार्टिन एंडर
स्रोत
यह दिलचस्प है, 3 तर्कों के लिए infix संकेतन का उपयोग करके SlotSequence...
— LegionMammal978
9

हास्केल, 26 23 बाइट्स

(!!).iterate(scanl1(+))

यह एक गुमनाम फंक्शन को परिभाषित करता है, जिसे निम्नानुसार किया गया है:

> let f = (!!).iterate(scanl1(+)) in f [-3,4,7,-1,15] 3
[-3,-5,1,14,49]

3 बाइट बचाने के लिए @nimi को धन्यवाद।

व्याख्या

(!!).                    -- Index by second argument from
     iterate(         )  -- the infinite list obtained by iterating
             scanl1(+)   -- the partial sums function (left scan by +) to first argument
— Zgarb
स्रोत
बहुत अच्छा! और स्पष्टीकरण के लिए धन्यवाद!
— जेक
2
बिंदु बिंदु पर जाएं, फिर आप फ़ंक्शन के लिए नाम भी छोड़ सकते हैं (!!).iterate(scanl1(+)):।
— नीमी
@ नमि धन्यवाद! किसी तरह मैंने तर्क दिया कि रचना यहाँ मेरे लाभ के लिए काम नहीं करेगी ...
— ज़र्गेब
9

एपीएल, ९ L बाइट्स

{+\⍣⍺⊢⍵}

यह एक डाइएडिक फ़ंक्शन को परिभाषित करता है जो पुनरावृत्तियों और सूची को बाएं और दाएं तर्कों के रूप में स्वीकार करता है।

1 बाइट को बंद करने के लिए @NBZ को धन्यवाद!

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

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

  • ⍺और ⍵फ़ंक्शन के लिए बाएँ और दाएँ तर्क हैं।

  • +\ राशि से संचयी कम है।

  • ⍣⍺पूर्ववर्ती ऑपरेटर ⍺बार दोहराता है ।

  • ⊢⍵के लिए पहचान समारोह लागू करता है ⍵।

    इस रूप में कोड पार्स करने का एक छोटा रास्ता है (+\⍣⍺)⍵बजाय +\⍣(⍺⍵)।

संयोजन के रूप में, हम +\कुल ⍺बार लागू होते हैं⍵

— डेनिस
स्रोत
@ अलेक्सा: फिर +\⍣⎕⊢⎕स्वीकार्य नहीं होगा? ( ⎕पायथन की तरह है input())।
— मारिनस
1
@marinus क्या वास्तव में एक REPL के बाहर प्रिंट करता है? मेरे पास केवल डेस्कटॉप दुभाषिए हैं जिन्हें ⎕बाद में असाइन करने की आवश्यकता होगी ।
— डेनिस
5

मतलाब, 41 बाइट्स

function f(l,n);for i=1:n;l=cumsum(l);end

काफी निष्कपट। मुझे अभी भी लगता है कि टुकड़ों में परिभाषित अनाम कार्यों, या पुनरावर्ती में लंगर बनाने के तरीके में बिल्ट न होना काफी कष्टप्रद है।

Ungolfed:

function f(l,n);
for i=1:n;
    l=cumsum(l);
end
— flawr
स्रोत
5

जावास्क्रिप्ट (ईएस 6) 38

आश्चर्यजनक रूप से छोटे .map का उपयोग करना

f=(l,n,t=0)=>n?f(l.map(x=>t+=x),n-1):l

function test()
{
  var n, v, i = I.value
  v = i.match(/\-?\d+/g).map(x=>+x)
  n = v.pop()
  console.log(v,n)
  O.innerHTML = I.value + ' -> ' + f(v,n) + '\n' + O.innerHTML;
}

test()
<input id=I value='[-3, 4, 7, -1, 15], 3'><button onclick="test()">-></button>
<pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
5

के, 7 3 बाइट्स

{y+\/x}

जे समाधान के समान। +\ठीक एक आंशिक राशि का प्रदर्शन करता है, और जब /एक मोनडिक क्रिया और एक पूर्णांक बाएं तर्क के साथ प्रदान किया जाता है , तो यह "लूप के लिए" की तरह, निर्दिष्ट संख्या को पुनरावृत्त करता है। बाकी सिर्फ तर्कों के क्रम के अनुरूप इसे बड़े करीने से लपेट रहा है।

  {y+\/x}[-3 4 7 -1 15;1]
-3 1 8 7 22
  {y+\/x}[-3 4 7 -1 15;3]
-3 -5 1 14 49

कोना और ओके में परीक्षण किया गया ।

संपादित करें:

अगर मुझे @ kirbyfan64sos निर्धारित किए गए तर्कों को उलटने की अनुमति है, तो मैं पूरी तरह से लपेटकर फ़ंक्शन के साथ वितरित कर सकता हूं:

+\/

जैसे आमंत्रित:

+\/[3;-3 4 7 -1 15]

यह k2.8 और k5 दोनों में ठीक से काम करता है। यह ओके में काम नहीं करता है क्योंकि दुभाषिया अभी तक करी (उर्फ "अनुमानित") क्रियाविशेषण का समर्थन नहीं करता है, और यह कम स्पष्ट कारणों के लिए Kona में ठीक से काम नहीं करता है।

संपादित करें : कुछ दिनों पहले, +\/ओके में भी सूत्रीकरण काम करता है।

— JohnE
स्रोत
1
तर्कों को उलटा किया जा सकता है , इसलिए मुझे लगता है कि आप कुछ बाइट्स शेव करने में सक्षम हो सकते हैं।
— kirbyfan64sos
3 +\/ -3 4 7 -1 15बस ठीक काम करता है Kona, लेकिन आप इसे एक फ़ंक्शन को असाइन नहीं कर सकते। अजीब ...
— डेनिस
हाँ, Kona स्पष्ट रूप 3+\/-3 4 7 -1 15से उसी के साथ व्यवहार नहीं कर रहा है +\/[3;-3 4 7 -1 15]- मुझे आश्चर्य होता है कि क्या वे पूर्व को एक विशेष वाक्यविन्यास मामले के रूप में संभालते हैं।
— जॉन
4

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

usM._GvwQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

व्याख्या

usM._GvwQ  implicit: Q = input list
      vw   input number
u       Q  repeat the following instruction ^ times to G = Q
   ._G        sequence of prefixes of G
 sM           sum them up
— Jakube
स्रोत
4

जूलिया, 29 बाइट्स

f(x,y)=y>0?f(cumsum(x),y-1):x

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

— ग्लेन हे
स्रोत
4

भूलभुलैया , 73 बाइट्स

;?
,"
;
#
#;}=
;  #
"#;(
_  ;={()"
#;; ( { "
  ; { !\(@
+=( =
" " "
":{:"

जब से मैंने भूलभुलैया में कुछ उत्तर दिया तब से कुछ समय हो गया है, और यह उल्लेखनीय लग रहा था। :)

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

3 | -3, 4, 7, -1, 15

आउटपुट न्यूलाइन-सेपरेटेड है:

-3
-5
1
14
49
— मार्टिन एंडर
स्रोत
4

आर, 75 बाइट्स

यह लंबा है, लेकिन एक अलग ले रहा है ... संचयी रकम के बजाय सीधे वांछित अनुक्रम की गणना करना:

function(x,n)sapply(1:length(x),function(i)sum(x[1:i]*choose(i:1+n-2,n-1)))

यह देखते हुए कि कम्स के लिए xi की शर्तों के गुणांक ^ n (x) पास्कल के त्रिकोण के विकर्ण हैं। अर्थात

cumsum^3(x) = choose(2,2) * x1, choose(3,2) * x1 + choose(2,2) *x2, choose(4,2) * x1 + choose(3,2) * x2 + choose(2,2) * x3, ....

संपादित करें: एक समारोह बनाने के लिए

— njnnja
स्रोत
4

अजगर 2, 67

यह एंथनी रोइटमैन के रूप में समान योग का उपयोग करता है , और मॉर्गन थ्रैप के समान पुनरावृत्ति ।

f=lambda l,n:f([sum(l[:i+1])for i in range(len(l))],n-1)if n else l

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

— mathmandan
स्रोत
4

पायथन, 113 93 89 76 बाइट्स

def f(l,n):
 for i in[0]*n:l=[sum(l[:j+1])for j in range(len(l))];
 print(l)

यह दोनों परीक्षण मामलों के लिए काम करता है। स्टेटस, मॉर्गन थ्राप और रूथ फ्रैंकलिन को क्रमशः 93, 89, और 76 बाइट्स के नीचे कार्यक्रम में मदद करने के लिए धन्यवाद।

— एंथनी रोइटमैन
स्रोत
1
आप दूसरे लूप को एक सूची समझ में बदलकर कई बाइट्स काट सकते हैं। यही कारण है, k=[sum(l[:j+1])for j in range(len(l))]। फिर ;k=lउस के अंत से निपटने के साथ आप for iलूप के साथ एक पंक्ति में यह सब धक्का दे सकते हैं ।
— स्टेटस
1
आप k=[sum(l[:j+1])for j in range(len(l))];l=k2 बाइट्स को बचाने के लिए लूप के लिए उसी लाइन पर आगे बढ़ सकते हैं और दूसरे बाइट को बचाने के लिए f के तर्कों के बीच की जगह को हटा सकते हैं।
— मॉर्गन थ्रैप
जैसा कि आप के मूल्य का उपयोग नहीं करते हैं i, आप के for i in range(n)साथ प्रतिस्थापित कर सकते हैं for i in[0]*n(क्योंकि आप सभी के बारे में परवाह है सूची की तत्वों की लंबाई नहीं है)। और मुझे लगता है कि आप इसे सहायक सूची का उपयोग किए बिना कर सकते हैं k, बस तर्क को संशोधित कर सकते हैं l।
— रूथ फ्रैंकलिन
4

गोल> <> 0.3.10 , 22 बाइट्स

SI
C>rFlMF:}+
NRl<C}<;

पहले पूर्णांक को पुनरावृत्ति संख्या के रूप में लिया जाता है और बाकी सूची बनाते हैं। अंतिम सूची को नईलाइन-अलग किया गया है।

भाषा अभी भी काफी युवा और अस्थिर है, लेकिन जब से मैं इन ऑपरेटरों पर सुंदर सेट कर रहा हूं मुझे लगा कि यह ठीक होगा।

व्याख्या

SI            Read integer, moving down on EOF (first line runs as loop)
r             Reverse stack, putting iteration number on top

[outer loop]
F             Do #(iterations) times

[inner loop]
lMF           Do #(length of stack - 1) times
:             Duplicate top of stack
}             Rotate stack rightward (top goes to bottom)
+             Add the top two elements of the stack
C             Continue inner loop, moving down from F when loop is over

}             Rotate once more
C             Continue outer loop, moving down from F when loop is over

lRN           Print stack as (num + newline)
;             Halt

यह देखने के लिए कि यह क्यों काम करता है, आइए एक छोटा उदाहरण देखें [5 2 1]:

[5 2 1] -- : --> [5 2 1 1] -- } -->  [1 5 2 1]  -- + --> [1 5 3]
[1 5 3] -- : --> [1 5 3 3] -- } -->  [3 1 5 3]  -- + --> [3 1 8]

-- } --> [8 3 1]
— Sp3000
स्रोत
3

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

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

एक पुनरावर्ती कार्य जो सूची lऔर पुनरावृत्तियों की संख्या दोनों को पुन: प्राप्त करता है n। चलो इसे तोड़ दो।

पहले, आइए एक पुनरावर्ती फ़ंक्शन पर विचार करें gजो आंशिक योग को केवल एक बार पुनरावृत्त करता है।

g=lambda l:l and g(l[:-1])+[sum(l)]

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

अब, आइए एक फ़ंक्शन देखें fजो पुनरावृत्तियों के gलिए लागू होता है n।

f=lambda l,n:n and f(g(l),n-1)or l

जब nयह होता है 0, तो यह सूची को lअपरिवर्तित लौटाता है , और अन्यथा, gएक बार लागू होता है , फिर fएक कम पुनरावृत्ति के साथ पुनरावर्ती कॉल करता है ।

अब, हम वास्तविक कोड को फिर से देखते हैं, जो दो पुनरावर्ती को एक ही कार्य में जोड़ता है। विचार g(l)विशेष मामले के रूप में माना जाता है f(l,1)।

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

हम ले लिया f(g(l),n-1)पिछले परिभाषा का विस्तार से g(l)में g(l[:-1])+[sum(l)], और उसके बाद की जगह g(_)के साथ f(_,1)करने के लिए पुनरावर्ती कॉल सीमित करने के लिए f।

आधार मामले के लिए, हम वापस करना चाहते lजब भी n==0या l==[]। हम इन्हें ध्यान में रखते हुए जोड़ते हैं कि या तो कोई n*lखाली सूची है, जो कि मिथ्या है। इसलिए, हम जब भी n*lगैर-खाली होते हैं, तब तक वापस लौट जाते lहैं।

भले ही दो पुनरावर्ती कॉल हैं f, लेकिन इससे फाइबोनैचि संख्याओं की पुनरावर्ती परिभाषा में तेजी से वृद्धि नहीं होती है, लेकिन यह द्विघात रहता है।

— XNOR
स्रोत
3

C ++ (61 + 17 = 78 बाइट्स)

#include<numeric>
void f(int*a,int*e,int n){for(;n--;)std::partial_sum(a,e,a);}

परीक्षण का मामला:

#include <iostream>
#include <iterator>

int main() {
    int a[] { -3, 4, 7, -1, 15 };
    f(a, std::end(a), 3);
    for (auto i : a)
        std::cout << i << " ";
}

यह विनिर्देश के साथ थोड़ी सी स्वतंत्रता लेता है: यह सी-शैली सरणी का उपयोग करता है, सरणी के आरंभ और अंत के लिए पासिंग पॉइंटर्स। आंतरिक रूप से, जैसा कि आप देख सकते हैं, यह मानक पुस्तकालय में चारों ओर केवल एक अत्यंत पतली आवरण है std::partial_sum। वास्तव में परिणामी मूल्य वापस करने के बजाय, यह केवल उस सरणी को संशोधित करता है जो अंदर पारित हो गया है।

अगर हम चीजों की परिभाषाओं को सीमा तक पहुंचाने में कोई आपत्ति नहीं करते (और, यकीनन, थोड़ा परे) हम एक लंबोदर अभिव्यक्ति में "फ़ंक्शन" को परिभाषित कर सकते हैं:

#include<numeric>
#include <iostream>
#include <iterator>

int main() {
    int a[] { -3, 4, 7, -1, 15 };
    int *e = std::end(a);
    int n=3;

    auto f=[&]{for(;n--;)std::partial_sum(a,e,a);};

    f();
    for (auto i : a)
        std::cout << i << " ";
}

यह इस टुकड़े को फ़ंक्शन (जैसे ऑब्जेक्ट) की परिभाषा को कम करता है:

[&]{for(;n--;)std::partial_sum(a,e,a);};

... 40 बाइट्स के लिए (+17 के लिए #include)।

— जेरी कॉफ़िन
स्रोत
वाउ, मुझे आंशिक रकम गिनने के लिए एसटीएल की उम्मीद नहीं थी।
— ज़ेरेगेस
1
@Zereges: कोई भी स्पेनिश इनक्विटिट की उम्मीद नहीं करता है .... ओह, रुको, हम सी ++ कर रहे हैं, पायथन नहीं। मैं क्षमाप्रार्थी हूं।
— जेरी कॉफिन
2

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

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

0!a=a
i!a=(i-1)![sum$take j a|j<-[1..length a]]

उपयोग (GHCi):

$ ghci partialsums.hs
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( partialsums.hs, interpreted )
Ok, modules loaded: Main.
*Main> 1![-3, 4 ,7 ,-1 ,15]
[-3,1,8,7,22]
*Main> 3![-3, 4 ,7 ,-1 ,15]
[-3,-5,1,14,49]
— जेक
स्रोत
गोल्फ में आपका स्वागत है! यह आमतौर पर गार्ड मैच की तुलना में पैटर्न मैच के लिए छोटा होता है, जैसे 0!a=a i!a=...।
— xnor
धन्यवाद @xnor - मैंने पहले प्रारंभिक कोड का निर्माण करते समय 'xs' का उपयोग किया था और जब मैंने पोस्ट में कोड को संशोधित किया था तो इसे याद करना होगा। संपादित।
— जेक
के लिए sum(take j a), आप sum$take j aउच्च पूर्वता का उपयोग करके, पार्न्स से बच सकते हैं $।
— xnor
आपके सहयोग के लिए धन्यवाद! मैं किसी कारण से, इस धारणा के तहत था कि $वाक्यविन्यास पर पूर्वता बरती जाएगी (और शेष पंक्ति का मूल्यांकन करने की कोशिश करें जैसा कि आप खड़े हैं)। बेशक, यह भी मतलब नहीं होगा।
— जेक
2

सी #, 52 + 85 = 148 137 बाइट्स

using E=System.Collections.Generic.IEnumerable<int>;

तथा

E I(E s,int i){int t=0;return i<1?s:I(System.Linq.Enumerable.Select(s,v=>t+=v),i-1);}

यह अपरंपरागत प्रथाओं ( v=>t+=v) का उपयोग करता है , लेकिन यह पीपीसीजी है। स्टैक गहराई की बाधा पर भी ध्यान दें।

— LegionMammal978
स्रोत
2

पायथन 3, 73

शायद थोड़ा और नीचे गोल्फ हो सकता है।

def f(n,i):
 p=0;c=[]
 for m in n:p+=m;c+=[p]
 f(c,i-1)if i else print(n)

यह संस्करण सुन्न का उपयोग करता है, जो धोखा देने जैसा महसूस करता है, लेकिन यहां यह है:

पायथन 3 (सुन्न के साथ), 72

from numpy import*
def f(n,i):
 if i:c=cumsum(n);f(c,i-1)
 else:print(n)
— मॉर्गन थ्रैप
स्रोत
2

सी ++ 14, 102 103 94 + 17 (शामिल) = 111 बाइट्स

#include<vector>
auto f(std::vector<int>a,int n){for(;n--;)for(int i=0;i<a.size()-1;++i)a[i+1]+=a[i];return a;}

परीक्षण केस के साथ, अनगुल्ड

#include <vector>
#include <iostream>

auto f(std::vector<int> a, int n)
{
    for (; n--;)
        for (int i = 0; i < a.size() - 1; ++i)
            a[i + 1] += a[i];
    return a;
}


int main()
{
    auto t = f({-3, 4, 7, -1, 15}, 3);
    for (int i : t)
        std::cout << i << " ";
}

मूल्यांकन के आदेश पर निर्भर करता है। निश्चित नहीं है कि यह यूबी है या नहीं, लेकिन काम करता है यह कंपाइलर निर्भर है, इसलिए मैंने इसे बदल दिया।

— Zereges
स्रोत
j0 से n तक की गिनती के बजाय , nमेरी गणना से 0. बाइट्स 97 बाइट्स तक गिनें।
— जेरी कॉफिन
@JerryCoffin धन्यवाद ..
— Zereges
1

बर्लेस्क, 10 बाइट्स

{q++pa}jE!

यह सामान्य रूप से बहुत कुशल नहीं है, लेकिन यह चाल करता है।

blsq ) {-3 4 7 -1 15} 1 {q++pa}jE!
{-3 1 8 7 22}
blsq ) {-3 4 7 -1 15} 3 {q++pa}jE!
{-3 -5 1 14 49}
— mroman
स्रोत
1

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

अनाम लैम्बडा जैसा कि इसके इनपुट को संशोधित करता है, cजैसे एक रैंडम-एक्सेस-कंटेनर की आवश्यकता होती है vector<int>।

[](auto&c,int n){while(n--)for(int i=0;i++<c.size();c[i]+=c[i-1]);}
— कार्ल नेफ
स्रोत
1

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

SƤ¡

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

यह मेरी ( श्री Xcoder की) विधि है।

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

+\¡

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

यह caird coinheringaahing समाधान है।

विधि # 1

S - पूर्ण कार्यक्रम, डायडिक।

  , - बार-बार, एन बार लागू करें।
 Pre - सूची के उपसर्गों पर पूर्ववर्ती लिंक को मैप करें।
एस - सुम।
     - आउटपुट निहितार्थ

विधि # 2

+ \ Full - पूर्ण कार्यक्रम, डायडिक।

  , - बार-बार, एन बार लागू करें।
 \ - संचयी द्वारा कम करें:
+ - जोड़।
— मिस्टर एक्सकोडर
स्रोत
0

Axiom 213 47 बाइट्स

m(a,b)==(for i in 1..b repeat a:=scan(+,a,0);a)

ungolf और कुछ उदाहरण

 (3) -> [m([-3,4,7,-1,15],1), m([-3,4,7,-1,15],3)]
    Compiling function l with type List Integer -> List Integer
    Compiling function m with type (List Integer,Integer) -> List
       Integer

    (3)  [[- 3,1,8,7,22],[- 3,- 5,1,14,49]]
                                                       Type: List List Integer
— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.