Les sommes partielles d'une liste d'entiers [a ₁ , a ₂ , a ₃ , ..., a _n ] sont

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

On peut alors prendre la liste des sommes partielles [s ₁ , s ₂ , s ₃ , ..., s _n ] et recalculer ses sommes partielles pour produire une nouvelle liste, etc.

Connexes: Différences à terme itérées

Contribution:

• Une liste non vide d'entiers
• Un nombre d'itérations positif,

Sortie: affiche ou retourne la liste des entiers résultant de la prise de sommes partielles autant de fois.

Le moins d'octets gagne. Les intégrés sont OK même s'ils résolvent carrément le problème.

Cas de test:

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

Classement:

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 octets

+/\^:

Essayez en ligne sur J.js .

Comment ça marche

• /\ est un adverbe (fonction qui prend un argument de gauche) qui se réduit cumulativement par son argument.

• Ainsi +/\est le verbe de somme cumulative .

• ^:est la conjonction de pouvoir ; (f ^: n) ys'applique fun total de nfois à y.

• Le train de conjonction verbale +/\^:forme un adverbe qui se répète +/\autant de fois que spécifié dans son argument (gauche).

  x (+/\^:) yest analysé en tant que (x (+/\^:)) y, ce qui équivaut à l'exécution (+/\^:x) y.

Merci à @Zgarb pour son aide avec l'explication.

Mathematica, 19 octets

Eh bien, si les fonctions intégrées sont correctes ...

Accumulate~Nest~##&

Définit une fonction avec la même signature que les exemples du défi. Je suis à peu près sûr, grâce au nom long, Accumulateque cela sera facilement battu par les langues de golf et la famille APL. :)

Pour développer le commentaire de LegionMammal978 pour ceux qui ne connaissent pas Mathematica:

##représente une séquence des paramètres de la fonction (qui est comme une liste qui se "répartit" automatiquement là où elle est insérée, si vous connaissez mieux ce terme dans la langue de votre choix). Il ~s'agit de sucre syntaxique pour l'invocation de la fonction infixe, donc si nous appelons la fonction avec des paramètres listet nque nous développons tout, nous obtenons:

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

Ce qui se trouve être exactement l'ordre des arguments attendu par Nest.

Haskell, 26 23 octets

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

Ceci définit une fonction anonyme, appelée comme suit:

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

Merci à @nimi d'avoir économisé 3 octets.

Explication

(!!).                    -- 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 octets

{+\⍣⍺⊢⍵}

Ceci définit une fonction dyadique qui accepte les itérations et la liste comme arguments gauche et droit.

Merci à @NBZ d'avoir joué sur 1 octet!

Essayez-le en ligne sur TryAPL .

Comment ça marche

• ⍺et ⍵sont les arguments gauche et droit de la fonction.

• +\ est cumulativement réduit de somme.

• ⍣⍺répète les ⍺temps opérateur précédents .

• ⊢⍵applique la fonction d'identité à ⍵.

  Il s'agit d'une façon plus courte d'analyser le code au (+\⍣⍺)⍵lieu de +\⍣(⍺⍵).

En conjonction, nous appliquons +\un total de ⍺fois à⍵

Matlab, 41 octets

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

Assez simple. Je pense toujours qu'il est assez ennuyeux de ne pas avoir une manière intégrée de créer des fonctions anonymes définies par morceaux ou des ancres dans les récursions.

Non golfé:

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

JavaScript (ES6) 38

Étonnamment petit en utilisant récursivement .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>

K, 7 3 octets

{y+\/x}

Très similaire à la solution J. +\effectue avec précision une somme partielle, et lorsqu'il /est fourni avec un verbe monadique et un argument de gauche entier, il itère un nombre spécifié de fois, comme une boucle "for". Le reste est juste en train de l'envelopper soigneusement pour l'adapter à l'ordre des arguments.

  {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

Testé à Kona et oK .

Modifier:

Si je suis autorisé à inverser les arguments, comme l'a déterminé @ kirbyfan64sos, je peux me passer entièrement de la fonction wrapping:

+\/

Appelé comme:

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

Cela fonctionne correctement en k2.8 et en k5. Cela ne fonctionne pas en ok car cet interprète ne prend pas encore en charge les adverbes au curry (aka "projetés"), et il ne semble pas fonctionner correctement dans Kona pour des raisons moins claires.

edit : Il y a quelques jours, la +\/formulation fonctionne également en oK.

Pyth, 9 octets

usM._GvwQ

Essayez-le en ligne: démonstration ou suite de tests

Explication

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 octets

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

Cela n'a vraiment pas besoin de beaucoup d'explications. C'est une fonction récursive, si y==0alors il suffit de sortir x. Sinon, décrémentez y, effectuez un cumsum et recommencez. Probablement pas la solution Julia la plus golfée possible, je travaille toujours dessus.

Labyrinthe , 73 octets

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

Cela fait un moment que je n'ai pas répondu à quelque chose dans Labyrinth, et cela semblait faisable. :)

Le format d'entrée est une liste plate avec le nombre d'itérations en premier (puis la liste à laquelle appliquer les sommes partielles). Les délimiteurs ne comptent pas tous, tant qu'il n'y a pas de caractère après le dernier entier, vous pouvez donc utiliser quelque chose de lisible comme:

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

La sortie est séparée par des sauts de ligne:

-3
-5
1
14
49

R, 75 octets

C'est long mais une prise différente ... calculer directement la séquence souhaitée au lieu des sommes cumulées:

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

Notant que les coefficients des termes de xi pour cumsum ^ n (x) sont des diagonales du triangle de Pascal. c'est à dire

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

modifier: pour créer une fonction

Python 2, 67

Cela utilise la même somme qu'Anthony Roitman et la même récursivité que Morgan Thrapp .

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

J'ai développé cette solution avant de voir la leur, puis il m'a semblé plus facile de la poster comme réponse plutôt que comme commentaire à l'un d'eux ou aux deux.

Python, 113 93 89 76 octets

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

Cela fonctionne pour les deux cas de test. Merci à Status, Morgan Thrapp et Ruth Franklin de m'avoir aidé à jouer le programme à 93, 89 et 76 octets respectivement.

Gol> <> 0.3.10 , 22 octets

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

Le premier entier est considéré comme le numéro d'itération et les autres constituent la liste. La liste finale est sortie séparée par des sauts de ligne.

La langue est encore assez jeune et instable, mais comme je suis assez attaché à ces opérateurs, j'ai pensé que ça allait.

Explication

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

Pour voir pourquoi cela fonctionne, essayons un petit exemple [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 octets

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

Une fonction récursive qui récursive à la fois sur la liste let le nombre d'itérations n. Décomposons-le.

Tout d'abord, considérons une fonction récursive gqui a répété la somme partielle une seule fois.

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

Pour une liste vide l, cela renvoie llui-même, la liste vide. Sinon, la dernière entrée des sommes partielles de lest la somme globale de l, qui est ajoutée au résultat récursif pour tous sauf le dernier élément de l.

Maintenant, regardons une fonction fqui s'applique gaux nitérations.

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

Quand nest 0, cela renvoie la liste linchangée, et sinon, s'applique gune fois, puis appelle frécursivement avec une itération de moins restante.

Maintenant, regardons à nouveau le code réel, qui combine les deux récursions en une seule fonction. L'idée est de traiter g(l)comme le cas particulier f(l,1).

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

Nous avons repris f(g(l),n-1)de la définition précédente, développé g(l)en g(l[:-1])+[sum(l)], puis remplacé g(_)par f(_,1)pour limiter les appels récursifs à f.

Pour le cas de base, nous voulons revenir lchaque fois que n==0ou l==[]. Nous les combinons en notant que l'un ou l'autre fait n*lêtre la liste vide, qui est Falsy. Ainsi, nous récursions chaque fois qu'il n*ln'est pas vide et revenons lautrement.

Même s'il y a deux appels récursifs à f, cela ne provoque pas une explosion exponentielle de la définition récursive des nombres de Fibonacci, mais reste quadratique.

C ++ (61 + 17 = 78 octets)

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

Cas de test:

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

Cela prend une légère liberté avec la spécification: il utilise un tableau de style C, en passant des pointeurs vers le début et la fin du tableau. En interne, comme vous pouvez le voir, ce n'est qu'un wrapper extrêmement fin autour std::partial_sumde la bibliothèque standard. Plutôt que de renvoyer réellement la valeur résultante, il modifie simplement le tableau transmis.

Si cela ne nous dérange pas de pousser les définitions des choses à la limite (et, sans doute, un peu au-delà), nous pouvons définir une "fonction" dans une expression 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 << " ";
}

Cela réduit la définition de la fonction (objet semblable à) à cette pièce:

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

... pour 40 octets (+17 pour le #include).

CJam, 13 octets

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

Testez-le ici.

Haskell, 52 47 octets

Première tentative de golf de code, et je suis vraiment un débutant Haskell, donc les commentaires sont les bienvenus! Il n'était pas clair dans la question quant au format nécessaire de l'appel de fonction, ou s'il était pris par un argument dans le programme, j'ai donc utilisé le point d'exclamation comme identificateur de fonction pour économiser quelques espaces.

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

Utilisation (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 octets

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

C #, 52 + 85 = 148 137 octets

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

et

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

Il utilise des pratiques peu orthodoxes ( v=>t+=v), mais c'est PPCG. Notez également la contrainte de profondeur de pile.

Python 3, 73

Pourrait probablement être joué un peu plus loin.

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

Cette version utilise numpy, qui ressemble un peu à de la triche, mais la voici:

Python 3 (avec 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 (inclus) = 111 octets

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

Non golfé, avec cas de test

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

Dépend de l'ordre d'évaluation. Je ne sais pas si c'est UB ou non, mais ça marche Cela dépend du compilateur, donc je l'ai changé.

Octave, 24 octets

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

Burlesque, 10 octets

{q++pa}jE!

ce n'est pas très efficace en général mais ça fait l'affaire.

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 octets

Comme lambda sans nom modifiant son entrée, nécessitant ccomme un conteneur à accès aléatoire comme vector<int>.

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

05AB1E , 4 octets (probablement non concurrents)

F.pO

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

Essayez-le en ligne!

Gelée , 3 octets

SƤ¡

Essayez-le en ligne!

C'est ma méthode (celle de M. Xcoder ).

Gelée , 3 octets

+\¡

Essayez-le en ligne!

C'est la solution de caird coinheringaahing .

Méthode n ° 1

SƤ¡ - Programme complet, dyadique.

  ¡- Appliquer plusieurs fois, N fois.
 Ƥ - Mappez le lien précédent sur les préfixes de la liste.
S - Somme.
     - Sortie implicite

Méthode n ° 2

+ \ ¡- Programme complet, dyadique.

  ¡- Appliquer plusieurs fois, N fois.
 \ - Réduction cumulative de:
+ - Addition.

Axiome 213 47 octets

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

ungolf et un exemple

 (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