Introducción

Observemos esta matriz: [3, 2, 4, 1, 1, 5, 1, 2].

Cada elemento muestra la longitud de la subcadena que debe resumirse. Echemos un vistazo al primer elemento de la matriz anterior:

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

El elemento en el primer índice es 3 , por lo que ahora tomamos una subcadena de longitud tres con el mismo índice que la posición inicial:

[3, 2, 4]

Cuando resumió, esto se traduce en 9 , por lo que el primer elemento del conjunto suma subcadena es 9.

Hacemos esto para todos los elementos de la matriz:

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

Puedes ver que el número 5 es un caso un poco extraño. Ese número excede la longitud de la matriz:

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

Ignoraremos todo lo que exceda la matriz, por lo que solo usaremos [5, 1, 2].

El último paso es resumir todo:

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

Y esa es la matriz que se debe generar:

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

La tarea

Dada una matriz no vacía con enteros positivos (no cero), genera el conjunto de suma de subcadenas . Este es el código de golf , por lo que gana el envío con el menor número de bytes.

Casos de prueba

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

Jalea , 6 bytes

ṫJḣ"ḅ1

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

ṫ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:])

Pruébalo en Ideone .

Excel, 21 bytes

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

Abra una nueva hoja de cálculo, coloque los valores de prueba en la columna A. Ingrese la fórmula en B1 y haga doble clic en el controlador de celda para recorrer el rango.

Python 3, 47 bytes

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

Implementación bastante sencilla. El comportamiento predeterminado de Python para los cortes que van más allá del final de la lista fue muy conveniente aquí.

Haskell, 34 , 33 bytes

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

Un byte guardado por nimi.

JavaScript ES6, 50 bytes

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

Bastante autoexplicativo. Está mapsobre cada elemento de la matriz, obteniendo el slicede ese index a través del índice más eel valor de ese elemento, e reduceing sumando.

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]\.

Uso

   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

Explicación

+/@{."_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 golpeado de nuevo!

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

El recuento de bytes asume la codificación ISO 8859-1.

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

La entrada y la salida son listas separadas por comas.

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas separado por salto de línea).

Mathematica 60 55 bytes

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

p.ej

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

Gracias @MartinEnder por reducir 5 bytes :)

05AB1E, 11 8 bytes

[D¬£Oˆ¦Ž

Explicación

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

Pruébalo en línea

Pyth , 8 bytes

.es:Qk+b

Banco de pruebas.

Traducción de la respuesta de El en Python .

Erlang, 69 bytes

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

Las funciones de orden superior de Erlang para listas no reciben el índice del elemento actual. Esto usa el diccionario de proceso para establecer el índice del elemento actual.

Pyke, 12 7 bytes

FKo>i<s

Pruébalo aquí!

        - 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

Banco de pruebas

Esta es una solución diferente a cualquier otra hasta ahora. Recorre la entrada, corta y suma los valores iniciales, luego elimina el primer elemento de la entrada almacenada y repite.

Explicación:

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

Pruébalo en línea!

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

Una solución recursiva que no utiliza ninguno de los métodos de matriz:

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

Pruebas:

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 bytes

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

muy claro

ideas de mejora apreciadas

Brachylog , 27 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Explicación

  .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

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

o

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

Programa PHP, 72 bytes

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

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

+11 como una función:

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

+9 sin incorporaciones:

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

($ c mantiene los valores originales, $ a cuenta atrás para cada índice, $ r obtiene las sumas)

-3 como programa:

<?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}

Ejemplo:

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

Matrices , 25 bytes

¡Sí, finalmente un desafío para el que no necesito nuevas funciones!

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

Corre con: python matricks.py substring.txt [[<input>]] 0

Explicación:

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 (usando la biblioteca externa) (66 bytes)

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

Enlace a lib: https://github.com/mvegh1/Enumerable

Explicación del código: _.Desde está cargando la matriz de entrada en la biblioteca, que es básicamente LINQ para js. Luego, cada elemento de la matriz se asigna de acuerdo con el siguiente predicado: tome la entrada, córtela del índice del elemento actual y tome ese índice más el valor del elemento actual. Luego, resume esa subsecuencia. Convierta el resultado en una matriz JS nativa y devuélvala

Clojure, 63 bytes

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

Utiliza la coincidencia de patrones para descomponer el argumento de entrada en el primero y el resto de los argumentos.

MATL , 17 14 13 bytes

fGy+!-R0<G*!s

Explicación

Pruébalo en línea! O verifique todos los casos de prueba (código modificado para manejar varias entradas).

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 bytes

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

Donde a es un int [] que representa la entrada a resolver.