Zadanie

Biorąc pod uwagę listę liczb całkowitych L i kolejna liczba całkowita s , celem jest obliczenie sumy kolumn mądry wszystkich ów -Długość (potencjalnie nakładają się) plastry L , a dotyczące ich położenia w stosunku do L (patrz niżej).

Definicje

Gdy s -długość (pokrywające się) plastry z listy L są stycznym podsekwencjami (bez opakowania) w L , które mają długość y .

W celu uzyskania pozycji wycinków s względem L można sobie wyobrazić zbudowanie „drabiny”, w której każdy wycinek s _i ma przesunięcie pozycji i od początku.

Okular

• y jest liczbą całkowitą większa niż 1 i ściśle mniejszy od długości L .
• L zawsze będzie zawierać co najmniej 3 elementy.
• Możesz konkurować w dowolnym języku programowania i możesz przyjmować dane wejściowe i generować dane wyjściowe za pomocą dowolnej standardowej metody , zwracając uwagę, że te luki są domyślnie zabronione. To jest golf golfowy , więc wygrywa najkrótsze przesłanie (w bajtach) dla każdego języka .

Przykłady i przypadki testowe

Oto działający przykład:

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

I jeszcze kilka przypadków testowych:

[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 bajtów

-1 bajt dzięki milom!

[:+//.]\

Jak to działa?

Lewy argument to s, prawy - L

]\ - dzieli L na podlisty o długości s

/. - wyciąga ukośne przekątne (anty przekątne)

+/ - dodaje je

[: - robi widelec z powyższych czasowników

Oto przykładowa sesja J dla pierwszego przypadku testowego:

   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

Wypróbuj online!

Haskell , 59 56 bajtów

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

Wypróbuj online!

Definiuje funkcję, (#)która przyjmuje listę si liczbę njako argumenty.

Jest to oparte na spostrzeżeniu, że dla s = [1, 2, 3, 4, 5, 6, 7, 8, 9]in = 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]

jest taki sam jak

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

Aby wygenerować tę początkowo rosnącą, potem stałą i ostatecznie malejącą listę, możemy zacząć

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

co daje [1, 2, 3, 4, 5, 4, 3, 2, 1]. Dodanie ndo minimumwyrażenia dodatkowego ograniczenia daje poprawną [1, 2, 3, 3, 3, 3, 3, 2, 1]odpowiedź na listę n = 3, chociaż dla n = 6(lub ogólnie dowolnego n > lengths s/2) length s + 1 - npotrzebne jest dodatkowe ograniczenie :

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

lub krócej:

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

W przypadku mnożenia par [1..length s]jest spakowane s, a ponieważ zipobcina dłuższą listę do długości krótszej, [1..]można użyć listy nieskończonej :

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

JavaScript (ES6), 65 62 58 bajtów

Zaoszczędź 4 bajty dzięki @Shaggy

Pobiera dane wejściowe w składni curry (a)(n).

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

Przypadki testowe

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 bajty

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

Ten pierwszy przypadek testowy (i dwa ostatnie, które dodałem) przykręcił mnie wiele razy, ale w końcu teraz działa ...: D

Zmienia tablicę wejściową zamiast zwracać nową.

Wyjaśnienie:

Wypróbuj online.

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 bajtów

)IŒIùvyNÅ0ì+

Wypróbuj online!

Mátl , 8 bajtów

YCPT&Xds

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

Rozważ dane wejściowe [1, 3, 12, 100, 23]i 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 bajtów ^SBCS

-5 dzięki ngn.

Anonimowa funkcja ukrytej poprawki przyjmuje s jako lewy argument, a L jako prawy argument. Zakłada ⎕IO( I ndex O rigin), że jest taki, 0jak domyślny w wielu systemach.

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

Wypróbuj online!

Objaśnienie z przykładowym przypadkiem [1,3,12,100,23]

(… ) Zastosuj następującą anonimową funkcję ukrytą:

 ,/ nakładające się okna tego rozmiaru; [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ Łącznie zastosuj to milczenie następującą anonimową funkcję milczącą:

  ⊢ właściwy (najbardziej) argument

  0, z zero po lewej stronie

Skumulowana redukcja oznacza, że ​​wstawiamy funkcję w każdą „przestrzeń” między kolejnymi terminami, przesuwając się od prawej do lewej. Dla każdego „spacji” funkcja odrzuci lewy argument, ale doda dodatkowe zero. Skutecznie dodaje to tyle zer do każdego terminu, ile jest „spacji” po jego lewej stronie, więc pierwszy element otrzymuje zero spacji, drugi otrzymuje jeden, a trzeci otrzymuje dwa:[[1,3,12],[0,3,12,100],[0,0,12,100,23]]

↑ awansować, łącząc listy w jedną matrycę, wypełniając je zerami;
 ┌ ┐
 │1 3 12 0 0│
 │0 3 12 100 0│
 │0 0 12 100 23│
 └ ┘
∘ następnie
+⌿ sumuj w pionie;[1,6,36,200,23]

Galaretka , 6 bajtów

JṡṬS×ḷ

Wypróbuj online!

Jak to działa

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 bajtów

Zajęło to zdecydowanie zbyt długo, gdy s> L/2!

Ë*°EmVUÊÄ-EwV

Spróbuj

Wyjaśnienie

                 :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 bajty

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

Wypróbuj online!

Julia , 41 bajtów

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

Wypróbuj online!

• Przedefiniuj \operatora.
• a[L=end]jest krótszą alternatywą dla L=length(a).
• Wykorzystuje metodę Laikoni .

Japt , 13 12 bajtów

-1 bajt dzięki @ETHproductions

ãV
ËEÆÃcDÃyx

Wypróbuj online!

R , 52 51 bajtów

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

Wypróbuj online!

Jest to równoważne z odpowiedzią Laikoni .

seq(l)produkuje indeksy, 1...length(l)ponieważ length(l)>1(w przeciwnym razie produkowałby 1...l[1]). Zapisuję go jako x, zapisuję jego odwrotność jako yi biorę pierwszy element y( length(l)), aby starannie przenieść odpowiedź Laikoni i zapisać bajt!

Oryginalna odpowiedź, 52 bajty

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

Wypróbuj online!

Wyjście lelementwise pomnożona przez minimum s, indeks 1 opartego na elemencie x, length(l)-x+1i length(L)-s+1.

Jest to również równoważne z odpowiedzią Laikoni, używaną L-xzamiast, rev(x)ponieważ jest krótsza.

APL + WIN, 25 bajtów

Monituje o wprowadzenie ekranu L, a następnie s

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

Wyjaśnienie:

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 bajtów

Rozwiązanie:

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

Wypróbuj online!

Przykład:

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

Wyjaśnienie:

Nie sądzę, żebym mógł konkurować z J na tym. Wygeneruj listę zer, które chcesz dołączyć i dodać do listy przesuwnych okien, a następnie podsumuj:

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

Podział jest następujący ... choć nadal wydaje się niezdarny.

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

Łuska , 4 bajty

mΣ∂X

Wypróbuj online!

Wykorzystuje pomysł z odpowiedzi J. Galena Iwanowa .

Wyjaśnienie

     -- 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 bajtów

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

Wypróbuj online!

Python 2 , 68 66 bajtów

-2 bajty dzięki Laikoni

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

Wypróbuj online!

Perl 5 , 63 bajtów

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

Wypróbuj online!

C (gcc) , 83 81 79 bajtów

Zasadniczo manipulowanie listą obejmuje trzy „fazy”: zwiększanie, podtrzymywanie i ochładzanie. Idąc wzdłuż listy, zwiększamy nasz współczynnik, aż osiągniemy maksimum. Jeśli pełny zestaw plasterków może zmieścić się na liście, to maksimum będzie takie samo jak długość plasterków. W przeciwnym razie będzie taka sama, jak liczba pasujących plasterków. Z drugiej strony ponownie zmniejszymy współczynnik, aby wylądować na 1 na ostatnim elemencie.

Długość faz przyspieszania i ochładzania rezerwujących ten płaskowyż jest o jeden mniejsza niż ten maksymalny czynnik.

Niefundowane pętle przed ich połączeniem mają nadzieję, że są wyraźniejsze (R = długość fazy rozruchu):

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;

Trzy pętle to o wiele za dużo, więc decyzja o współczynniku na podstawie r daje nam jedną pętlę (użycie s dla R do zapisania niektórych bajtów):

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

Wypróbuj online!

Perl, 45 44 bajtów

Obejmuje +4 -ai Zauważ również, że ten kod daje 2 ostrzeżenia perl przy uruchomieniu. Możesz je wyłączyć kosztem jednego pociągnięcia, dodając Xopcję

Podaj długość maski po -iopcji i tablicę w jednym wierszu na STDIN:

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

Tylko kod:

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

Rubin , 62 bajty

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

Wypróbuj online!

Zasadniczo port odpowiedzi na javascript Arnaulda , z tym wyjątkiem, że potrzeba with_indexjest o wiele bardziej bolesna.

W czasie, gdy musiałem zdecydować się na przesłanie tego, grałem w golfa od tej 70-bajtowej wersji, która jest bliższa algorytmowi Dennisa .

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

Clojure, 72 bajty

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

Pyt , 106 bajtów

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

Pobiera L w pierwszym wierszu jako tablicę i przyjmuje s w drugiej linii

Wyjaśnienie:

                     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

Wypróbuj online!

Python + numpy, 64 bajty

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

Nazwij to l jako listą, a N jako długością.