Saya punya tantangan sederhana untuk Anda saat ini. Mengingat sebuah array bilangan bulat positif A (atau setara dalam bahasa Anda), ganti setiap entri A _i dengan jumlah berikutnya A _i unsur A , bersepeda kembali dari awal jika tidak ada cukup item.

Seperti biasa, Anda dapat bersaing dalam bahasa pemrograman apa pun dan dapat mengambil input dan memberikan output melalui metode standar apa pun dan dalam format apa pun yang wajar, sambil memperhatikan bahwa celah ini dilarang secara default. Anda juga dapat mengambil ukuran A sebagai input. Ini adalah kode-golf , jadi pengiriman terpendek (dalam byte) untuk setiap bahasa menang.

Contoh / Kasus Uji

Diberikan [1,3,4,5], kode Anda harus di-output [3,10,13,14], karena 1digantikan oleh 3, 3digantikan oleh 4+5+1=10(perhatikan bagaimana kode itu dibungkus kembali dari awal), 4oleh 5+1+3+4=13dan 5oleh 1+3+4+5+1=14.

Mengingat [3,2,1,9], program Anda harus menghasilkan [12,10,9,33], karena kami mengganti 3dengan 2+1+9=12, 2dengan 1+9=10, 1dengan 9dan 9dengan 3+2+1+9+3+2+1+9+3=33(perhatikan bagaimana kami kembali dari awal lebih dari sekali).

Beberapa kasus uji lagi untuk Anda pilih:

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

"G@:X@+)s

Cobalah 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

Jelly , 6 byte

ṙJṁS¥"

Cobalah online!

Python , 55 byte

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

Cobalah online!

J, 33 byte

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

ungolfed

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

penjelasan

Cobalah online!

C (gcc) , 86 85 byte

• Menyimpan satu byte berkat 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]);}

Cobalah online!

Haskell, 50 47 44 byte

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

Cobalah 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 byte

εL¾+èO¼

Cobalah online!

Penjelasan

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

Larutan:

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

Cobalah online!

Contoh:

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

Penjelasan:

Membentuk kembali input, drop pertama, ambil masing-masing x panjang, jumlahkan.

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

Jelly , 7 byte

R+"Jị⁸§

Cobalah online!

Attache , 26 byte

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

Cobalah online!

Penjelasan

Ini adalah fork dari dua fungsi:

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

Artinya, tine kanan Iotaditerapkan pada argumen xdan diteruskan sebagai argumen kedua ke tine tengah (fungsi pertama). Jadi ini menjadi, untuk masukan x:

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

Mengganti yang dalam untuk _dan _2:

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

Iota[x]mengembalikan array indeks x. Ini setara dengan 0...#x. #xadalah cara singkat untuk mengatakan ukuran x, atau Size[x]. Intinya, fungsi ini memetakan Sumfungsi pada ekspresi kedua:

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

x[...]Bit luar berarti yang ...akan menghasilkan serangkaian indeks untuk dipilih x. Bagian terpenting dari menghasilkan indeks adalah ini:

Iota[x] + 1:x

Ungkapan ini menggunakan sedikit vektorisasi. Untuk memvisualisasikan ini, anggaplah inputnya x := [1, 3, 4, 5]. Kemudian, ungkapan ini setara dengan:

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

Ini adalah daftar indeks yang mewakili Nelemen-elemen indeks berikutnya dalam xmod #x. Untuk membuatnya aman untuk pengambilan, kami menggunakan mod array ini #x:

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

Ini memberi kita indeks yang tepat, yang kemudian diperoleh dari xdan setiap array dijumlahkan, memberikan hasil yang tepat.

Upaya lain

36 byte: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Saya lupa x[...]sepenuhnya vektorisasi, sehingga menjadi:

30 byte: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - tapi kemudian saya menyadari bahwa _2+di bagian dalam dapat difaktorkan keluar, yang berarti kita bisa menyelamatkan tanda kurung dengan menggunakan :alih-alih .., memberi kita versi saat ini.

R , 89 64 byte

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

Cobalah online!

Gagasan utama untuk menghasilkan vektor indeks bersepeda yang cukup lama dapat Anda gunakan untuk mendapatkan elemen yang diperlukan dari vektor input.

Versi asli:

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

Cobalah online!

R , 62 58 byte

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

Cobalah online!

Alternatif untuk solusi R. lainnya . Dalam komentar, JayCe menyebutkancumsum yang memicu sesuatu di otak saya untuk menggunakan diffinvdan mendaur ulang matriks rep.

Penjelasan:

Input array yang diberikan a, biarkan M=max(a)dan l=length(a).

Perhatikan bahwa M+lindeks maksimum yang mungkin perlu kita akses, dan itu M+l<=M*l+1, karena jika M,l>1, M+l<=M*l(dengan kesetaraan hanya ketika M=l=2) dan jika l==1atau M==1, maka M+l==M*l+1.

Sebagai contoh, mari a=c(4,3,2,1). Lalu M=l=4.

Kami membangun M*l+1 x lmatriks dalam R oleh matrix(a,max(a)*l+1,l). Karena R mendaur ulang adalam urutan kolom-utama, kita berakhir dengan matriks yang mengulang elemen-elemen aseperti:

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

Setiap kolom adalah penerus siklik dari setiap elemen a, dengan amelintasi baris pertama; ini karena cara R mendaur ulang argumennya dalam sebuah matriks.

Selanjutnya, kita mengambil "turunan" terbalik dengan diffinv, pada dasarnya jumlah kumulatif setiap kolom dengan tambahan 0sebagai baris pertama, menghasilkan matriks

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

Di kolom pertama, entri 6=4+2sama dengan 14=4 + (3+2+1+4), yang merupakan jumlah penerus siklik (CSS) ditambah terkemuka 4. Demikian pula, di kolom kedua, entri 5=3+2sama dengan 10=3 + (4+1+2), dan sebagainya.

Jadi di kolom i, a[i]+2entri nd sama dengan CSS(i)+a[i]. Oleh karena itu, kami mengambil baris yang diindeks dengan a+2, menghasilkan matriks persegi:

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

Entri di sepanjang diagonal sama dengan jumlah penggantinya siklik plus a, jadi kami mengekstrak diagonal dan mengurangi a, mengembalikan hasilnya sebagai jumlah penggantinya siklik.

Pyth, 13 11 byte

.esm@Q+dkSb

Disimpan 2 byte berkat Tn. Xcoder.
Coba di sini

Penjelasan

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

Arang , 12 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

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

Solusi mudah. Tidak Disatukan:

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

map()Fungsi JavaScript sangat cocok untuk pekerjaan itu, ia menjalankan panggilan balik yang diberikan terhadap setiap elemen dan menggantinya dengan hasil panggilan balik tersebut. Callback menerima dua parameter, yang pertama xadalah nilai dan yang kedua yadalah indeks. Dengan mengambil modulus i % a.lengthkita dapat dengan mudah mengulang array, berkali-kali jika diperlukan.

Cuplikan tes

(Masukkan input sebagai notasi 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 byte

Lambda batal kari mengambil int[]daftar dan intpanjang.

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

Cobalah secara Online . Perhatikan bahwa saya telah dibayangi System.outdalam program ini untuk mendapatkan hasil untuk pencetakan yang lebih cantik.

Julia 0,6 , 63 55 53 byte

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

Cobalah online!

Solusi yang lebih lama:

Julia 0,6 , 65 byte

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

Cobalah online!

Solusi lain. Tidak hebat dengan bytecount, tapi saya suka, dan mungkin lebih efisien daripada dua lainnya, terutama jika inputnya memiliki angka besar.

Julia 0,6 , 69 byte

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

Cobalah online!

Kanvas , 10 byte

²Ｘ｛ｘ＋⁸＠］∑］

Coba di sini!

Penjelasan:

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

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

Input pertama adalah panjang L , kemudian input selanjutnya L adalah elemen dalam urutan. Output L mewakili array yang dihasilkan, dengan elemen-elemen dalam urutan yang disajikan.

Japt, 7 byte

ËÆg°EÃx

Coba di sini

APL + WIN, 37 byte

Anjuran untuk input:

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

Cobalah online! Atas perkenan Dyalog Classic

Penjelasan:

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 byte

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

Cobalah online!

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

bermain golf

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

Cobalah online!

(versi ungolfed di atas) Saya baru dengan hal codegolf ini!

* diperbarui! berkat tautan bermanfaat yang disediakan dalam komentar, saya berhasil mengurangi ukurannya menjadi 65 byte!

Perl 5 dengan -M5.010, 42 byte

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

Cobalah online!

JavaScript, 46 byte

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

Cobalah online

Cjam, 23 byte

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

Cobalah online!

Pip -rn , 14 byte

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

Mengambil nomor input pada garis stdin berturut-turut; memberikan nomor output pada garis stdout berturut-turut. Cobalah online!

Penjelasan

             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)

Atau, menggunakan contoh yang dikerjakan:

             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

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

Cobalah online!

menggunakan ⎕io←1

Perl 6 , 50 32 byte

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

Cobalah online!

Saya baru bermain golf di Perl 6, jadi saya yakin ini bisa lebih pendek. Tidak baru lagi, dan kembali ke golf ini!