Bài tập

Cho một danh sách các số nguyên L và một số nguyên s , mục tiêu là để tính toán số tiền cột khôn ngoan của tất cả các s Chiều dài (có khả năng chồng chéo) lát L , trong khi liên quan vị trí của họ liên quan đến L (xem dưới đây).

Định nghĩa

Các lát s -length (chồng chéo) của danh sách L là tất cả các chuỗi tiếp giáp (không bao bọc) của L có độ dài s .

Để gắn liền các vị trí của các lát s so với L , bạn có thể tưởng tượng được việc xây dựng một "bậc thang", trong đó mỗi lát là _tôi đã một bù đắp của tôi vị trí ngay từ đầu.

Thông số kỹ thuật

• s là một số nguyên lớn hơn 1 và nhỏ hơn đúng hơn độ dài của L .
• L sẽ luôn chứa ít nhất 3 yếu tố.
• 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 , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Đâ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ụ và trường hợp thử nghiệm

Đây là một ví dụ hoạt động:

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

Và một số trường hợp thử nghiệm khác:

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

-1 byte nhờ dặm!

[:+//.]\

Làm thế nào nó hoạt động?

Đối số bên trái là s, bên phải - L

]\ - chia L thành các danh sách con có độ dài s

/. - trích xuất các đường chéo xiên (chống chéo)

+/ - thêm chúng lên

[: - làm cho một ngã ba từ các động từ trên

Dưới đây là phiên J ví dụ cho trường hợp thử nghiệm đầu tiên:

   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

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

Haskell , 59 56 byte

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

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

Xác định hàm (#)lấy danh sách svà số nlàm đối số.

Điều này dựa trên sự quan sát rằng cho s = [1, 2, 3, 4, 5, 6, 7, 8, 9]và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]

giống như

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

Để tạo danh sách này ban đầu tăng, sau đó liên tục và cuối cùng là giảm danh sách, chúng ta có thể bắt đầu với

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

mà năng suất [1, 2, 3, 4, 5, 4, 3, 2, 1]. Việc thêm ndưới dạng ràng buộc bổ sung vào minimumbiểu thức mang lại [1, 2, 3, 3, 3, 3, 3, 2, 1]câu trả lời danh sách chính xác cho n = 3, mặc dù đối với n = 6(hoặc nói chung là bất kỳ n > lengths s/2), ràng buộc bổ sung length s + 1 - nlà cần thiết:

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

hoặc ngắn hơn:

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

Đối với phép nhân cặp [1..length s]được nén với s, và vì zipcắt ngắn danh sách dài hơn với độ dài của danh sách ngắn hơn, danh sách vô hạn [1..]có thể được sử dụng:

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

JavaScript (ES6), 65 62 58 byte

Đã lưu 4 byte nhờ @Shaggy

Đưa đầu vào trong cú pháp currying (a)(n).

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

Các trường hợp thử nghiệm

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 byte

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

Trường hợp thử nghiệm đầu tiên đó (và hai trường hợp cuối cùng tôi đã thêm) đã lừa tôi nhiều lần, nhưng cuối cùng nó cũng hoạt động ..: D

Sửa đổi mảng đầu vào thay vì trả về một mảng mới.

Giải trình:

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

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 byte

)IŒIùvyNÅ0ì+

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

MATL , 8 byte

YCPT&Xds

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Xem xét đầu vào [1, 3, 12, 100, 23]và 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 byte ^SBCS

-5 cảm ơn ngn.

Hàm ẩn danh ẩn danh lấy s làm đối số trái và L làm đối số phải. Giả sử ⎕IO( I ndex O rigin) 0là mặc định trên nhiều hệ thống.

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

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

Giải thích với trường hợp ví dụ [1,3,12,100,23]

(... ) áp dụng các chức năng ngầm ẩn danh sau đây:

 ,/ cửa sổ chồng chéo kích thước đó; [[1,3,12],[3,12,100],[12,100,23]]

 (... )\ tích lũy áp dụng ngầm chức năng ngầm ẩn danh sau này:

  ⊢ đối số đúng (nhất)

  0, với số 0 ở bên trái

Giảm tích lũy có nghĩa là chúng ta chèn hàm vào mọi "khoảng trắng" giữa các số hạng liên tiếp, hoạt động theo cách từ phải sang trái. Đối với mỗi "khoảng trắng", hàm sẽ loại bỏ đối số bên trái nhưng nối thêm một số không. Thực tế, điều này nối thêm nhiều số không vào mỗi số hạng khi có "khoảng trắng" ở bên trái, vì vậy, số hạng đầu tiên có khoảng trắng, số thứ hai có một và số thứ ba có hai:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ tăng thứ hạng bằng cách kết hợp các danh sách thành một ma trận duy nhất, đệm bằng số không;
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ sau đó
+⌿ tổng hợp theo chiều dọc;[1,6,36,200,23]

Thạch , 6 byte

JṡṬS×ḷ

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

Làm thế nào nó hoạt động

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 byte

Phải mất quá lâu để làm việc này khi s> L/2!

Ë*°EmVUÊÄ-EwV

Thử nó

Giải trình

                 :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

Ngôn ngữ Wolfram (Mathicala) , 42 byte

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

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

Julia , 41 byte

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

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

• Xác định lại \toán tử.
• a[L=end]là một thay thế ngắn hơn để L=length(a).
• Sử dụng phương pháp của Laikoni .

Japt , 13 12 byte

-1 byte nhờ @ETHproductions

ãV
ËEÆÃcDÃyx

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

R , 52 51 byte

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

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

Điều này tương đương với câu trả lời của Laikoni .

seq(l)tạo ra các chỉ số 1...length(l)kể từ khi length(l)>1(nếu không nó sẽ sản xuất 1...l[1]). Tôi lưu nó dưới dạng x, lưu ngược lại yvà lấy phần tử đầu tiên của y( length(l)) để chuyển gọn câu trả lời của Laikoni và lưu một byte!

Câu trả lời gốc, 52 byte

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

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

Kết quả này được lelementwise nhân với tối thiểu s, chỉ số 1 có trụ sở của nguyên tố này x, length(l)-x+1và length(L)-s+1.

Điều này cũng tương đương với câu trả lời của Laikoni, sử dụng L-xthay vì rev(x)ngắn hơn.

APL + THẮNG, 25 byte

Lời nhắc cho đầu vào màn hình của L theo sau là s

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

Giải trình:

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 byte

Dung dịch:

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

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

Thí dụ:

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

Giải trình:

Đừng nghĩ rằng tôi có thể cạnh tranh với J về điều này. Tạo một danh sách các số không được thêm vào và thêm vào danh sách cửa sổ trượt, sau đó tổng hợp lại:

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

Sự cố là như sau ... mặc dù điều này vẫn cảm thấy vụng về.

{+/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 byte

mΣ∂X

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

Sử dụng ý tưởng từ câu trả lời J của Galen Ivanov .

Giải trình

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

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

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

Python 2 , 68 66 byte

-2 byte nhờ Laikoni

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

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

Perl 5 , 63 byte

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

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

C (gcc) , 83 81 79 byte

Về cơ bản, có ba "giai đoạn" để thao túng danh sách: tăng tốc, duy trì và hạ nhiệt. Khi chúng tôi đi cùng danh sách, chúng tôi sẽ tăng yếu tố của mình cho đến khi đạt được mức tối đa. Nếu một loạt các lát có thể phù hợp với danh sách, mức tối đa này sẽ giống với độ dài của các lát. Nếu không, nó sẽ giống như số lát phù hợp. Ở đầu bên kia, chúng ta sẽ giảm hệ số một lần nữa, hạ cánh xuống 1 trên phần tử cuối cùng.

Độ dài của các giai đoạn tăng tốc và hạ nhiệt làm tăng tốc cho cao nguyên này là một yếu tố nhỏ hơn mức tối đa đó.

Các vòng lặp không được chỉnh sửa trước khi kết hợp chúng hy vọng làm cho nó rõ ràng hơn (R = chiều dài của giai đoạn tăng tốc):

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;

Ba vòng lặp là quá nhiều, vì vậy việc quyết định yếu tố dựa trên r cung cấp cho chúng ta một vòng lặp (sử dụng s cho R để lưu một số byte):

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

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

Perl, 45 44 byte

Bao gồm +4 cho -ai Cũng lưu ý rằng mã này đưa ra 2 cảnh báo perl khi khởi động. Bạn có thể loại bỏ những thứ này với giá của một cú đánh bằng cách thêmX tùy chọn

Đưa ra độ dài mặt nạ sau -itùy chọn và mảng trên một dòng trên STDIN:

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

Chỉ cần mã:

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

Ruby , 62 byte

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

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

Về cơ bản là một cổng của câu trả lời javascript của Arnauld , ngoại trừ việc cầnwith_index là đau đớn hơn nhiều.

Trong thời gian để tôi quyết định thực sự gửi nó, tôi đã đánh golf từ phiên bản 70 byte này, gần với thuật toán của Dennis hơn .

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

Clojure, 72 byte

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

Pyt , 106 byte

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

Lấy L trên dòng đầu tiên dưới dạng một mảng và lấy s trên dòng thứ hai

Giải trình:

                     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

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

Python + numpy, 64 byte

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

Gọi đây với l là danh sách và N là chiều dài.