직무

정수의리스트로부터 L 과 다른 정수 의 목표는 모두의 열 방향으로 합계를 계산한다 (S)의 - 길이 (잠재적으로 겹치는) 슬라이스 L을 행 상대적인 위치와 관련된 상태, L (아래 참조).

정의

S의 - 길이 (오버랩) 슬라이스 리스트의 L은 의 (포장)없이 모든 연속 시퀀스이다 L 길이이다 S .

하기 위해서는 위치와 관련된 조각의 의 에 상대적으로 L , 각 조각은 "사다리", 구축 상상 이야 _내가 의 오프셋 (offset) 한 나는 처음부터 위치를.

명세서

• s 는 1 보다 크고 L 의 길이보다 엄격히 작은 정수 입니다.
• L 은 항상 3 개 이상의 요소를 포함합니다.
• 모든 프로그래밍 언어로 경쟁 할 수 있으며 표준 방법을 통해 입력을 받고 출력을 제공 할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다. 이것은 code-golf 이므로 모든 언어에 대한 가장 짧은 제출 (바이트)이 이깁니다.

예 및 테스트 사례

다음은 작동하는 예입니다.

[1, 2, 3, 4, 5, 6, 7, 8, 9], 3

[1, 2, 3]
   [2, 3, 4]
      [3, 4, 5]
         [4, 5, 6]
            [5, 6, 7]
               [6, 7, 8]
                  [7, 8, 9]
-------------------------------- (+)  | column-wise summation
[1, 4, 9, 12, 15, 18, 21, 16, 9]

그리고 더 많은 테스트 사례 :

[1, 3, 12, 100, 23], 4         -> [1, 6, 24, 200, 23]
[3, -6, -9, 19, 2, 0], 2       -> [3, -12, -18, 38, 4, 0]
[5, 6, 7, 8, 2, -4, 7], 3      -> [5, 12, 21, 24, 6, -8, 7]
[1, 2, 3, 4, 5, 6, 7, 8, 9], 3 -> [1, 4, 9, 12, 15, 18, 21, 16, 9]
[1, 1, 1, 1, 1, 1, 1], 6       -> [1, 2, 2, 2, 2, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 8, 9], 6 -> [1, 4, 9, 16, 20, 24, 21, 16, 9]

J , 11, 9 8 바이트

마일로 -1 바이트!

[:+//.]\

어떻게 작동합니까?

왼쪽 인수는 s, 오른쪽 인수-L

]\ -길이가 s 인 하위 목록으로 L을 분할합니다.

/. -사선 대각선 추출 (대각선)

+/ -합산

[: -위의 동사에서 포크를 만듭니다.

첫 번째 테스트 사례에 대한 예제 J 세션은 다음과 같습니다.

   a =. 1 2 3 4 5 6 7 8 9

   ] 3 ]\ a 
1 2 3
2 3 4
3 4 5
4 5 6
5 6 7
6 7 8
7 8 9

   ] </. 3 ]\ a 
┌─┬───┬─────┬─────┬─────┬─────┬─────┬───┬─┐
│1│2 2│3 3 3│4 4 4│5 5 5│6 6 6│7 7 7│8 8│9│
└─┴───┴─────┴─────┴─────┴─────┴─────┴───┴─┘

   ] +//. 3 ]\ a 
1 4 9 12 15 18 21 16 9

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

하스켈 , 59 56 바이트

s#n=[x*minimum[n,i,length s+1-max i n]|(i,x)<-zip[1..]s]

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

(#)리스트 s와 숫자 n를 인수로 받는 함수 를 정의합니다 .

이것은 다음에 대한 관찰을 기반으로합니다. s = [1, 2, 3, 4, 5, 6, 7, 8, 9] 과n = 3

[1, 2, 3]
   [2, 3, 4]
      [3, 4, 5]
         [4, 5, 6]
            [5, 6, 7]
               [6, 7, 8]
                  [7, 8, 9]
---------------------------- (+)
[1, 4, 9,12,15,18,21,16, 9]

와 같다

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 3, 3, 3, 3, 2, 1]
---------------------------- (*)
[1, 4, 9,12,15,18,21,16, 9]

이것을 처음으로 증가시킨 다음 지속적으로 감소시키는 목록을 생성하기 위해

[minimum[i, length s + 1 - i] | i<-[1..length s]]

어느 것이 생산 [1, 2, 3, 4, 5, 4, 3, 2, 1]됩니다. 표현식에 n추가 제약 조건을 추가 하면 추가 제약 조건에 대한 minimum올바른 목록 [1, 2, 3, 3, 3, 3, 3, 2, 1]답변이 생성 n = 3됩니다 n = 6(또는 일반적으로 n > lengths s/2).length s + 1 - n 이 필요 .

[minimum[i, n, length s + 1 - i, length s + 1 - n] | i<-[1..length s]]

또는 더 짧은 :

[minimum[i, n, length s + 1 - max i n] | i<-[1..length s]]

쌍의 곱셈 [1..length s]은으로 압축되며 더 긴 목록을 더 짧은 목록의 길이로 자르기 s때문에 zip무한 목록을 [1..]사용할 수 있습니다.

[x * minimum[i, n, length s + 1 - max i n] | (i,x)<-zip[1..]s]

자바 스크립트 (ES6), 65 62 58 바이트

@Shaggy 덕분에 4 바이트 절약

카레 구문으로 입력을 (a)(n)받습니다.

a=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))

테스트 사례

let f =

a=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))

console.log(JSON.stringify(f([1, 3, 12, 100, 23]        )(4))) // [1, 6, 24, 200, 23]
console.log(JSON.stringify(f([3, -6, -9, 19, 2, 0]      )(2))) // [3, -12, -18, 38, 4, 0]
console.log(JSON.stringify(f([5, 6, 7, 8, 2, -4, 7]     )(3))) // [5, 12, 21, 24, 6, -8, 7]
console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9])(3))) // [1, 4, 9, 12, 15, 18, 21, 16, 9]
console.log(JSON.stringify(f([1, 1, 1, 1, 1, 1, 1]      )(6))) // [1, 2, 2, 2, 2, 2, 1]
console.log(JSON.stringify(f([1, 2, 3, 4, 5, 6, 7, 8, 9])(6))) // [1, 4, 9, 16, 20, 24, 21, 16, 9]

자바 8, 83 바이트

L->s->{for(int i=0,l=L.length+1,t,u;++i<l;u=l-(s>i?s:i),L[i-1]*=t<u?t:u)t=i<s?i:s;}

그 첫 번째 테스트 케이스 (그리고 내가 추가 한 마지막 두 개)는 여러 번 나를 망 쳤지 만 마침내 작동합니다. : : D

입력 배열을 새로 반환하지 않고 수정합니다.

설명:

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

L->s->{                  // Method with int-array and int parameters, and no return-type
  for(int i=0,           //  Index-integer, starting at 0
      l=L.length+1,      //  The length of the input-array + 1
      t,u;               //  Two temp integers
      ++i<l              //  Loop `i` from 1 to the length (inclusive)
      ;                  //    After every iteration:
       u=l               //     Set temp integer `u` to the length plus 1,
          -(s>i?s:i),    //     minus the highest of `s` and `i`
       L[i-1]*=t<u?t:u)  //     And replace the item with the lowest of `t` and `u`
    t=i<s?i:s;}          //   Set temp integer `t` to the lowest of `i` or `s`

05AB1E , 12 바이트

)IŒIùvyNÅ0ì+

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

MATL , 8 바이트

YCPT&Xds

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오. .

설명

입력 [1, 3, 12, 100, 23]과를 고려하십시오 4.

YC     % Implicit inputs: row vector L and number s. Create matrix of 
       % overlapping blocks of L with length s, where each block is a column
       % STACK: [  1   3;
                   3  12;
                  12 100;
                 100  23]
P      % Flip vertically
       % STACK: [100  23;
                  12 100;
                   3  12;
                   1   3]
&TXd   % Extract all diagonals, starting from bottom-left, and arrange them as
       % columns of a matrix, with zero padding
       % STACK: [1   3  12 100   0;
                 0   3  12 100  23]
s      % Sum of each column. Since s is less than the length of L, there are
       % at least two rows. Thus function `s` can be used instead of `Xs`.
       % Implicit display
       % STACK: [1   6  24 200  23]

APL (Dyalog Unicode) , 19 14 바이트 ^SBCS

ngn 덕분에 -5입니다.

s 를 왼쪽 인수로 사용하고 L 을 오른쪽 인수로 사용 하는 익명의 암묵적 삽입 함수 . 많은 시스템에서 기본값으로 설정 ⎕IO( I ndex O rigin)한다고 가정 0합니다.

+⌿∘↑((0,⊢)\,/)

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

예제 사례 설명 [1,3,12,100,23]

(… ) 다음 익명의 암묵적 기능을 적용하십시오.

 ,/ 해당 크기의 겹치는 창; [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ 다음 암묵적 암묵 기능을이 암묵적으로 누적 적용합니다.

  ⊢ 가장 오른쪽 주장

  0, 왼쪽에 0으로

누적 축소는 연속 된 용어 사이의 모든 "공간"에 함수를 삽입하여 오른쪽에서 왼쪽으로 진행 함을 의미합니다. 각 "공백"에 대해 함수는 왼쪽 인수를 버리고 추가 0을 추가합니다. 효과적으로, 이것은 왼쪽에 "공백"이있는 것처럼 각 항에 0을 추가하므로 첫 번째 항은 0의 공백을 얻고, 두 번째는 1을, 세 번째는 2를 얻습니다.[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ 목록을 단일 행렬로 결합하여 순위를 높이고 0으로 채 웁니다.
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ 그런 다음
+⌿ 세로 로 합산하십시오.[1,6,36,200,23]

젤리 , 6 바이트

JṡṬS×ḷ

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

작동 원리

JṡṬS×ḷ  Main link. Left argument: A (array). Right argument: n (integer)

J       Indices; yield [1, ..., len(A)].
 ṡ      Split the indices into overlapping slices of length n.
  Ṭ     Untruth; map each array of indices to a Boolean vector, with 1's at the
        specified indices and 0's elsewhere.
        For example, [3, 4, 5] maps to [0, 0, 1, 1, 1].
   S    Sum the rows, essentially counting how many times each index appears in
        the arrays returned by the ṡ atom.
     ḷ  Left; yield A.
    ×   Multiply the counts to the left with the integers to the right.

apt , 13 바이트

s> 이 작업을 수행하는 데 너무 오래 걸렸습니다 L/2.

Ë*°EmVUÊÄ-EwV

시도 해봐

설명

                 :Implicit input of array U and integer V
Ë                :Map over each element at 0-based index E in U
 *               :  Multiply by
    m            :  The minumum of
  °E             :    E incremented,
     V           :    V,
          EwV    :    and the maximum of E & V
         -       :    subtracted from
      UÊÄ        :    the length of U plus 1

Wolfram Language (Mathematica) , 42 바이트

Min[i,#2,l+1-{i,#2}]~Table~{i,l=Tr[1^#]}#&

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

줄리아 , 41 바이트

a\n=(a[L=end];a.*min(1:L,L:-1:1,n,L-n+1))

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

• \연산자를 재정의하십시오 .
• a[L=end]보다 짧은 대안 L=length(a)입니다.
• Laikoni의 방법을 사용합니다 .

apt , 13 12 바이트

@ETHproductions 덕분에 -1 바이트

ãV
ËEÆÃcDÃyx

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

R , 52 51 바이트

function(l,s)l*pmin(s,x<-seq(l),y<-rev(x),y[1]+1-s)

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

이것은 Laikoni의 답변 과 같습니다. .

seq(l)1...length(l)이후 인덱스를 생성합니다 length(l)>1(그렇지 않으면을 생성합니다 1...l[1]). 로 x저장하고 그 반대를로 저장하고 ( y의 첫 번째 요소를 가져옵니다.ylength(l) ) 하여 Laikoni의 답변을 깔끔하게 이식하고 바이트를 저장합니다!

원래 답변, 52 바이트

function(l,s,L=sum(l|1)+1)l*pmin(s,x<-2:L-1,L-x,L-s)

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

출력이된다 lelementwise 최소 곱하여 s, 소자의 1 기반의 인덱스 x, length(l)-x+1및 length(L)-s+1.

이것은 또한 Laikoni의 대답과 동일하며 짧게 사용하는 L-x대신 사용 합니다 rev(x).

APL + WIN, 25 바이트

L의 화면 입력 프롬프트와 s

+/(1-⍳⍴z)⌽¨(⍴L)↑¨s←⎕,/L←⎕

설명:

L←⎕ prompt for screen input of L

s←⎕,/ prompt for screen input of s and create nested vector of successive s elements of L

(⍴L)↑¨ pad each element of the nested vector with zeros to the length of L

(1-⍳⍴z)⌽¨ incrementally rotate each element of the nested vector

+/ sum the elements of the nested vector

K (oK) , 30 바이트

해결책:

{+/t,'(y':x),'|t:(!1-y-#x)#'0}

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

예:

{+/t,'(y':x),'|t:(!1-y-#x)#'0}[3 -6 -9 19 2 0;2]
3 -12 -18 38 4 0

설명:

내가 J 와 경쟁 할 수 있다고 생각하지 마십시오 . 슬라이딩 창 목록에 추가되고 앞에 추가 될 0 목록을 생성 한 다음 요약하십시오.

{ t,'(y':x),'|t:(!(#x)+1-y)#'0 }[1 2 3 4 5 6 7 8 9;3]
(1 2 3 0 0 0 0 0 0
 0 2 3 4 0 0 0 0 0
 0 0 3 4 5 0 0 0 0
 0 0 0 4 5 6 0 0 0
 0 0 0 0 5 6 7 0 0
 0 0 0 0 0 6 7 8 0
 0 0 0 0 0 0 7 8 9)

고장은 다음과 같습니다 ...하지만 여전히 서투른 느낌이 듭니다.

{+/t,'(y':x),'|t:(!1-y-#x)#'0} / the solution
{                            } / lambda taking x and y implicitly
                          #'0  / take (#) each (') zero
                 (       )     / do this together
                       #x      / count (#) length of x
                     y-        / take count away from length y
                   1-          / take that result from 1
                  !            / til, generate range to that number
               t:              / save in variable t
              |                / reverse it
            ,'                 / join with each
      (y':x)                   / sliding window size y over x
    ,'                         / join with each
   t                           / prepend t
 +/                            / sum up

껍질 , 4 바이트

mΣ∂X

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

Galen Ivanov의 J answer 아이디어를 사용합니다 .

설명

     -- implicit input number n and list s, e.g. s = [1,2,3,4,5,6] and n = 4 
   X -- get sublists of length n of list s           [[1,2,3,4],[2,3,4,5],[3,4,5,6]]
  ∂  -- anti-diagonals                               [[1],[2,2],[3,3,3],[4,4,4],[5,5],[6]]
mΣ   -- get the sum of each of the lists             [1,4,9,12,10,6]

C (gcc) , 100 바이트

j,x;f(L,l,s)int*L;{for(j=0;j<l;j++)L[j]*=j<s&j<l-s?-~j:j>s&j>l-s?l-j:(x=s<l-j?s:l-j)<l-~-s?x:l-~-s;}

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

파이썬 2 , 68 66 바이트

Laikoni 덕분에 -2 바이트

lambda l,n:[v*min(n,i+1,len(l)-max(i,n-1))for i,v in enumerate(l)]

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

펄 5 , 63 바이트

$b=<>;map{say$_*=$n+$b>@F?$n-$b<0?$i:--$i:$i<$b?++$i:$i;++$n}@F

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

C (gcc) , 83 81 79 바이트

기본적으로 목록 조작에는 램프 업, 서스테인 및 쿨 오프의 세 단계가 있습니다. 목록을 살펴보면 최대 값에 도달 할 때까지 요소를 증가시킵니다. 전체 슬라이스가 목록에 들어갈 수 있으면이 최대 길이는 슬라이스 길이와 같습니다. 그렇지 않으면 맞는 슬라이스 수와 같습니다. 다른 쪽 끝에서는 마지막 요소의 1에 도달하도록 계수를 다시 줄입니다.

이 고원을 북 엔드하는 램프 업 및 쿨 다운 단계의 길이는 최대 계수보다 1이 적습니다.

ungolfed 루프를 결합하기 전에 루프가 더 명확 해집니다 (R = 램프 업 위상 길이).

for (r = 1; r <= R; r++) L[r - 1] *= r;
for (; r < n - R; r++)   L[r - 1] *= R + 1;
for (; r < n; r++)       L[r - 1] *= n - r + 1;

세 개의 루프가 너무 많아서 r에 기반한 요소를 결정하면 하나의 루프를 얻게됩니다 (R에 대해 s를 사용하여 일부 바이트 저장)

r;f(L,n,s)int*L;{for(r=0,s=2*s-1>n?n-s:s-1;r++<n;)*L++*=r>s?r<n-s?s+1:n-r+1:r;}

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

펄, 45 44 바이트

+4 포함 -ai 이 코드는 시작시 2 개의 perl 경고를 표시합니다. X옵션 을 추가하여 한 번의 스트로크 비용으로이를 억제 할 수 있습니다

-i옵션 뒤에 마스크 길이 와 STDIN의 한 줄에 배열을 지정하십시오.

perl -ai4 -E 'say$_*grep$_~~[$^I..@F],$a..$^I+$a++for@F' <<< "1 3 12 100 23"

코드 만 :

say$_*grep$_~~[$^I..@F],$a..$^I+$a++for@F

루비 , 62 바이트

->a,l{a.map.with_index{|x,i|x*[i+1,l,a.size-[l-1,i].max].min}}

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

본질적으로 Arnauld의 자바 스크립트 답변 포트는 필요 with_index하지만 훨씬 더 고통 스럽습니다.

실제로 이것을 제출하기로 결정하는데 시간이 걸렸을 때, 나는 Dennis의 알고리즘에 더 가까운이 70 바이트 버전에서 골프를 쳤다 .

->a,l{c=a.map{0};(0...a.size).each_cons(l){|h|h.map{|i|c[i]+=a[i]}};c}

클로저, 72 바이트

#(let[R(range 1(inc(count %)))](map *(map min(repeat %2)R(reverse R))%))

Pyt , 106 바이트

ĐŁĐ←⇹řĐ↔Đ04ȘĐ04Ș>Đ04Ș03Ș¬*07ȘážÁ*+04Ș⇹Đ3ȘĐ3Ș-⁺Đ4Ș⇹ŕĐ3Ș<Ь3Ș*3Ș*+⇹ĐŁ⑴04Ș3Ș⇹04Ș*Đ04ȘĐ04Ș<Đ04Ș*06ȘážÁ03Ș¬*++*

첫 번째 줄에서 L을 배열로 취하고 두 번째 줄에서 s를 취합니다.

설명:

                     Implicit input (L)
Đ                    Duplicate L
ŁĐ                   Get length of L (len) and push it twice
←                    Get s
⇹ř                   Push [1,2,...,len]
Đ↔Đ                  Push [len,...,2,1] twice
04ȘĐ                 Push 0, flip top 4 on stack, and duplicate top [1,2,...,len]
04Ș>                 Is [len,...,2,1]>[1,2,...,len] (element-wise) [boolean array]
Đ                    Duplicate top of stack                   
04Ș03Ș¬*             Pushes [1,2,...,ceil(len/2),0,...,0]
07ȘážÁ               Push 0, flip top seven on stack, and remove all 0s from stack
*                    Pushes [0,0,...,0,floor(len/2),floor(len/2)-1,...,1]
+                    Adds top two on stack element-wise

The top of the stack is now:
     [1,2,...,ceil(len/2),floor(len/2),...,2,1] (let's call it z)

04Ș                  Push zero and swap top four on stack
⇹                    Swap top two on stack
Đ3ȘĐ3Ș-⁺Đ4Ș⇹ŕĐ3Ș<Ь3Ș*3Ș*+     Pushes min of (len-s+1,s) [let's call it m]
⇹ĐŁ⑴04Ș3Ș⇹04Ș*                Pushes an array [m,m,...,m] with length len
Đ04ȘĐ04Ș<Đ04Ș*06ȘážÁ03Ș¬*++    Pushes element-wise min of [m,m,...,m] and z
*                              Element-wise multiplication of above with L

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

파이썬 + numpy, 64 바이트

from pylab import *
lambda l,N:convolve(*ones((2,len(l)-N-1)))*l

l을 목록으로, N을 길이로 사용하여 이것을 호출하십시오.