Tôi có một thử thách đơn giản cho bạn lần này. Đưa ra một mảng các số nguyên dương A (hoặc tương đương trong ngôn ngữ của bạn), thay thế mỗi mục A _i bằng tổng các phần tử A _i tiếp theo của A , quay trở lại từ đầu nếu không có đủ các mục.

Như thường lệ, bạn có thể cạnh tranh trong bất kỳ ngôn ngữ lập trình nào và có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào và ở bất kỳ định dạng hợp lý nào, trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Bạn cũng có thể lấy kích thước của A làm đầu vào. Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất (tính bằng byte) cho mọi ngôn ngữ sẽ thắng.

Ví dụ / Trường hợp kiểm tra

Cho trước [1,3,4,5], mã của bạn sẽ xuất ra [3,10,13,14], bởi vì 1được thay thế bởi 3, 3được thay thế bằng 4+5+1=10(chú ý cách nó được bọc lại từ đầu), 4bởi 5+1+3+4=13và 5bởi 1+3+4+5+1=14.

Cho [3,2,1,9], chương trình của bạn sẽ sản xuất [12,10,9,33], bởi vì chúng tôi thay thế 3bằng 2+1+9=12, 2với 1+9=10, 1bằng 9và 9bằng3+2+1+9+3+2+1+9+3=33 (thông báo cách thức chúng tôi quấn lại từ đầu nhiều hơn một lần).

Một số trường hợp thử nghiệm khác để bạn lựa chọn:

[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

Hãy thử trực tuyến!

	% 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

Thạch , 6 byte

ṙJṁS¥"

Hãy thử trực tuyến!

Python , 55 byte

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

Hãy thử trực tuyến!

J, 33 byte

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

vô dụng

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

giải trình

Hãy thử trực tuyến!

C (gcc) , 86 85 byte

• Đã lưu một byte nhờ 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]);}

Hãy thử trực tuyến!

Haskell, 50 47 44 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Giải trình

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

Dung dịch:

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

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Định hình lại đầu vào, thả trước, lấy x chiều dài của mỗi cái, tổng hợp lại.

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

Thạch , 7 byte

R+"Jị⁸§

Hãy thử trực tuyến!

Tùy viên , 26 byte

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

Hãy thử trực tuyến!

Giải trình

Đây là một nhánh của hai chức năng:

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

Điều này có nghĩa là, tine phải Iotađược áp dụng cho đối số xvà được truyền làm đối số thứ hai cho tine trung tâm (hàm đầu tiên). Vì vậy, điều này trở thành, cho đầu vào x:

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

Thay thế những người trong _và _2:

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

Iota[x]trả về một mảng các chỉ số của x. Nó tương đương với 0...#x. #xlà một cách ngắn để nói kích thước của x, hoặc Size[x]. Về bản chất, hàm này đang ánh xạ Sumhàm qua biểu thức thứ hai:

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

x[...]Bit bên ngoài có nghĩa là ...sẽ tạo ra một loạt các chỉ mục được chọn từ đó x. Phần quan trọng nhất của việc tạo các chỉ số là:

Iota[x] + 1:x

Biểu thức này sử dụng một chút vector hóa. Để hình dung điều này, hãy giả sử đầu vào là x := [1, 3, 4, 5]. Sau đó, biểu thức này tương đương với:

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

Đây là danh sách các chỉ số đại diện cho các chỉ số Nphần tử tiếp theo trong xmod #x. Để làm cho chúng an toàn để truy xuất, chúng tôi sử dụng mod mảng này #x:

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

Điều này cho chúng ta các chỉ số thích hợp, sau đó được lấy từ x và mỗi mảng được tính tổng, cho kết quả phù hợp.

Những nỗ lực khác

36 byte: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - Tôi quên x[...]hoàn toàn vector hóa, do đó trở thành:

30 byte: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - nhưng sau đó tôi nhận ra _2+trong phạm vi bên trong có thể được tính ra, điều đó có nghĩa là chúng ta có thể lưu dấu ngoặc đơn bằng cách sử dụng :thay vì .., cung cấp cho chúng tôi phiên bản hiện tại.

R , 89 64 byte

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

Hãy thử trực tuyến!

Ý tưởng chính để tạo ra một vectơ chỉ số chu kỳ đủ dài mà bạn có thể sử dụng để lấy các phần tử cần thiết từ vectơ đầu vào.

Phiên bản gốc:

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

Hãy thử trực tuyến!

R , 62 58 byte

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

Hãy thử trực tuyến!

Một thay thế cho giải pháp R khác . Trong các bình luận, JayCe đã đề cập đến việccumsum kích hoạt thứ gì đó trong não tôi để sử dụng diffinvvà tái chế ma trận thay vìrep .

Giải trình:

Cho mảng đầu vào a, hãy M=max(a)vàl=length(a) .

Quan sát rằng đó M+llà chỉ số tối đa có thể chúng ta cần truy cập, và rằng M+l<=M*l+1, vì nếu M,l>1, M+l<=M*l(chỉ với đẳng thức khi M=l=2) và nếu l==1hoặc M==1, sau đóM+l==M*l+1 .

Bằng cách ví dụ, hãy a=c(4,3,2,1). Sau đóM=l=4 .

Chúng tôi xây dựng M*l+1 x lma trận trong R bằng matrix(a,max(a)*l+1,l). Vì R tái chế atheo thứ tự chính của cột, nên chúng tôi kết thúc bằng một ma trận lặp lại các phần tử anhư sau:

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

Mỗi cột là sự kế thừa theo chu kỳ của từng yếu tố a, với ahàng đầu tiên; điều này là do cách R tái chế các đối số của nó trong một ma trận.

Tiếp theo, chúng tôi lấy "đạo hàm" nghịch đảo diffinv, về cơ bản là tổng tích lũy của mỗi cột với một bổ sung 0là hàng đầu tiên, tạo ra ma trận

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

Trong cột đầu tiên, mục 6=4+2 bằng 14=4 + (3+2+1+4), là tổng kế tiếp theo chu kỳ (CSS) cộng với một đầu 4. Tương tự, trong cột thứ hai, mục nhập 5=3+2bằng 10=3 + (4+1+2)và vv.

Vì vậy, trong cột i , a[i]+2mục thứ hai bằng CSS(i)+a[i]. Do đó, chúng tôi lấy các hàng được lập chỉ mục bởi a+2, thu được một ma trận vuông:

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

Các mục dọc theo đường chéo bằng với tổng kế tiếp theo chu kỳ cộng a, vì vậy chúng tôi trích xuất đường chéo và phép trừa , trả về kết quả là tổng của người kế tiếp theo chu kỳ.

Bình thường, 13 11 byte

.esm@Q+dkSb

Lưu được 2 byte nhờ ông Xcoder.
Hãy thử nó ở đây

Giải trình

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

Than , 12 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Giải pháp đơn giản. Ung dung:

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

map()Hàm của JavaScript hoàn hảo cho công việc, nó chạy hàm gọi lại đã cho đối với từng phần tử và thay thế nó bằng kết quả của hàm gọi lại. Cuộc gọi lại nhận được hai tham số, đầu tiên xlà giá trị và thứ hai ylà chỉ mục. Bằng cách lấy mô-đuni % a.length chúng ta có thể dễ dàng lặp qua mảng, nhiều lần nếu cần.

Kiểm tra đoạn

(Đặt đầu vào là ký hiệu 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

Một lambda void curried lấy một int[]danh sách và intchiều dài.

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

Dùng thử trực tuyến . Lưu ý rằng tôi đã theo dõi System.outchương trình này để lấy kết quả cho việc in ấn đẹp hơn.

Julia 0,6 , 63 55 53 byte

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

Hãy thử trực tuyến!

Giải pháp cũ hơn:

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

Hãy thử trực tuyến!

Giải pháp khác. Không tuyệt vời bởi bytecount, nhưng tôi thích nó, và nó có thể hiệu quả hơn hai cái kia, đặc biệt nếu đầu vào có số lượng lớn.

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

Hãy thử trực tuyến!

Canvas , 10 byte

²Ｘ｛ｘ＋⁸＠］∑］

Hãy thử nó ở đây!

Giải trình:

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

Đầu vào đầu tiên là chiều dài L , sau đó L đầu vào tiếp theo là các yếu tố theo thứ tự. Đầu ra L đại diện cho mảng kết quả, với các yếu tố theo thứ tự chúng được trình bày.

Japt, 7 byte

ËÆg°EÃx

Hãy thử nó ở đây

APL + THẮNG, 37 byte

Lời nhắc cho đầu vào:

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

Hãy thử trực tuyến! Lịch sự của Dyalog Classic

Giải trình:

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

Hãy thử trực tuyến!

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

đánh gôn

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

vô dụng

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

Hãy thử trực tuyến!

(phiên bản chưa được chỉnh sửa ở trên) Tôi chưa quen với thứ codegolf này!

* cập nhật! nhờ các liên kết hữu ích được cung cấp trong các bình luận, tôi đã quản lý để giảm kích thước xuống còn 65 byte!

Perl 5 với -M5.010, 42 byte

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

Hãy thử trực tuyến!

JavaScript, 46 byte

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

Dùng thử trực tuyến

Cjam, 23 byte

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

Hãy thử trực tuyến!

Pip -rn , 14 byte

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

Lấy số đầu vào trên các dòng liên tiếp của stdin; đưa ra số đầu ra trên các dòng xuất sắc liên tiếp. Hãy thử trực tuyến!

Giải trình

             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)

Hoặc, sử dụng một ví dụ hoạt động:

             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

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

Hãy thử trực tuyến!

sử dụng ⎕io←1

Perl 6 , 50 32 byte

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

Hãy thử trực tuyến!

Tôi mới chơi golf ở Perl 6, vì vậy tôi chắc chắn điều này có thể ngắn hơn. Không còn mới nữa, và quay lại chơi golf này!