이번에는 간단한 도전이 있습니다. 양의 정수의 배열을 지정해, (또는 해당 언어에 해당)를 각 항목의 교체 에게 _난을 다음의 합으로 의 _난의 요소 충분히 항목이없는 경우 처음부터 다시 순환.

평소와 같이 모든 프로그래밍 언어로 경쟁 할 수 있으며 표준 방법을 통해 합리적인 형식으로 입력 및 출력을 제공 할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다. 선택적으로 A 의 크기 를 입력으로 사용할 수도 있습니다. 이것은 code-golf 이므로 모든 언어에 대한 가장 짧은 제출 (바이트)이 이깁니다.

예 / 테스트 사례

을 감안할 때 [1,3,4,5], 당신의 코드를 출력해야 [3,10,13,14]하기 때문에, 1로 대체 3, 3대체되고 4+5+1=10, (그것은 처음부터 다시 포장하는 방법 통지) 4에 의해 5+1+3+4=13과 5가 1+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¥"

온라인으로 사용해보십시오!

파이썬 , 55 바이트

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

온라인으로 사용해보십시오!

J, 33 바이트

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

언 골프

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

설명

온라인으로 사용해보십시오!

C (gcc) , 86 85 바이트

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

온라인으로 사용해보십시오!

하스켈, 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

설명:

입력을 재구성하고, 먼저 떨어 뜨리고, 각각의 x 길이를 취하고 요약하십시오.

+/'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의 크기를 말하는 짧은 방법입니다 . 본질적으로이 함수는 함수를 두 번째 표현식에 매핑합니다 .xSize[x]Sum

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

외부 x[...]비트는 ...에서 선택할 일련의 인덱스를 생성 한다는 의미입니다 x. 지수 생성에서 가장 중요한 부분은 다음과 같습니다.

Iota[x] + 1:x

이 표현식은 약간의 벡터화를 사용합니다. 이를 시각화하기 위해 입력이이라고 가정 해 봅시다 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]]

mod의 다음 N요소에 대한 인덱스를 나타내는 인덱스 목록입니다 . 검색을 안전하게하기 위해이 배열 모드를 사용합니다 .x#x#x

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

이를 통해 적절한 인덱스를 얻을 수 있으며,이 인덱스를 가져와 x각 배열을 합산하여 적절한 결과를 얻을 수 있습니다.

다른 시도

36 바이트 : {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - x[...]완전히 벡터화하는 것을 잊어 버렸습니다 .

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 내 뇌에서 무언가를 사용 diffinv하고 대신 매트릭스 재활용 을 유발 한 것에 대해 언급했습니다rep .

설명:

입력 배열이 주어지면 alet M=max(a)과 l=length(a).

이것이 M+l우리가 액세스해야하는 가능한 최대 인덱스이며 M+l<=M*l+1, if M,l>1, M+l<=M*l(when에만 동일하게 M=l=2) if l==1또는 M==1, then 이므로 관찰하십시오 M+l==M*l+1.

예를 들어 봅시다 a=c(4,3,2,1). 그런 다음 M=l=4.

우리 M*l+1 x l는 R에 의해 행렬을 구성합니다 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]+2nd 항목은 같습니다 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

Mr. Xcoder 덕분에 2 바이트를 절약했습니다.
여기 사용해보십시오

설명

.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

자바 스크립트 ES6, 65 바이트

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

간단한 솔루션. 언 골프 드 :

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

JavaScript의 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>

자바 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더 예쁘게 인쇄 할 수 있도록이 프로그램에서 그림자 를 표시했습니다.

줄리아 0.6 , 63 55 53 바이트

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

온라인으로 사용해보십시오!

이전 솔루션 :

줄리아 0.6 , 65 바이트

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

온라인으로 사용해보십시오!

또 다른 해결책. 바이트 수는 크지 않지만 좋아하지만 입력에 큰 숫자가있는 경우 다른 두 개보다 효율적입니다.

줄리아 0.6 , 69 바이트

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

온라인으로 사용해보십시오!

캔버스 , 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 출력은 결과 배열을 나타내며 요소는 제시된 순서대로 나타납니다.

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

루비 , 38 바이트

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

온라인으로 사용해보십시오!

자바 스크립트, 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})

언 골프

     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 바이트로 줄일 수있었습니다!

펄 5 와 -M5.01042 바이트

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

온라인으로 사용해보십시오!

자바 스크립트, 46 바이트

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

온라인으로 사용해보십시오

잼, 23 바이트

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

온라인으로 사용해보십시오!

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

펄 6 , 50 32 바이트

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

온라인으로 사용해보십시오!

나는 Perl 6에서 골프를 처음 접했기 때문에 이것이 더 짧을 수 있다고 확신합니다. 더 이상 새로운 것이 아니며 다시 골프로 돌아옵니다!