Diesmal habe ich eine einfache Herausforderung für dich. Ersetzen Sie bei einem gegebenen Array positiver Ganzzahlen A (oder dem Äquivalent in Ihrer Sprache) jeden Eintrag A _i durch die Summe der nächsten A _i -Elemente von A und fahren Sie von Anfang an zurück, wenn nicht genügend Elemente vorhanden sind.

Wie üblich können Sie in jeder Programmiersprache antreten und Eingaben und Ausgaben mit jeder Standardmethode und in jedem vernünftigen Format vornehmen. Beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind. Optional können Sie auch die Größe von A als Eingabe verwenden. Dies ist Codegolf , daher gewinnt die kürzeste Übermittlung (in Bytes) für jede Sprache .

Beispiele / Testfälle

Gegeben [1,3,4,5], Code sollte eine Ausgabe [3,10,13,14], weil 1durch ersetzt wird 3, 3wird ersetzt durch 4+5+1=10( man beachte , wie es von Anfang an eingewickelt zurück), 4durch 5+1+3+4=13und 5durch 1+3+4+5+1=14.

Gegeben [3,2,1,9], Ihr Programm sollte produzieren [12,10,9,33], weil wir 3mit 2+1+9=12, 2mit 1+9=10, 1mit 9und 9mit ersetzen 3+2+1+9+3+2+1+9+3=33(beachten Sie, wie wir von Anfang an mehr als einmal zurückgebrochen haben).

Weitere Testfälle zur Auswahl:

[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

Probieren Sie es online!

	% 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

Gelee , 6 Bytes

ṙJṁS¥"

Probieren Sie es online!

Python , 55 Bytes

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

Probieren Sie es online!

J, 33 Bytes

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

ungolfed

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

Erläuterung

Probieren Sie es online!

C (GCC) , 86 85 Bytes

• Dank Jakob ein Byte gespeichert .

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

Probieren Sie es online!

Haskell, 50 47 44 Bytes

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

Probieren Sie es online!

                    -- <*> 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¼

Probieren Sie es online!

Erläuterung

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

Lösung:

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

Probieren Sie es online!

Beispiele:

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

Erläuterung:

Formen Sie die Eingabe um, lassen Sie sie zuerst fallen, nehmen Sie jeweils die x-Länge und addieren Sie sie.

+/'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

Gelee , 7 Bytes

R+"Jị⁸§

Probieren Sie es online!

Attache , 26 Bytes

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

Probieren Sie es online!

Erläuterung

Dies ist eine Gabelung von zwei Funktionen:

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

Dies bedeutet, dass der rechte Strich Iotaauf das Argument angewendet xund als zweites Argument an den mittleren Strich (die erste Funktion) übergeben wird. Also wird dies für die Eingabe x:

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

Ersetzen der in _und _2:

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

Iota[x]gibt ein Array der Indizes von zurück x. Es ist gleichbedeutend mit 0...#x. #xist eine kurze Beschreibung der Größe von xoder Size[x]. Im Wesentlichen ordnet diese Funktion die SumFunktion dem zweiten Ausdruck zu:

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

Das äußere x[...]Bit bedeutet, dass ...eine Reihe von Indizes generiert wird, aus denen ausgewählt werden kann x. Der wichtigste Teil bei der Erstellung der Indizes ist:

Iota[x] + 1:x

Dieser Ausdruck verwendet ein wenig Vektorisierung. Nehmen wir zur Veranschaulichung an, die Eingabe ist x := [1, 3, 4, 5]. Dann ist dieser Ausdruck äquivalent zu:

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

Dies ist eine Liste von Indizes, die die nächsten NElemente in xmod darstellen #x. Um sie für den Abruf sicher zu machen, verwenden wir diesen Array-Mod #x:

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

Dies gibt uns die richtigen Indizes, die dann erhalten werden x und jedes Array wird summiert, was die richtigen Ergebnisse ergibt.

Andere Versuche

36 Bytes: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Ich habe die x[...]Vektorisierung komplett vergessen , so dass:

30 bytes: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - aber dann wurde mir klar, dass der _2+innere Bereich herausgerechnet werden konnte, was bedeutet, dass wir Klammern sparen konnten , indem wir :anstelle von ..die aktuelle Version gaben.

R , 89 64 Bytes

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

Probieren Sie es online!

Hauptidee, um einen ausreichend langen Zyklusindexvektor zu generieren, mit dem Sie die erforderlichen Elemente aus dem Eingabevektor abrufen können.

Originalfassung:

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

Probieren Sie es online!

R , 62 58 Bytes

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

Probieren Sie es online!

Eine Alternative zur anderen R-Lösung . In den Kommentaren erwähnte JayCe,cumsum was etwas in meinem Gehirn auslöste, um diffinvMatrix-Recycling statt zu verwenden rep.

Erläuterung:

Gegebenes Eingabearray a lassen M=max(a)und l=length(a).

Beachten Sie, dass M+ldie maximal mögliche Index wir Zugang bräuchten, und das M+l<=M*l+1, denn wenn M,l>1, M+l<=M*l(mit Gleichheit nur dann , wennM=l=2 ) und wenn l==1oder M==1, dann M+l==M*l+1.

Beispielhaft sei gesagt a=c(4,3,2,1). Dann M=l=4.

Wir konstruieren die M*l+1 x lMatrix in R durch matrix(a,max(a)*l+1,l). Da R ain der Hauptreihenfolge der Spalten recycelt wird, erhalten wir eine Matrix, die die Elemente von wiederholta als solche :

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

Jede Spalte ist der zyklische Nachfolger jedes Elements von a , mit aüber die erste Zeile; Dies liegt an der Art und Weise, wie R seine Argumente in einer Matrix wiederverwendet.

Als nächstes nehmen wir die inverse "Ableitung" diffinv, im wesentlichen die kumulative Summe jeder Spalte mit einer zusätzlichen 0als erste Zeile, die die Matrix erzeugt

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

In der ersten Spalte ist der Eintrag 6=4+2gleich 14=4 + (3+2+1+4), dh die zyklische Nachfolgesumme (CSS) plus eine führende 4. In ähnlicher Weise ist der Eintrag in der zweiten Spalte 5=3+2gleich 10=3 + (4+1+2)und so weiter.

In der Spalte iist der a[i]+2nd-Eintrag also gleich CSS(i)+a[i]. Daher nehmen wir Zeilen, die durch indiziert sind a+2, und ergeben eine quadratische Matrix:

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

Die Einträge entlang der Diagonale sind gleich den zyklischen Nachfolgersummen plus a, also extrahieren wir die Diagonale und subtrahieren aund geben das Ergebnis als zyklische Nachfolgersummen zurück.

Pyth, 13 11 Bytes

.esm@Q+dkSb

2 Bytes gespart dank Mr. Xcoder.
Probieren Sie es hier aus

Erläuterung

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

Kohle , 12 Bytes

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

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

  θ             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 Byte

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

Einfache Lösung. Ungolfed:

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

Die JavaScript- map()Funktion ist perfekt für den Job. Sie führt den angegebenen Rückruf für jedes Element aus und ersetzt ihn durch das Ergebnis des Rückrufs. Der Rückruf empfängt zwei Parameter, der erste xist der Wert und der zweite yist der Index. Durch Ermitteln des Moduls können i % a.lengthwir das Array bei Bedarf problemlos mehrmals durchlaufen.

Testschnipsel

(Setzen Sie die Eingabe als JSON-Notation)

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

Ein Curry-Lambda ohne Inhalt, das eine int[]Liste und eine intLänge annimmt .

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

Probieren Sie es online . Beachten Sie, dass ich System.outin diesem Programm einen Shadow erstellt habe , um die Ergebnisse für einen schöneren Ausdruck zu erhalten.

Julia 0,6 , 63 55 53 Bytes

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

Probieren Sie es online!

Ältere Lösung:

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

Probieren Sie es online!

Eine andere Lösung. Von bytecount nicht besonders gut, aber ich mag es und es ist wahrscheinlich effizienter als die anderen beiden, besonders wenn der Eingang große Zahlen enthält.

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

Probieren Sie es online!

Canvas , 10 Bytes

²Ｘ｛ｘ＋⁸＠］∑］

Probieren Sie es hier aus!

Erläuterung:

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

Erste Eingabe ist die Länge L , dann L nachfolgende Eingaben sind die Elemente in der Reihenfolge. L Ausgaben repräsentieren das resultierende Array mit den Elementen in der Reihenfolge, in der sie dargestellt werden.

Japt, 7 Bytes

ËÆg°EÃx

Probieren Sie es hier aus

APL + WIN, 37 Bytes

Eingabeaufforderungen:

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

Probieren Sie es online! Mit freundlicher Genehmigung von Dyalog Classic

Erläuterung:

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

Ruby , 38 Bytes

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

Probieren Sie es online!

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

Golf gespielt

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

ungolfed

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

Probieren Sie es online!

Ich bin neu in dieser Codegolf-Sache!

*aktualisiert! Dank der nützlichen Links in den Kommentaren konnte ich die Größe auf 65 Bytes reduzieren!

Perl 5 mit -M5.01042 Bytes

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

Probieren Sie es online!

JavaScript, 46 Bytes

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

Probieren Sie es online aus

Cjam, 23 Bytes

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

Probieren Sie es online!

Pip -rn , 14 Bytes

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

Nimmt Eingabenummern in aufeinanderfolgenden Zeilen von stdin an; gibt Ausgangsnummern in aufeinanderfolgenden Zeilen von stdout aus.Probieren Sie es online!

Erläuterung

             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)

Oder anhand eines Beispiels:

             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 Byte

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

Probieren Sie es online!

Verwendet ⎕io←1

Perl 6 , 50 32 Bytes

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

Probieren Sie es online!

Ich bin neu beim Golfen in Perl 6, daher bin ich mir sicher, dass dies kürzer sein kann. Nicht mehr neu und zurück zum Golfen!