introduction

Observons ce tableau: [3, 2, 4, 1, 1, 5, 1, 2].

Chaque élément affiche la longueur de la sous-chaîne qui doit être additionnée. Jetons un coup d'œil au premier élément du tableau ci-dessus:

[3, 2, 4, 1, 1, 5, 1, 2]
 ^

L'élément au premier index est 3 , donc nous prenons maintenant une sous-chaîne de longueur trois avec le même index que la position de départ:

[3, 2, 4]

En résumé, cela donne 9 , donc le premier élément de l'ensemble de sous - chaînes est 9.

Nous faisons cela pour tous les éléments du tableau:

3 -> [3, 2, 4]
2 -> [2, 4]
4 -> [4, 1, 1, 5]
1 -> [1]
1 -> [1]
5 -> [5, 1, 2]
1 -> [1]
2 -> [2]

Vous pouvez voir que le nombre 5 est un peu un cas étrange. Ce nombre dépasse la longueur du tableau:

[3, 2, 4, 1, 1, 5, 1, 2]
                ^  ^  ^  ^  ^

Nous ignorerons tout ce qui dépasse le tableau, nous utilisons donc simplement [5, 1, 2].

La dernière étape consiste à tout résumer:

[3, 2, 4]     -> 9
[2, 4]        -> 6
[4, 1, 1, 5]  -> 11
[1]           -> 1
[1]           -> 1
[5, 1, 2]     -> 8
[1]           -> 1
[2]           -> 2

Et c'est le tableau qui doit être sorti:

[9, 6, 11, 1, 1, 8, 1, 2]

La tâche

Étant donné un tableau non vide avec des entiers positifs (non nuls), affichez l'ensemble de sous - chaînes . C'est du code-golf , donc la soumission avec le plus petit nombre d'octets gagne!

Cas de test

[1, 2, 3, 4, 5] -> [1, 5, 12, 9, 5]
[3, 3, 3, 3, 3, 3, 3, 3] -> [9, 9, 9, 9, 9, 9, 6, 3]
[5, 1, 2, 4, 1] -> [13, 1, 6, 5, 1]
[1] -> [1]

Gelée , 6 octets

ṫJḣ"ḅ1

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

ṫJḣ"ḅ1  Main link. Argument: A (array)

 J      Index; yield the 1-based indices of A.
ṫ       Tail; map k to the postfix of A that begins with the k-th element.
  ḣ"    Vectorized head; for each k in A, truncate the corr. postfix to length k.
    ḅ1  Convert the resulting slices from base 1 to integer.

Python, 40 octets

f=lambda x:x and[sum(x[:x[0]])]+f(x[1:])

Testez-le sur Ideone .

Excel, 21 octets

=SUM(OFFSET(A1,,,A1))

Ouvrez une nouvelle feuille de calcul, placez les valeurs de test dans la colonne A. Entrez la formule dans B1 et double-cliquez sur la poignée de cellule pour parcourir la plage.

Python 3, 47 octets

lambda X:[sum(X[i:i+k])for i,k in enumerate(X)]

Implémentation assez simple. Le comportement par défaut de Python pour les tranches qui dépassent la fin de la liste était très pratique ici.

Haskell, 34 , 33 octets

f l@(x:y)=sum(take x l):f y
f x=x

Un octet enregistré par nimi.

JavaScript ES6, 50 octets

a=>a.map((e,i)=>a.slice(i,i+e).reduce((a,b)=>a+b))

Assez explicite. Il se trouve au- mapdessus de chaque élément du tableau, obtenant le résultat slicede ce index via l'index plus ela valeur de l'élément , et reduceing en ajoutant.

f=
  a=>a.map((e,i)=>a.slice(i,i+e).reduce((a,b)=>a+b))

;[
  [3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]
].forEach(function(test){
  document.getElementById('p').textContent += test + ' => ' + f(test) + '\n';
});

<pre id="p"></pre>

J, 11 octets

+/@{."_1]\.

Usage

   f =: +/@{."_1]\.
   f 3 2 4 1 1 5 1 2
9 6 11 1 1 8 1 2
   f 1 2 3 4 5
1 5 12 9 5

Explication

+/@{."_1]\.  Input: A
        ]\.  Get each suffix of A from longest to shortest
   {."_1     For each value in A, take that many values from its corresponding suffix
+/@          Sum that group of values taken from that suffix
             Return the sums

JavaScript (ES6), 45

reduce battu à nouveau!

a=>a.map((v,i)=>eval(a.slice(i,v+i).join`+`))

F=
a=>a.map((v,i)=>eval(a.slice(i,v+i).join`+`))

;[[3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]].forEach(t=>console.log(t+' -> '+F(t)))

Rétine , 38 octets

Le nombre d'octets suppose un codage ISO 8859-1.

\d+
$*
M!&`\b1(1)*(?<-1>,1+)*
M%`1
¶
,

L'entrée et la sortie sont des listes séparées par des virgules.

Essayez-le en ligne! (La première ligne active une suite de tests séparés par un saut de ligne.)

Mathematica 60 55 octets

Tr@Take[#,UpTo@#&@@#]&/@Drop[#,t-1]~Table~{t,Length@#}&

par exemple

f = %; f /@ {{1, 2, 3, 4, 5}, {3, 3, 3, 3, 3, 3, 3, 3}, {5, 1, 2, 4, 1}, {1}}

(*    {{1, 5, 12, 9, 5}, {9, 9, 9, 9, 9, 9, 6, 3}, {13, 1, 6, 5, 1}, {1}}    *)

Merci @MartinEnder d'avoir rasé 5 octets :)

05AB1E, 11 8 octets

[D¬£Oˆ¦Ž

Explication

[         # infinite loop
 D        # duplicate current list
  ¬       # get head of list
   £      # get that many elements from list
    O     # sum
     ˆ    # add to global array
      ¦   # remove first element of list
       Ž  # break if stack is empty
          # implicitly push and print global array

Essayez-le en ligne

Pyth , 8 octets

.es:Qk+b

Suite de tests.

Traduction de la réponse d' El en Python .

Erlang, 69 octets

f(A)->put(1,1),L=lists,[L:sum(L:sublist(A,put(1,get(1)+1),X))||X<-A].

Les fonctions d'ordre supérieur d'Erlang pour les listes ne reçoivent pas l'index de l'élément courant. Cela utilise le dictionnaire de processus pour définir l'index de l'élément en cours.

Pyke, 12 7 octets

FKo>i<s

Essayez-le ici!

        - o = 0
F       - for i in input:
  o     -    o+=1
   >    -    input[o:]
    i<  -   ^[:i]
      s -  sum(^)

VBA, 160 octets

Function e(g())
Dim h()
k=LBound(g)
l=UBound(g)
ReDim h(k To l)
On Error Resume Next
For i=k To l
For j=i To i+g(i)-1
h(i)=h(i)+g(j)
Next
Next
e=h
End Function

Pyth, 6 octets

ms<~tQ

Suite de tests

Il s'agit d'une solution différente des autres jusqu'à présent. Il boucle sur l'entrée, tranche une somme des valeurs initiales, puis supprime le premier élément de l'entrée stockée et répète.

Explication:

ms<~tQ
ms<~tQdQ    Implicit variable introduction
            Implicit: Q = eval(input())
m      Q    Map d over the input, Q
  <  Qd     Take the first d elements of Q
 s          Sum them
   ~tQ      Afterwards, set Q to the tail of Q, removing the first element.

Julia, 39 octets

!x=x!=[]?[take(x,x[])|>sum;!x[2:end]]:x

Essayez-le en ligne!

F #, 84 82 octets

let f(A:int[])=[for i in 0..A.Length-1->Seq.skip i A|>Seq.truncate A.[i]|>Seq.sum]

JavaScript (ES6) - 79 octets

Une solution récursive qui n'utilise aucune des méthodes de tableau:

f=([a,...t],n)=>a&&n?a+f(t,n-1):0;g=([a,...t],r=[])=>a?g(t,[...r,a+f(t,a-1)]):r

Essai:

f=([a,...t],n)=>a&&n?a+f(t,n-1):0;
g=([a,...t],r=[])=>a?g(t,[...r,a+f(t,a-1)]):r;

[
  [3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]
].forEach(a=>console.log(''+g(a)));

C #, 89 octets

int[]s(List<int>a)=>a.Select((n,i)=>a.GetRange(i,Math.Min(n,a.Count-i)).Sum()).ToArray();

assez simple

idées d'amélioration appréciées

Brachylog , 27 octets

.v|h~l(A:Tc?;A?)b:0&~b.h~+A

Essayez-le en ligne! ou vérifiez tous les cas de test .

Explication

  .v           Input = Output = []
|            Or
  h~l          A is a list, its length is the value of the first element of the Input
  (
    A:Tc?        The concatenation of A with another list T results in the Input
  ;            Or
    A?           A = Input
  )
  b:0&         Call recursively on Input minus the first element
  ~b.          Output is the output of that call with an extra element at the beginning
  h~+A         That extra element is the sum of the elements of A

Dyalog APL, 15 octets

{+/¨⍵↑∘⌽¨⌽,\⌽⍵}

ou

{⌽+/¨(-↑¨,\)⌽⍵}

Programme PHP, 72 octets

<?foreach($a=$_GET[a]as$i=>$v)echo array_sum(array_slice($a,$i,$v)),"
";

appeler avec php-cgi -f <filename> 'a[]=3&a[]=2&a[]=4...

+11 en fonction:

function f($a){foreach($a as$i=>$v)$r[]=array_sum(array_slice($a,$i,$v));return$r;}

+9 sans prédéfinis:

function p($a){foreach($c=$r=$a as$i=>$v)for($k=$i;$k--;)if(--$a[$k]>0)$r[$k]+=$v;return$r;}

($ c conserve les valeurs d'origine, $ a décompte pour chaque index, $ r obtient les sommes)

-3 comme programme:

<?foreach($a=$r=$c=$_GET[a]as$i=>$v)for($k=$i;$k--;)if(--$c[$k]>0)$r[$k]+=$v;print_r($r);

q (37 octets)

{sum each(til[count x],'x)sublist\:x}

Exemple:

q){sum each(til[count x],'x)sublist\:x}3 2 4 1 1 5 1 2
9 6 11 1 1 8 1 2

Matricks , 25 octets

Ouais, enfin un défi pour lequel je n'ai pas besoin de nouvelles fonctionnalités!

md{z:l-g:c;+c;q:c;};:1:l;

Courir avec: python matricks.py substring.txt [[<input>]] 0

Explication:

m                  :1:l;   #loop over entire input
                           #set each value to...
 d{               }        #the sum of...
   z:l-g:c:+c;q:c;         #the input cropped to
                           #the length of the value in the cell

Javascript (à l'aide d'une bibliothèque externe) (66 octets)

n=>_.From(n).Select((v,i)=>_.From(n).Slice(i,i+v).Sum()).ToArray()

Lien vers la bibliothèque: https://github.com/mvegh1/Enumerable

Explication du code: _.From charge le tableau d'entrée dans la bibliothèque, qui est essentiellement LINQ pour js. Ensuite, chaque élément du tableau est mappé en fonction du prédicat suivant: prenez l'entrée, puis coupez-la à partir de l'index de l'élément actuel et prenez cet index plus la valeur de l'élément actuel. Résumez ensuite cette sous-séquence. Convertir le résultat en un tableau JS natif et le renvoyer

Clojure, 63 octets

(defn f[[b & r]](concat[(apply + b(take(dec b)r))](if r(f r))))

Utilise la correspondance de modèle pour décomposer l'argument d'entrée dans le premier et le reste des arguments.

MATL , 17 14 13 octets

fGy+!-R0<G*!s

Explication

Essayez-le en ligne! Ou vérifiez tous les cas de test (code modifié pour gérer plusieurs entrées).

f     % Take input implicitly. Indices of nonzero elements: this gives [1 2 ... n]
      % where n is input size
G     % Push input again
y     % Push a copy of [1 2 ... n]
+     % Add. Gives [a+1 b+2...] where [a b...] is the input
!     % Transpose into a column vector
-     % Subtraction with broadcast. Gives 2D array
R     % Keep upper triangular part, making the rest of entries 0
0<    % True for negative entries. Each row corresponds to a substring sum.
      % For each row, this gives true for the entries of the input that make up
      % that substring sum. Each row is thus a mask to select entries of the input
G     % Push input again
*     % Multiply with broadcast. This multiplies the input times each row
!s    % Sum of each row. Implicitly display

C #, 94 octets

Console.Write(String.Join(",",a.Select((v,i)=>a.Skip(i).Take(v).Sum().ToString()).ToArray()));

Où a est un int [] qui représente l'entrée à résoudre.