Tengo un desafío simple para ti esta vez. Dada una serie de enteros positivos A (o el equivalente en su idioma), reemplace cada entrada A _i con la suma de los siguientes elementos A _i de A , retrocediendo desde el principio si no hay suficientes elementos.

Como de costumbre, puede competir en cualquier lenguaje de programación y puede tomar entradas y proporcionar salidas a través de cualquier método estándar y en cualquier formato razonable, mientras toma nota de que estas lagunas están prohibidas por defecto. Opcionalmente, también puede tomar el tamaño de A como entrada. Este es el código de golf , por lo que gana el envío más corto (en bytes) para cada idioma .

Ejemplos / Casos de prueba

Dado [1,3,4,5], su código debería salir [3,10,13,14], porque 1se reemplaza por 3, 3se reemplaza por 4+5+1=10(observe cómo se recuperó desde el principio), 4por 5+1+3+4=13y 5por 1+3+4+5+1=14.

Dado [3,2,1,9], su programa debe producir [12,10,9,33], porque lo sustituimos 3con 2+1+9=12, 2con 1+9=10, 1con 9y 9con 3+2+1+9+3+2+1+9+3=33(observe cómo nos hemos recuperado desde el principio más de una vez).

Algunos casos de prueba más para elegir:

[4,3,2,1]                       -> [10,7,5,4]
[3,2,1,9]                       -> [12,10,9,33]
[1,3,4,5]                       -> [3,10,13,14]
[4,4,3,2,2]                     -> [11,11,8,6,8]
[3,5,3,2,1]                     -> [10,14,6,4,3]
[3,2,4,3,2,1,1]                 -> [9,7,7,4,2,1,3]
[7,8,6,5,4,3,2,1,5]             -> [29,33,20,15,11,8,6,5,30]
[28,2,4,2,3,2,3,4,5,3]          -> [137,6,10,5,9,7,12,38,39,34]
[1,2,3,4,5,4,3,2,1,2,3,4,3,2,1] -> [2,7,13,14,12,8,5,3,2,7,9,7,4,2,1]

MATL , 10 9 bytes

"G@:X@+)s

Pruébalo en línea!

	% implicit input
"	% for loop, iterate over the input array 
G	% push input x
@	% push for loop index, x[i]
:	% range, push [1,...,x[i]]
X@	% push for loop index, i
+	% sum, so stack holds [i+1,...,i+x[i]]
)	% index, modularly, so gets the cyclic successors
s	% sum cyclic successors, leaving the sum on the stack
	% implicit end of for loop
	% implicit output of stack

Jalea , 6 bytes

ṙJṁS¥"

Pruébalo en línea!

Python , 55 bytes

lambda a:[sum((-~v*a)[i:i+v])for i,v in enumerate(a,1)]

Pruébalo en línea!

J, 33 bytes

[:({.+/@{.}.)"1 i.@#|."{($~>./*#)

sin golf

[: ({. +/@{. }.)"1 i.@# |."0 _ ($~ (>./ * #))

explicación

Pruébalo en línea!

C (gcc) , 86 85 bytes

• Salvó un byte gracias a Jakob .

C(y,c,l,i,k)int*y;{for(l=~0;++l<c;printf("%d,",k))for(k=i=0;i++<y[l];k+=y[(l+i)%c]);}

Pruébalo en línea!

Haskell, 50 47 44 bytes

zipWith((sum.).take)<*>scanr(:)[].tail.cycle

Pruébalo en línea!

                    -- <*> in function context is Haskell's S combinator, i.e.
                    --     (zipWith ... <*> scanr ...) arg
                    -- resovles to
                    --     zipWith ... arg (scanr ... arg)
zipWith             -- so we zip
                    --   the input list and
 scanr(:)[]         --   the tails (tails of [1,2,3] are [[1,2,3],[2,3],[3],[]])
      tail          --   of the tail of
          cycle     --   and infinite cycle of the input list
                    -- with the function
 (sum.).take        --   take that many elements given by the element
                    --   of the input list from the list given by the inits
                    --   and sum it   

05AB1E , 8 7 bytes

εL¾+èO¼

Pruébalo en línea!

Explicación

ε        # apply to each element x of the input
 L       # push range [1 ... x]
  ¾+     # add counter to each (initially 0)
    è    # cyclically index into input with each
     O   # sum
      ¼  # increment counter

K4 / K (oK) , 20 19 bytes

Solución:

+/'x#'1_(1+2##x)#x:

Pruébalo en línea!

Ejemplos:

q)k)+/'x#'1_(1+2##x)#x:1 3 4 5
3 10 13 14
q)k)+/'x#'1_(1+2##x)#x:4 3 2 1
10 7 5 4
q)k)+/'x#'1_(1+2##x)#x:3 2 4 3 2 1 1
9 7 7 4 2 1 3
q)k)+/'x#'1_(1+2##x)#x:1 2 3 4 5 4 3 2 1 2 3 4 3 2 1
2 7 13 14 12 8 5 3 2 7 9 7 4 2 1

Explicación:

Reformar la entrada, soltar primero, tomar x longitud de cada uno, resumir.

+/'x#'1_(1+2##x)#x: / the solution
                 x: / store input as x
                #   / reshape
        (      )    / do this together
             #x     / count x
           2#       / duplicate (2-take)
         1+         / add 1
      1_            / 1 drop (_), remove first element
   x#'              / x take each-both
+/'                 / sum (+/) each

Jalea , 7 bytes

R+"Jị⁸§

Pruébalo en línea!

Adjunto , 26 bytes

{Sum=>_[(_2+1:_)%#_]}#Iota

Pruébalo en línea!

Explicación

Esta es una bifurcación de dos funciones:

• {Sum=>_[(_2+1:_)%#_]}
• Iota

Lo que esto significa es que el diente derecho Iotase aplica al argumento xy se pasa como el segundo argumento al diente central (la primera función). Entonces esto se convierte, para entrada x:

{Sum=>_[(_2+1:_)%#_]}[x, Iota[x]]

Sustituyendo a aquellos por _y _2:

Sum => x[(Iota[x] + 1:x) % #x]

Iota[x]devuelve una matriz de los índices de x. Es equivalente a 0...#x. #xes una forma corta de decir el tamaño de xo Size[x]. En esencia, esta función está mapeando la Sumfunción sobre la segunda expresión:

x[(Iota[x] + 1:x) % #x]

El x[...]bit externo significa que ...generará una serie de índices para seleccionar x. La parte más importante de generar los índices es esta:

Iota[x] + 1:x

Esta expresión usa un poco de vectorización. Para visualizar esto, supongamos que la entrada es x := [1, 3, 4, 5]. Entonces, esta expresión es equivalente a:

Iota[[1, 3, 4, 5]] + 1:[1, 3, 4, 5]
[0, 1, 2, 3] + [1:1, 1:3, 1:4, 1:5]
[0, 1, 2, 3] + [[1], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
[0 + [1], 1 + [1, 2, 3], 2 + [1, 2, 3, 4], 3 + [1, 2, 3, 4, 5]]
[[0 + 1], [1 + 1, 1 + 2, 1 + 3], [2 + 1, 2 + 2, 2 + 3, 2 + 4], [3 + 1, 3 + 2, 3 + 3, 3 + 4, 3 + 5]]
[[1], [2, 3, 4], [3, 4, 5, 6], [4, 5, 6, 7, 8]]

Esta es una lista de índices que representan los siguientes Nelementos de índices en xmod #x. Para que sean seguros para su recuperación, tomamos este mod de matriz #x:

(Iota[x] + 1:x) % #x

Esto nos da los índices adecuados, que luego se obtienen de x y se suma cada matriz, dando los resultados adecuados.

Otros intentos

36 bytes: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Olvidé x[...]completamente vectorizar, por lo que se convierte en:

30 bytes: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - pero luego me di cuenta de que _2+en el rango interno se podía factorizar, lo que significa que podríamos guardar paréntesis usando en :lugar de .., dándonos la versión actual.

R , 89 64 bytes

j=rep(x<-scan(),max(x));Map(function(u,v)sum(j[v+1:u]),x,seq(x))

Pruébalo en línea!

La idea principal es generar un vector de índice de ciclo lo suficientemente largo que pueda usar para obtener los elementos necesarios del vector de entrada.

Versión original:

function(x,i=seq(x),j=rep(i,max(x))){for(k in i){T=c(T,sum(x[j[(k+1):(k+x[k])]]))};T[-1]}

Pruébalo en línea!

R , 62 58 bytes

function(a,l)diag(diffinv(matrix(a,max(a)*l+1,l))[a+2,])-a

Pruébalo en línea!

Una alternativa a la otra solución R . En los comentarios, JayCe mencionócumsum qué activó algo en mi cerebro para usar diffinvy reciclar la matriz en lugar de hacerlo rep.

Explicación:

Dada la matriz de entrada a, let M=max(a)y l=length(a).

Observe que ese M+les el índice máximo posible al que tendríamos que acceder, y que M+l<=M*l+1, dado que si M,l>1, M+l<=M*l(con igualdad solo cuando M=l=2) y si l==1o M==1, entonces M+l==M*l+1.

A modo de ejemplo, let a=c(4,3,2,1). Entonces M=l=4.

Construimos la M*l+1 x lmatriz en R por matrix(a,max(a)*l+1,l). Debido a que R se recicla aen el orden principal de la columna, terminamos con una matriz que repite los elementos acomo tales:

      [,1] [,2] [,3] [,4]
 [1,]    4    3    2    1
 [2,]    3    2    1    4
 [3,]    2    1    4    3
 [4,]    1    4    3    2
 [5,]    4    3    2    1
 [6,]    3    2    1    4
 [7,]    2    1    4    3
 [8,]    1    4    3    2
 [9,]    4    3    2    1
[10,]    3    2    1    4
[11,]    2    1    4    3
[12,]    1    4    3    2
[13,]    4    3    2    1
[14,]    3    2    1    4
[15,]    2    1    4    3
[16,]    1    4    3    2
[17,]    4    3    2    1

Cada columna son los sucesores cíclicos de cada elemento de a, con a através de la primera fila; Esto se debe a la forma en que R recicla sus argumentos en una matriz.

A continuación, tomamos la "derivada" inversa con diffinv, esencialmente la suma acumulativa de cada columna con un adicional 0como la primera fila, generando la matriz

      [,1] [,2] [,3] [,4]
 [1,]    0    0    0    0
 [2,]    4    3    2    1
 [3,]    7    5    3    5
 [4,]    9    6    7    8
 [5,]   10   10   10   10
 [6,]   14   13   12   11
 [7,]   17   15   13   15
 [8,]   19   16   17   18
 [9,]   20   20   20   20
[10,]   24   23   22   21
[11,]   27   25   23   25
[12,]   29   26   27   28
[13,]   30   30   30   30
[14,]   34   33   32   31
[15,]   37   35   33   35
[16,]   39   36   37   38
[17,]   40   40   40   40
[18,]   44   43   42   41

En la primera columna, la entrada 6=4+2es igual a 14=4 + (3+2+1+4), que es la suma de sucesor cíclico (CSS) más un encabezado 4. Del mismo modo, en la segunda columna, la entrada 5=3+2es igual a 10=3 + (4+1+2), y así sucesivamente.

Entonces, en la columna i, la a[i]+2entrada nd es igual a CSS(i)+a[i]. Por lo tanto, tomamos filas indexadas por a+2, dando una matriz cuadrada:

     [,1] [,2] [,3] [,4]
[1,]   14   13   12   11
[2,]   10   10   10   10
[3,]    9    6    7    8
[4,]    7    5    3    5

Las entradas a lo largo de la diagonal son iguales a las sumas cíclicas del sucesor más a, por lo que extraemos la diagonal y restamos a, devolviendo el resultado como las sumas cíclicas del sucesor.

Pyth, 13 11 bytes

.esm@Q+dkSb

Guardado 2 bytes gracias al Sr. Xcoder.
Pruébalo aquí

Explicación

.esm@Q+dkSb
.e         Q   For each index k and value b in (implicit) input...
         Sb    ... get the list [1, ..., b]...
   m  +dk      ... add k to each...
    @Q         ... and index into the input...
  s            ... then take the sum.

Carbón , 12 bytes

ＩＥθΣＥι§θ⊕⁺κλ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ             Input array
 Ｅ              Map over elements
     ι          Current element
    Ｅ           Map over implicit range
           λ    Inner index
          κ     Outer index
         ⁺      Sum
        ⊕       Increment
       θ        Input array
      §         Cyclically index
   Σ            Sum
Ｉ               Cast to string
                Implicitly print on separate lines

JavaScript ES6, 65 bytes

a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})

Solución directa. Sin golf:

a => a.map((x,y) => {
    var s = 0;
    for (i = y; i < y + x; i++) {
        s += a[i % a.length];
    }
    return s;
});

La map()función de JavaScript es perfecta para el trabajo, ejecuta la devolución de llamada dada contra cada elemento y la reemplaza por el resultado de la devolución de llamada. La devolución de llamada recibe dos parámetros, el primero xes el valor y el segundoy es el índice. Al tomar el módulo i % a.length, podemos recorrer fácilmente la matriz, varias veces si es necesario.

Fragmento de prueba

(Ponga la entrada como notación JSON)

let f = a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})

<input id=I type="text" size=70 value="[4,3,2,1]"><button onclick="console.log(f(JSON.parse(I.value)))">Run</button>

Java 8, 87 bytes

Un lambda vacío curry tomando una int[]lista y intlongitud.

l->s->{for(int i=-1,j,t;++i<s;System.out.println(t))for(j=t=0;j++<l[i];)t+=l[(i+j)%s];}

Pruébalo en línea . Tenga en cuenta que he seguido System.outeste programa para obtener resultados para una impresión más bonita.

Julia 0.6 , 63 55 53 bytes

A->[sum(repmat(A,v+1)[i+1:i+v])for(i,v)=enumerate(A)]

Pruébalo en línea!

Solución anterior:

Julia 0.6 , 65 bytes

A->(l=length(A);[sum(A[mod1(j,l)]for j∈i+1:i+A[i])for i∈1:l])

Pruébalo en línea!

Otra solución. No es bueno por bytecount, pero me gusta, y probablemente sea más eficiente que los otros dos, especialmente si la entrada tiene números grandes.

Julia 0.6 , 69 bytes

A->(l=length(A);[sum([A;A][i+1:i+A[i]%l])+A[i]÷l*sum(A)for i∈1:l])

Pruébalo en línea!

Lienzo , 10 bytes.

²Ｘ｛ｘ＋⁸＠］∑］

Pruébalo aquí!

Explicación:

{         ] map over the items in the input
 ²X           save this loops counter on X (because of a bad design choice..)
   {    ]     map over 1..current item
    x+          add to it X
      ⁸@        and index in the input using that
         ∑    sum the map

QBasic 1.1 , 115 bytes

INPUT L
DIM A(L)
FOR I=0TO L-1
INPUT C
A(I)=C
NEXT
FOR I=0TO L-1
S=0
FOR C=I+1TO I+A(I)
S=S+A(C MOD L)
NEXT
?S
NEXT

La primera entrada es la longitud L , luego las entradas posteriores L son los elementos en orden. Las salidas L representan la matriz resultante, con los elementos en el orden en que se presentan.

Japt, 7 bytes

ËÆg°EÃx

Pruébalo aquí

APL + WIN, 37 bytes

Solicitudes de entrada:

+/¨v↑¨⊂[2](⍳⍴v)⌽((⍴v),⍴n)⍴n←(+/v)⍴v←⎕

Pruébalo en línea! Cortesía de Dyalog Classic.

Explicación:

n←(+/v)⍴v←⎕ prompts for input and creates a repeating vector of length max v

((⍴v),⍴n)⍴n converts n to a matrix of length v x length n

(⍳⍴v)⌽ rotates each row of n by the size of each element of v

⊂[2] converts each row of m to an element in a nested vector

+/¨v↑¨ selects the number of elements from each element of the nested vector according to v and sums

Rubí , 38 bytes.

->a{w=0;a.map{|x|(a*-~x)[w+=1,x].sum}}

Pruébalo en línea!

JavaScript, 65 bytes 3̶0̶0̶ ̶b̶y̶t̶e̶s̶

golf

n=>n.map((z,x)=>{for(s=0,i=x;i<z+x;)s+=n[++i%n.length];return s})

sin golf

     f = n=>n.map((z,x)=>{
            for(s=0,i=x;i<z+x;)s+=n[++i%n.length];
            return s
            }
        );
console.log(f(process.argv[2].slice(1, -1).split(", ").map(x=>+x)))

Pruébalo en línea!

(versión no golfizada arriba) ¡Soy nuevo en esto del codegolf!

*¡actualizado! Gracias a los útiles enlaces proporcionados en los comentarios, ¡logré reducir el tamaño a 65 bytes!

Perl 5 con -M5.01042 bytes

say sum+((@F,@F)x$_)[++$-..($-+$_-1)]for@F

Pruébalo en línea!

JavaScript, 46 bytes

a=>a.map(g=(x,y)=>x--&&a[++y%a.length]+g(x,y))

Pruébalo en línea

Cjam, 23 bytes

_ee{~,\)f+1$f=:+\}/;]S*

Pruébalo en línea!

Pip -rn , 14 bytes

$+g@(_+\,B)MEg

Toma números de entrada en líneas sucesivas de stdin; da números de salida en líneas sucesivas de stdout.Pruébalo en línea!

Explicación

             g  List of lines of stdin (from -r flag)
           ME   Enumerate and map this function to the (index, value) pairs:
       \,B       One-based range(value)
     _+          To each element, add the index of that value
  g@(     )      Use the resulting range to slice into the original list g
                 (cyclical indexing is built in)
$+               Sum the numbers in the slice
                Output the list of results one per line (from -n flag)

O, usando un ejemplo trabajado:

             g  [1 3 4 5]
           ME   
       \,B      [(1,2) (1,4) (1,5) (1,6)]
     _+         [(1,2) (2,5) (3,7) (4,9)]
  g@(     )     [[3] [4 5 1] [5 1 3 4] [1 3 4 5 1]]
$+              [3 10 13 14]

APL (Dyalog Classic) , 12 bytes

+/¨⊢⍴¨⍳∘≢⌽¨⊂

Pruébalo en línea!

usos ⎕io←1

Perl 6 , 50 32 bytes

{$_>>.&{.[++$+ ^$^a X%+$_].sum}}

Pruébalo en línea!

Soy nuevo en el golf en Perl 6, así que estoy seguro de que esto puede ser más corto. ¡Ya no es nuevo y volvemos al golf!