งาน

ได้รับรายชื่อของจำนวนเต็มLและอีกจำนวนเต็มsเป้าหมายคือการคำนวณผลรวมคอลัมน์ที่ชาญฉลาดของทุกsมีความยาว (อาจทับซ้อนกัน) ชิ้นของLในขณะที่เกี่ยวข้องกับตำแหน่งของพวกเขาเทียบกับL (ดูด้านล่าง)

คำนิยาม

sมีความยาว(ที่ทับซ้อนกัน) ชิ้นของรายการLคือประกาศ subsequences ต่อเนื่องกัน (โดยไม่ต้องห่อ) ของLที่มีความยาวs

เพื่อให้ได้ตำแหน่งของชิ้นที่สัมพันธ์กับLคุณสามารถจินตนาการถึงการสร้าง "บันได" ซึ่งแต่ละชิ้นของ_iมีตำแหน่งออฟเซ็ตiจากจุดเริ่มต้น

รายละเอียด

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

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

นี่คือตัวอย่างการทำงาน:

[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

]\ - แยก L ออกเป็นรายการย่อยที่มีความยาว s

/. - แยก diagonals เฉียง (ต่อต้าน diagonals)

+/ - เพิ่มพวกเขา

[: - ทำให้แยกจากคำกริยาข้างต้น

นี่คือตัวอย่าง 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

ลองออนไลน์!

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

JavaScript (ES6), 65 62 58 ไบต์

บันทึกแล้ว 4 ไบต์ขอบคุณ @Shaggy

(a)(n)จะเข้าในไวยากรณ์ currying

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]

Java 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

-5 ขอบคุณ ngn

ไม่ประสงค์ออกนามโดยปริยายสละฟังก์ชั่นมัดsเป็นอาร์กิวเมนต์ด้านซ้ายและLเป็นอาร์กิวเมนต์ขวา ถือว่า⎕IO( I ndex O rigin) 0เป็นค่าเริ่มต้นในหลาย ๆ ระบบ

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

ลองออนไลน์!

อธิบายด้วยกรณีตัวอย่าง [1,3,12,100,23]

(… ) ใช้ฟังก์ชั่นเงียบโดยไม่ระบุชื่อต่อไปนี้:

 ,/ หน้าต่างที่ซ้อนกันของขนาดนั้น [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ ใช้ฟังก์ชันนี้โดยปริยายโดยปริยายโดยปริยายต่อไปนี้:

  ⊢ อาร์กิวเมนต์ (ขวา) ที่เหมาะสม

  0, กับศูนย์ทางด้านซ้าย

การลดลงของสะสมหมายถึงการที่เราใส่ฟังก์ชั่นลงใน "ช่องว่าง" ทุกอันระหว่างคำที่ต่อเนื่องกันทำงานจากทางขวาไปซ้าย สำหรับแต่ละ "ช่องว่าง" ฟังก์ชั่นจะยกเลิกการโต้แย้งด้านซ้าย แต่ผนวกศูนย์เพิ่มเติม ได้อย่างมีประสิทธิภาพนี้จะผนวกค่าศูนย์ให้มากที่สุดสำหรับแต่ละเทอมเนื่องจากมี "ช่องว่าง" ทางด้านซ้ายดังนั้นเทอมแรกจะมีศูนย์ว่างส่วนที่สองรับหนึ่งและที่สามได้สอง:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ เพิ่มอันดับโดยการรวมรายการเป็นเมทริกซ์เดียวเติมด้วยศูนย์
 ┌ ┐
 │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.

Japt , 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 (Mathematica) , 42 ไบต์

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

ลองออนไลน์!

Julia , 41 ไบต์

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

ลองออนไลน์!

• กำหนด\ผู้ประกอบการใหม่
• a[L=end]L=length(a)เป็นทางเลือกที่สั้นกว่า
• ใช้วิธีการ Laikoni ของ

Japt , 13 12 ไบต์

-1 ไบต์ขอบคุณ @ETHproductions

ã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และใช้องค์ประกอบแรกของy(length(l) ) เพื่อตอบคำถามของ Laikoni และบันทึกไบต์!

คำตอบเดิม 52 ไบต์

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

ลองออนไลน์!

เอาท์พุทจะlคูณ elementwise โดยต่ำสุดของsดัชนี 1-based ขององค์ประกอบx, และlength(l)-x+1length(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ในเกมนี้ได้ สร้างรายการศูนย์ที่จะต่อท้ายและผนวกเข้ากับรายการหน้าต่างบานเลื่อนจากนั้นสรุป:

{ 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

Husk , 4 ไบต์

mΣ∂X

ลองออนไลน์!

ใช้ความคิดจาก คำตอบ J ของ Galen Ivanovคำตอบของ

คำอธิบาย

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

ลองออนไลน์!

Python 2 , 68 66 ไบต์

-2 ไบต์ขอบคุณLaikoni

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

ลองออนไลน์!

Perl 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 ในองค์ประกอบสุดท้าย

ความยาวของระยะทางลาดขึ้นและระยะเย็นลงที่ bookend ที่ราบสูงนี้น้อยกว่าหนึ่งปัจจัยสูงสุด

วงดนตรีที่ไม่ได้ประกอบก่อนที่จะรวมเข้าด้วยกันหวังว่าจะทำให้ชัดเจน (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 ทำให้เรามีลูปหนึ่งอัน (ใช้ s สำหรับ R เพื่อบันทึกบางไบท์):

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

ลองออนไลน์!

Perl, 45 44 ไบต์

รวมถึง +4 สำหรับ-ai นอกจากนี้โปรดสังเกตว่ารหัสนี้ให้คำเตือน Perl 2 อันเมื่อเริ่มต้น คุณสามารถระงับสิ่งเหล่านี้ได้ด้วยค่าใช้จ่ายเพียงหนึ่งจังหวะโดยการเพิ่ม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

Ruby , 62 ไบต์

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

ลองออนไลน์!

เป็นหลักพอร์ตของคำตอบจาวาสคริปต์ของ Arnauldยกเว้นว่าต้องwith_indexมีความเจ็บปวดมากขึ้น

ในเวลาที่มันต้องใช้เวลาสำหรับผมที่จะตัดสินใจที่จะส่งจริงนี้ผมแข็งแรงเล่นกอล์ฟลงมาจากรุ่นนี้ 70 ไบต์ซึ่งเป็นผู้ใกล้ชิดกับอัลกอริทึมของเดนนิส

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

Clojure 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

ลองออนไลน์!

Python + จำนวน 64 ไบต์

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

เรียกสิ่งนี้ด้วย l เป็นรายการและ N เป็นความยาว