The jumlah parsial dari daftar bilangan bulat [a ₁ , a ₂ , a ₃ , ..., a _n ] adalah

s ₁ = a ₁
s ₂ = a ₁ + a ₂
s ₃ = a ₁ + a ₂ + a ₃
...
s _n = a ₁ + a ₂ + ... + a _n

Kita kemudian dapat mengambil daftar jumlah parsial [s ₁ , s ₂ , s ₃ , ..., s _n ] dan menghitung jumlah parsialnya lagi untuk menghasilkan daftar baru, dan seterusnya.

Terkait: Iterasi ke depan perbedaan

Memasukkan:

• Daftar bilangan bulat yang tidak kosong
• Sejumlah iterasi positif,

Keluaran: Cetak atau kembalikan daftar bilangan bulat yang dihasilkan dari pengambilan jumlah parsial yang berkali-kali.

Bytes paling sedikit menang. Built-in tidak masalah meskipun mereka langsung menyelesaikan masalah.

Kasus uji:

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

Papan peringkat:

var QUESTION_ID=59192,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/61321/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

J, 5 byte

+/\^:

Cobalah online di J.js .

Bagaimana itu bekerja

• /\ adalah kata keterangan (fungsi yang mengambil argumen kiri) yang secara kumulatif berkurang dengan argumennya.

• Jadi +/\adalah jumlah kata kerja kumulatif .

• ^:adalah konjungsi kekuatan ; (f ^: n) yberlaku ftotal nkali untuk y.

• Kereta kata kerja-konjungsi +/\^:membentuk kata keterangan yang berulang +/\sebanyak yang ditentukan dalam argumen (kiri).

  x (+/\^:) yakan diuraikan sebagai (x (+/\^:)) y, yang setara dengan mengeksekusi (+/\^:x) y.

Terima kasih kepada @Zgarb atas bantuannya dengan penjelasannya.

Mathematica, 19 byte

Nah, jika built-in tidak apa-apa ...

Accumulate~Nest~##&

Menentukan fungsi dengan tanda tangan yang sama dengan contoh dalam tantangan. Saya cukup yakin, berkat nama panjang Accumulatebahwa ini akan mudah dikalahkan oleh bahasa golf dan keluarga APL. :)

Untuk menguraikan komentar LegionMammal978 bagi mereka yang tidak Mathematica:

##mewakili urutan parameter fungsi (yang seperti daftar yang secara otomatis "splat" di mana pun ia dimasukkan, jika Anda lebih terbiasa dengan istilah itu dari bahasa pilihan Anda). The ~adalah sintaksis gula untuk fungsi infix doa, jadi jika kita memanggil fungsi dengan parameter listdan ndan memperluas segala sesuatu, kita mendapatkan:

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

Yang terjadi justru urutan argumen yang diharapkan oleh Nest.

Haskell, 26 23 byte

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

Ini mendefinisikan fungsi anonim, dipanggil sebagai berikut:

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

Terima kasih kepada @nimi karena telah menghemat 3 byte.

Penjelasan

(!!).                    -- Index by second argument from
     iterate(         )  -- the infinite list obtained by iterating
             scanl1(+)   -- the partial sums function (left scan by +) to first argument

APL, 9 8 byte

{+\⍣⍺⊢⍵}

Ini mendefinisikan fungsi diad yang menerima iterasi dan daftar sebagai argumen kiri dan kanan.

Terima kasih kepada @NBZ untuk bermain golf 1 byte!

Cobalah online di TryAPL .

Bagaimana itu bekerja

• ⍺dan ⍵argumen kiri dan kanan untuk fungsi.

• +\ kumulatif dikurangi dengan jumlah.

• ⍣⍺mengulangi waktu operator sebelumnya ⍺.

• ⊢⍵menerapkan fungsi identitas ⍵.

  Ini adalah cara yang lebih pendek dari parsing kode sebagai (+\⍣⍺)⍵bukan +\⍣(⍺⍵).

Dalam hubungannya, kami menerapkan +\total ⍺kali untuk⍵

Matlab, 41 byte

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

Cukup mudah. Saya masih berpikir itu cukup menjengkelkan karena tidak memiliki cara untuk membuat fungsi anonim yang didefinisikan secara terpisah, atau jangkar dalam rekursi.

Tidak Disatukan:

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

JavaScript (ES6) 38

Mengejutkan menggunakan .map secara rekursif

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>

K, 7 3 byte

{y+\/x}

Sangat mirip dengan solusi J. +\tepat melakukan jumlah parsial, dan ketika /diberikan dengan kata kerja monadik dan argumen integer kiri itu mengulangi beberapa kali, seperti loop "for". Sisanya hanya membungkusnya dengan rapi agar sesuai dengan urutan argumen.

  {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

Diuji dalam Kona dan oK .

Edit:

Jika saya diizinkan untuk membalikkan argumen, seperti yang ditentukan @ kirbyfan64sos, saya dapat membuang fungsi pembungkus seluruhnya:

+\/

Dipanggil seperti:

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

Ini berfungsi baik di k2.8 dan k5. Ini tidak berfungsi di OK karena penerjemah itu belum mendukung adverbia curried (alias "diproyeksikan"), dan itu tampaknya tidak bekerja dengan baik di Kona karena alasan yang kurang jelas.

sunting : Sampai beberapa hari yang lalu, +\/formulasi juga berfungsi di oK.

Pyth, 9 byte

usM._GvwQ

Cobalah online: Demonstrasi atau Test Suite

Penjelasan

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

Julia, 29 byte

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

Ini benar-benar tidak perlu banyak penjelasan. Ini adalah fungsi rekursif, jika y==0kemudian hanya keluaran x. Jika tidak, kurangi y, lakukan cumsum, dan rekursi. Mungkin bukan solusi Julia yang paling golf, saya masih mengusahakannya.

Labirin , 73 byte

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

Sudah lama sejak saya menjawab sesuatu di Labyrinth, dan ini sepertinya bisa dilakukan. :)

Format input adalah daftar datar dengan jumlah iterasi pertama (dan kemudian daftar untuk menerapkan jumlah parsial). Pembatas tidak masalah semua, selama tidak ada karakter setelah integer terakhir, sehingga Anda dapat menggunakan sesuatu yang dapat dibaca seperti:

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

Output dipisahkan oleh baris baru:

-3
-5
1
14
49

R, 75 byte

Ini panjang tapi berbeda ... menghitung urutan yang diinginkan secara langsung daripada jumlah kumulatif:

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

Memperhatikan bahwa koefisien syarat xi untuk kumsum ^ n (x) adalah diagonal segitiga Pascal. yaitu

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, ....

edit: untuk membuat fungsi

Python 2, 67

Ini menggunakan penjumlahan yang sama dengan Anthony Roitman , dan rekursi yang sama dengan Morgan Thrapp .

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

Saya mengembangkan solusi ini sebelum saya melihat solusi mereka, dan kemudian sepertinya lebih mudah untuk mempostingnya sebagai jawaban daripada komentar untuk salah satu atau keduanya.

Python, 113 93 89 76 byte

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

Ini berfungsi untuk kedua kasus uji. Terima kasih kepada Status, Morgan Thrapp, dan Ruth Franklin yang telah membantu saya mengubah program menjadi 93, 89, dan 76 byte.

Gol> <> 0.3.10 , 22 byte

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

Bilangan bulat pertama dianggap sebagai nomor iterasi dan sisanya merupakan daftar. Daftar akhir dikeluarkan baris-baru yang dikeluarkan.

Bahasanya masih sangat muda dan tidak stabil, tetapi karena saya cukup mengatur operator ini saya pikir itu akan baik-baik saja.

Penjelasan

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

Untuk melihat mengapa ini berhasil, mari kita coba contoh kecil [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]

Python, 52 byte

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

Fungsi rekursif yang berulang pada daftar ldan jumlah iterasi n. Mari kita jabarkan.

Pertama, mari kita pertimbangkan fungsi rekursif gyang mengulangi jumlah parsial sekali saja.

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

Untuk daftar kosong l, ini mengembalikan ldirinya sendiri, daftar kosong. Jika tidak, entri terakhir dari jumlah parsial ladalah jumlah keseluruhan l, yang ditambahkan ke hasil rekursif untuk semua kecuali elemen terakhir l.

Sekarang, mari kita lihat fungsi fyang berlaku guntuk niterasi.

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

Ketika nadalah 0, ini mengembalikan daftar lberubah, dan sebaliknya, berlaku gsekali, kemudian memanggil frekursif dengan satu lebih sedikit iterasi yang tersisa.

Sekarang, mari kita lihat kembali kode yang sebenarnya, yang menggabungkan dua rekursi menjadi satu fungsi. Idenya adalah untuk memperlakukan g(l)sebagai kasus khusus f(l,1).

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

Kami mengambil f(g(l),n-1)dari definisi sebelumnya, diperluas g(l)menjadi g(l[:-1])+[sum(l)], dan kemudian diganti g(_)dengan f(_,1)untuk membatasi panggilan rekursif f.

Untuk kasus dasar, kami ingin kembali lkapanpun n==0atau l==[]. Kami menggabungkan ini dengan mencatat bahwa salah satu n*ldari daftar tersebut menjadi daftar kosong, yaitu Falsy. Jadi, kami berulang setiap kali n*ltidak kosong, dan mengembalikan lsebaliknya.

Meskipun ada dua panggilan rekursif f, ini tidak menyebabkan ledakan eksponensial definisi rekursif dari angka-angka Fibonacci, tetapi tetap kuadratik.

C ++ (61 + 17 = 78 byte)

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

Kasus cobaan:

#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 << " ";
}

Ini membutuhkan sedikit kebebasan dengan spesifikasi: ia menggunakan larik C-style, melewati pointer ke awal dan akhir larik. Secara internal, seperti yang Anda lihat, itu hanya pembungkus yang sangat tipis std::partial_sumdi dalam perpustakaan standar. Alih-alih benar-benar mengembalikan nilai yang dihasilkan, itu hanya mengubah array yang diteruskan.

Jika kita tidak keberatan mendorong definisi hal-hal ke batas (dan, bisa dibilang, sedikit di luar) kita dapat mendefinisikan "fungsi" dalam ekspresi lambda:

#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 << " ";
}

Ini mengurangi definisi fungsi (-seperti objek) untuk bagian ini:

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

... untuk 40 byte (+17 untuk #include).

CJam, 13 byte

q~{{1$+}*]}*p

Uji di sini.

Haskell, 52 47 byte

Kode 'usaha' golf pertama, dan saya sangat pemula di Haskell, jadi komentar dengan senang hati disambut! Tidak jelas dalam pertanyaan mengenai format panggilan fungsi yang diperlukan, atau apakah itu diambil oleh argumen ke program, jadi saya menggunakan tanda seru sebagai pengidentifikasi fungsi untuk menghemat beberapa ruang.

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

Penggunaan (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]

R, 41 byte

function(x,n){for(i in 1:n)x=cumsum(x);x}

C #, 52 + 85 = 148 137 byte

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

dan

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

Ini menggunakan praktik yang tidak lazim ( v=>t+=v), tetapi ini adalah PPCG. Perhatikan juga batasan kedalaman tumpukan.

Python 3, 73

Mungkin bisa bermain golf sedikit lebih jauh.

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

Versi ini menggunakan numpy, yang terasa sedikit seperti curang, tetapi ini dia:

Python 3 (dengan numpy), 72

from numpy import*
def f(n,i):
 if i:c=cumsum(n);f(c,i-1)
 else:print(n)

C ++ 14, 102 103 94 + 17 (termasuk) = 111 byte

#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;}

Tidak disatukan, dengan test case

#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 << " ";
}

Bergantung pada urutan evaluasi. Tidak yakin apakah itu UB atau tidak, tetapi berfungsi Ini bergantung pada kompiler, jadi saya mengubahnya.

Oktaf, 24 byte

@(l,n)l*triu(0*l'*l+1)^n

Burlesque, 10 byte

{q++pa}jE!

itu tidak terlalu efisien secara umum tetapi itu berhasil.

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}

C ++ 14, 67 byte

Sebagai lambda tanpa nama memodifikasi inputnya, diperlukan csebagai wadah akses-acak seperti vector<int>.

[](auto&c,int n){while(n--)for(int i=0;i++<c.size();c[i]+=c[i-1]);}

05AB1E , 4 byte (Mungkin tidak bersaing)

F.pO

F    # Implicitly take first input and loop n times.
 .p  # Generate prefixes of input.
   O # Sum all prefixes (implicitly vectorized).

Cobalah online!

Jelly , 3 byte

SƤ¡

Cobalah online!

Ini adalah metode saya ( Mr Xcoder ).

Jelly , 3 byte

+\¡

Cobalah online!

Ini adalah solusi caird coinheringaahing .

Metode # 1

SƤ¡ - Program lengkap, diad.

  ¡- terapkan berulang kali, N kali.
 Ƥ - Memetakan tautan sebelumnya di atas awalan daftar.
S - Sum.
     - Output tersirat

Metode # 2

+ \ ¡- Program lengkap, diad.

  ¡- terapkan berulang kali, N kali.
 \ - Kumulatif dikurangi dengan:
+ - Tambahan.

Aksioma 213 47 byte

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

ungolf dan beberapa contoh

 (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