คราวนี้ฉันมีความท้าทายที่ง่ายสำหรับคุณ กำหนดอาร์เรย์ของจำนวนเต็มบวกA (หรือเทียบเท่าในภาษาของคุณ), แทนที่แต่ละรายการA _iด้วยผลรวมขององค์ประกอบA _iถัดไปของA , การวนกลับจากจุดเริ่มต้นหากมีรายการไม่เพียงพอ

ตามปกติคุณสามารถแข่งขันในภาษาการเขียนโปรแกรมใด ๆและสามารถรับอินพุตและให้ผลลัพธ์ผ่านวิธีมาตรฐานใด ๆและในรูปแบบที่เหมาะสมในขณะที่การทราบว่าช่องโหว่เหล่านี้ถูกห้ามโดยค่าเริ่มต้น คุณสามารถเลือกใช้ขนาดของAเป็นอินพุตได้เช่นกัน นี่คือรหัสกอล์ฟดังนั้นการส่งสั้นที่สุด (เป็นไบต์) สำหรับทุกภาษาที่ชนะ

ตัวอย่าง / กรณีทดสอบ

ได้รับ[1,3,4,5]รหัสของคุณควรส่งออก[3,10,13,14]เพราะ1ถูกแทนที่ด้วย3, 3จะถูกแทนที่ด้วย4+5+1=10(แจ้งให้ทราบวิธีการที่จะห่อกลับมาจากจุดเริ่มต้น) 4โดย5+1+3+4=13และโดย51+3+4+5+1=14

ได้รับ[3,2,1,9]โปรแกรมของคุณควรผลิต[12,10,9,33]เพราะเราแทน3ด้วย2+1+9=12, 2กับ1+9=10, 1ด้วย9และ9ด้วย3+2+1+9+3+2+1+9+3=33(แจ้งให้ทราบวิธีการที่เราห่อกลับมาจากการเริ่มต้นมากกว่าหนึ่งครั้ง)

กรณีทดสอบเพิ่มเติมให้คุณเลือกจาก:

[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 ไบต์

"G@:X@+)s

ลองออนไลน์!

	% 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

เยลลี่ 6 ไบต์

ṙJṁS¥"

ลองออนไลน์!

Pythonขนาด 55 ไบต์

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

ลองออนไลน์!

J, 33 ไบต์

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

ungolfed

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

คำอธิบาย

ลองออนไลน์!

C (gcc) , 86 85 ไบต์

• บันทึกขอบคุณไบต์จาคอบ

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

ลองออนไลน์!

Haskell, 50 47 44 ไบต์

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

ลองออนไลน์!

                    -- <*> 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 ไบต์

εL¾+èO¼

ลองออนไลน์!

คำอธิบาย

ε        # 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 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

ตัวอย่าง:

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

คำอธิบาย:

Reshape input, drop first, take x Length

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

เยลลี่ขนาด 7 ไบต์

R+"Jị⁸§

ลองออนไลน์!

ทูตขนาด 26 ไบต์

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

ลองออนไลน์!

คำอธิบาย

นี่เป็นทางแยกของสองฟังก์ชั่น:

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

สิ่งนี้หมายความว่าอะไรขวากหนามIotaถูกนำไปใช้กับการโต้แย้งxและถูกส่งผ่านเป็นอาร์กิวเมนต์ที่สองในการขวากหนามตรงกลาง (ฟังก์ชั่นแรก) ดังนั้นสิ่งนี้จะกลายเป็นข้อมูลเข้าx:

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

แทนที่ผู้ที่อยู่ใน_และ_2:

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

Iota[x]xส่งกลับอาร์เรย์ของดัชนีของที่ 0...#xมันเทียบเท่ากับ #xเป็นวิธีที่สั้น ๆ บอกขนาดของหรือx Size[x]ในสาระสำคัญฟังก์ชั่นนี้คือการทำแผนที่Sumฟังก์ชั่นมากกว่าการแสดงออกที่สอง:

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

ด้านนอกx[...]หมายถึงบิตที่จะสร้างชุดของดัชนีที่ได้รับเลือกจาก... xส่วนที่สำคัญที่สุดในการสร้างดัชนีคือ:

Iota[x] + 1:x

นิพจน์นี้ใช้ vectorization เล็กน้อย x := [1, 3, 4, 5]จะเห็นภาพนี้สมมติใส่เป็น จากนั้นนิพจน์นี้เทียบเท่ากับ:

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

นี่คือรายการของดัชนีซึ่งเป็นตัวแทนของดัชนีที่อยู่ถัดจากNองค์ประกอบในสมัยx #xเพื่อให้ปลอดภัยสำหรับการเรียกคืนเราใช้ mod array นี้#x:

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

สิ่งนี้ทำให้เรามีดัชนีที่เหมาะสมซึ่งจะได้รับจากxและแต่ละอาร์เรย์จะถูกรวมเข้าด้วยกันทำให้ได้ผลลัพธ์ที่เหมาะสม

ความพยายามอื่น ๆ

36 ไบต์: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - ฉันลืมx[...]vectorizes อย่างเต็มที่ดังนั้นจึงกลายเป็น:

30 ไบต์: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - แต่จากนั้นฉันก็รู้ว่า_2+ในขอบเขตภายในสามารถแยกออกเป็นส่วน ๆ ได้ซึ่งหมายความว่าเราสามารถบันทึกวงเล็บโดยใช้:แทน..ทำให้เราเป็นรุ่นปัจจุบัน

R , 89 64 ไบต์

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

ลองออนไลน์!

แนวคิดหลักในการสร้างเวกเตอร์ดัชนีการขี่จักรยานทางยาวพอคุณสามารถใช้เพื่อรับองค์ประกอบที่จำเป็นจากเวกเตอร์อินพุต

รุ่นเดิม:

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

ลองออนไลน์!

R , 62 58 ไบต์

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

ลองออนไลน์!

ทางเลือกที่จะแก้ปัญหา R อื่น ๆ ในการแสดงความคิดเห็นJayce ได้พูดถึงของcumsumที่เรียกสิ่งที่อยู่ในสมองของฉันกับการใช้งานและการรีไซเคิลเมทริกซ์แทนdiffinvrep

คำอธิบาย:

เข้าแถวที่กำหนดaให้และM=max(a)l=length(a)

สังเกตว่าM+lเป็นดัชนีที่เป็นไปได้สูงสุดที่เราจะต้องเข้าถึงและนั่นM+l<=M*l+1เพราะถ้าM,l>1, M+l<=M*l(ที่มีความเท่าเทียมกันเฉพาะเมื่อM=l=2) และถ้าl==1หรือแล้วM==1M+l==M*l+1

a=c(4,3,2,1)โดยวิธีการเช่นให้ M=l=4แล้วก็

เราสร้างเมทริกซ์ในการวิจัยโดยM*l+1 x l matrix(a,max(a)*l+1,l)เนื่องจาก R วนรอบaในลำดับคอลัมน์ที่สำคัญเราจึงสิ้นสุดด้วยเมทริกซ์ที่ทำซ้ำองค์ประกอบของaเช่น:

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

แต่ละคอลัมน์เป็นผู้สืบทอดที่เป็นวงกลมของแต่ละองค์ประกอบaโดยมีaแถวแรกอยู่ นี่เป็นเพราะวิธีการที่ R วนรอบอาร์กิวเมนต์ในเมทริกซ์

ต่อไปเราจะใช้ "อนุพันธ์" ผกผันกับdiffinvเป็นผลรวมสะสมของแต่ละคอลัมน์โดยมีการเพิ่มเติม0เป็นแถวแรกสร้างเมทริกซ์

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

ในคอลัมน์แรกรายการ6=4+2เท่ากับ14=4 + (3+2+1+4)ซึ่งเป็นผลรวมของการสืบทอดต่อเนื่อง (CSS) บวกกับการนำ4หน้า เช่นเดียวกันในคอลัมน์ที่สองรายการ5=3+2เท่ากับ10=3 + (4+1+2)และอื่น ๆ

ดังนั้นในคอลัมน์iที่รายการครั้งจะมีค่าเท่ากับa[i]+2 CSS(i)+a[i]ดังนั้นเราจึงจัดทำดัชนีแถวโดยa+2ให้เมทริกซ์จตุรัส:

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

ผลรวมของเส้นทแยงมุมเท่ากับผลรวมของตัวตายตัวแทนแบบวนรอบบวกaดังนั้นเราจึงแยกเส้นทแยงมุมและลบออกaแล้วคืนผลลัพธ์เป็นผลรวมของตัวต่อแบบวนรอบ

Pyth, 13 11 ไบต์

.esm@Q+dkSb

บันทึก 2 ไบต์ต้องขอบคุณ Mr. Xcoder
ลองที่นี่

คำอธิบาย

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

ถ่าน 12 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

  θ             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 ไบต์

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

ทางออกที่ตรงไปตรงมา Ungolfed:

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

map()ฟังก์ชั่นของจาวาสคริปต์นั้นสมบูรณ์แบบสำหรับงานมันรันการเรียกกลับที่กำหนดกับแต่ละองค์ประกอบและแทนที่ด้วยผลของการติดต่อ การเรียกกลับได้รับสองพารามิเตอร์ตัวแรกxคือค่าและตัวที่สองyคือดัชนี โดยการใช้โมดูลัสi % a.lengthเราสามารถวนซ้ำอาร์เรย์ได้หลายครั้งหากจำเป็น

ตัวอย่างการทดสอบ

(ใส่อินพุตเป็นสัญลักษณ์ 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 ไบต์

แลมบ์ดาโมฆะที่โค้งมนเป็นint[]รายการและintความยาว

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

ลองออนไลน์ โปรดทราบว่าฉันได้แชโดว์System.outในโปรแกรมนี้เพื่อรับผลการพิมพ์ที่สวยกว่า

Julia 0.6 , 63 55 53 ไบต์

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

ลองออนไลน์!

วิธีแก้ปัญหาที่เก่ากว่า:

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

ลองออนไลน์!

ทางออกอื่น ไม่ดีเท่า bytecount แต่ฉันชอบและอาจมีประสิทธิภาพมากกว่าอีกสองโดยเฉพาะถ้าอินพุตมีจำนวนมาก

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

ลองออนไลน์!

Canvas ขนาด 10 ไบต์

²Ｘ｛ｘ＋⁸＠］∑］

ลองที่นี่!

คำอธิบาย:

{         ] 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 ไบต์

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

อินพุตแรกคือความยาวLจากนั้นLอินพุตที่ตามมาคือองค์ประกอบตามลำดับ เอาต์พุตLแสดงอาร์เรย์ที่เกิดขึ้นพร้อมองค์ประกอบตามลำดับที่เสนอ

Japtap, 7 ไบต์

ËÆg°EÃx

ลองที่นี่

APL + WIN, 37 ไบต์

พรอมต์สำหรับอินพุต:

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

ลองออนไลน์! ความอนุเคราะห์จาก Dyalog Classic

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

JavaScript, 65 ไบต์3̶0̶0̶̶b̶y̶t̶e̶s̶

แข็งแรงเล่นกอล์ฟ

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

ลองออนไลน์!

(เวอร์ชั่นที่ไม่ได้กล่าวไว้ข้างต้น) ฉันยังใหม่กับสิ่งที่เป็น codegolf

* อัพเดท! ขอบคุณลิงค์ที่มีประโยชน์ที่ให้ไว้ในความคิดเห็นฉันจัดการเพื่อลดขนาดถึง 65 ไบต์!

Perl 5กับ-M5.010, 42 ไบต์

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

ลองออนไลน์!

JavaScript ขนาด 46 ไบต์

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

ลองออนไลน์

Cjam, 23 ไบต์

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

ลองออนไลน์!

Pip -rnขนาด 14 ไบต์

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

ใช้หมายเลขอินพุตบนบรรทัดต่อเนื่องของ stdin; ให้หมายเลขเอาต์พุตบนบรรทัดต่อเนื่องของ stdout ลองออนไลน์!

คำอธิบาย

             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)

หรือใช้ตัวอย่างที่ทำงาน:

             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 ไบต์

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

ลองออนไลน์!

การใช้งาน ⎕io←1

Perl 6 , 50 32 ไบต์

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

ลองออนไลน์!

ฉันใหม่กับการเล่นกอล์ฟใน Perl 6 ดังนั้นฉันแน่ใจว่านี่จะสั้นกว่านี้ ไม่ใช่เรื่องใหม่อีกต่อไปแล้วกลับไปเล่นกอล์ฟนี้!