Einführung

Lassen Sie sich diese Anordnung beachten: [3, 2, 4, 1, 1, 5, 1, 2].

Jedes Element zeigt die Länge des zu summierenden Teilstrings an. Werfen wir einen Blick auf das erste Element des obigen Arrays:

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

Das Element am ersten Index ist 3 , daher nehmen wir jetzt einen Teilstring der Länge drei mit demselben Index wie die Startposition:

[3, 2, 4]

Zusammengefasst ergibt dies 9 , sodass das erste Element der Teilstringsummenmenge ist 9.

Wir machen das für alle Elemente im Array:

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

Sie können sehen, dass die Nummer 5 ein bisschen komisch ist. Diese Zahl überschreitet die Länge des Arrays:

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

Wir werden alles ignorieren, was das Array überschreitet, also verwenden wir einfach [5, 1, 2].

Der letzte Schritt ist, alles zusammenzufassen:

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

Und das ist das Array, das ausgegeben werden muss:

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

Die Aufgabe

Bei einem nicht leeren Array mit positiven Ganzzahlen (ungleich Null) wird der Teilstringsummensatz ausgegeben . Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Testfälle

[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]

Gelee , 6 Bytes

ṫJḣ"ḅ1

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

ṫ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 Bytes

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

Teste es auf Ideone .

Excel, 21 Bytes

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

Öffnen Sie eine neue Tabelle, und geben Sie die Testwerte in Spalte A ein. Geben Sie die Formel in B1 ein und doppelklicken Sie auf den Zellengriff, um den Bereich zu durchlaufen.

Python 3, 47 Bytes

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

Ziemlich unkomplizierte Implementierung. Das Standardverhalten von Python für Slices, die über das Ende der Liste hinausgehen, war hier sehr praktisch.

Haskell, 34 , 33 Bytes

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

Ein Byte von nimi gespeichert.

JavaScript ES6, 50 Byte

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

Ziemlich selbsterklärend. Es wird mapüber jedes Element im Array gelegt, das slicevon diesem iNDEX über den Index plus eden Wert dieses Elements abgerufen und reducedurch Addieren addiert.

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 Bytes

+/@{."_1]\.

Verwendung

   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

Erläuterung

+/@{."_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 wieder geschlagen!

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)))

Retina , 38 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Eingabe und Ausgabe sind durch Kommas getrennte Listen.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Mathematica 60 55 Bytes

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

z.B

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}}    *)

Danke @MartinEnder, dass du 5 Bytes gespart hast :)

05AB1E, 11 8 Bytes

[D¬£Oˆ¦Ž

Erläuterung

[         # 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

Probieren Sie es online aus

Pyth , 8 Bytes

.es:Qk+b

Testsuite.

Übersetzung der Antwort von El in Python .

Erlang, 69 Bytes

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

Die übergeordneten Funktionen von Erlang für Listen erhalten nicht den Index des aktuellen Elements. Dies verwendet das Prozesswörterbuch, um den Index des aktuellen Elements festzulegen.

Pyke, 12 7 Bytes

FKo>i<s

Probieren Sie es hier aus!

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

VBA, 160 Bytes

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 Bytes

ms<~tQ

Testsuite

Dies ist eine andere Lösung als alle anderen bisher. Es durchläuft die Eingabe, schneidet eine Summierung der Anfangswerte, entfernt dann das erste Element der gespeicherten Eingabe und wiederholt diese.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

F #, 84 82 Bytes

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

JavaScript (ES6) - 79 Bytes

Eine rekursive Lösung, die keine der Array-Methoden verwendet:

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

Testen:

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)));

89 Bytes

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

ziemlich einfach

Verbesserungsvorschläge erwünscht

Brachylog , 27 Bytes

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

Probieren Sie es online! oderüberprüfen Sie alle Testfälle .

Erläuterung

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

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

oder

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

PHP-Programm, 72 Bytes

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

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

+11 als Funktion:

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

+9 ohne eingebauten:

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

($ c behält die ursprünglichen Werte bei, $ a zählt für jeden Index herunter, $ r bekommt die Summen)

-3 als Programm:

<?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 Bytes)

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

Beispiel:

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 Bytes

Yay, endlich eine Herausforderung, für die ich keine neuen Funktionen benötige!

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

Laufen mit: python matricks.py substring.txt [[<input>]] 0

Erläuterung:

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 (mit externer Bibliothek) (66 Bytes)

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

Link zu lib: https://github.com/mvegh1/Enumerable

Codeerklärung: _.From lädt das Eingabearray in die Bibliothek, die im Grunde genommen LINQ für js ist. Dann wird jedes Element im Array gemäß dem folgenden Prädikat zugeordnet: Nehmen Sie die Eingabe, schneiden Sie sie aus dem aktuellen Elementindex und nehmen Sie diesen Index plus den Wert des aktuellen Elements. Fassen Sie dann diese Untersequenz zusammen. Konvertieren Sie das Ergebnis in ein natives JS-Array und geben Sie es zurück

Clojure, 63 Bytes

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

Verwendet die Mustererkennung, um das Eingabeargument in das erste und den Rest der Argumente zu zerlegen.

MATL , 17 14 13 Bytes

fGy+!-R0<G*!s

Erläuterung

Probieren Sie es online! Oder überprüfen Sie alle Testfälle (Code geändert, um mehrere Eingaben zu verarbeiten).

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

94 Bytes

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

Wobei a ein int [] ist, das die zu lösende Eingabe darstellt.