ओवरलैपिंग स्लाइस का कॉलम-वार योग

19

कार्य

पूर्णांकों की एक सूची को देखते हुए एल और एक अन्य पूर्णांक रों , लक्ष्य सभी का स्तंभ-वार रकम की गणना करने के लिए है रों -length (संभावित अतिव्यापी) की स्लाइस एल , के सापेक्ष उनके पदों से संबंधित है, जबकि एल (नीचे देखें)।

परिभाषाएं

रों -length (ओवरलैपिंग) स्लाइस सूची के एल के सभी सन्निहित subsequences (रैपिंग के बिना) कर रहे हैं एल कि लंबाई के होते हैं रों ।

आदेश करने के लिए पदों संबंधित स्लाइस की रों के सापेक्ष एल , आप एक "सीढ़ी", जहां प्रत्येक टुकड़ा के निर्माण की कल्पना कर सकते है मैं एक की भरपाई है मैं शुरू से ही स्थिति।

ऐनक

  • s , 1 से अधिक पूर्णांक है और 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]
code-golf  array-manipulation  subsequence 
— श्री Xcoder
स्रोत
2
यह पहला परीक्षण मामला कष्टप्रद है। ;) बस क्योंकि sसे बड़ा है L/2। हो सकता है कि कुछ और परीक्षण मामले जोड़ें जहां यह मामला है [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]?
— केविन क्रूज़सेन
2
@ केविनक्रूजसेन क्या आप कृपया मेरे लिए संपादन कर सकते हैं? वे कुछ अच्छे परीक्षण के मामले हैं, लेकिन मैं अभी मोबाइल पर हूं;) धन्यवाद!
— श्री Xcoder

जवाबों:

11

जे , 11, 9 8 बाइट्स

मील के लिए -1 बाइट धन्यवाद!

[:+//.]\

यह काम किस प्रकार करता है?

बायाँ तर्क s है, दायें वाला - L है

]\ - लंबाई s के साथ उपविष् टों में L को विभाजित करता है

/. - तिरछे विकर्णों को निकालता है (विरोधी विकर्ण)

+/ - उन्हें जोड़ता है

[: - उपरोक्त क्रियाओं से कांटा बनता है

यहाँ पहले परीक्षण मामले के लिए एक उदाहरण जे सत्र है:

   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

इसे ऑनलाइन आज़माएं!

— गैलेन इवानोव
स्रोत
क्या "तिरछे तिरछे" और "विकर्ण" के बीच कोई अंतर है?
— लुइस मेंडो
@ लिसन मेन्डो - मुझे लगता है कि "तिरछा" का मतलब जे क्रियाविशेष के मामले में नीचे-बाएं से ऊपर-दाएं की ओर जाना है /. , जैसा कि मुख्य विकर्ण के ऊपर-लेफ्ट से डाउन-राइट की ओर जाना है।
— गेलन इवानोव
1
आह, धन्यवाद। तो यह है कि आमतौर पर विरोधी विकर्ण कहा जाता है
— लुइस मेंडो
2
आप के ,/\साथ प्रतिस्थापित कर सकते हैं]\
— मील
@ मीलों हां, बिल्कुल! धन्यवाद!
— गैलेन इवानोव
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]
— Laikoni
स्रोत
6

जावास्क्रिप्ट (ईएस 6), 65 62 58 बाइट्स

@ बग्घी के लिए 4 बाइट्स को सहेजा गया

करी सिंटैक्स में इनपुट लेता है (a)(n) ।

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
a=>n=>a.map((v,i)=>v*Math.min(++i,n,a.length+1-(n>i?n:i)))58 बाइट्स के लिए काम करता है ?
— झबरा
@ किसी तरह, मैं जानता था कि मेरे कोड में वास्तव में कुछ बेवकूफ था लेकिन यह पता नहीं लगा सका ... बहुत बहुत धन्यवाद!
— अरनुलद
6

जावा 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;}

यह पहला परीक्षण मामला (और पिछले दो मैंने जोड़ा है) ने मुझे कई बार खराब कर दिया, लेकिन यह आखिरकार अब काम करता है ..: डी

एक नया लौटने के बजाय इनपुट सरणी को संशोधित करता है।

स्पष्टीकरण:

इसे ऑनलाइन आज़माएं।

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`
— केविन क्रूज़सेन
स्रोत
5

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]
— लुइस मेंडो
स्रोत
5

एपीएल (डायलॉग यूनिकोड) , 19 14 बाइट्स एसबीसीएस

-5 ngn के लिए धन्यवाद।

बेनामी मौन इन्फ़िक्स समारोह लेने s बाईं तर्क और के रूप में एल सही तर्क के रूप में। मान लिया गया है ⎕IO( मैं ndex हे rigin) होने के लिए 0के रूप में कई सिस्टम पर डिफ़ॉल्ट है।

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

इसे ऑनलाइन आज़माएं!

उदाहरण के मामले के साथ स्पष्टीकरण [1,3,12,100,23]

(… ) निम्नलिखित अनाम tacit फ़ंक्शन लागू करें:

 ,/ उस आकार की अतिव्यापी खिड़कियां; [[1,3,12],[3,12,100],[12,100,23]]

 (… )\ इस अनाम tacit फंक्शन को संचयी रूप से लागू करें:

  ⊢ सही (सबसे) तर्क

  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]

— एडम
स्रोत
1
⊢,⍨¨0⍴⍨¨⍳∘≢->{0,⍵}\
— ngn
@ng आप हमेशा इन चालाक कटौती के बारे में सोचते हैं, लेकिन आपको वास्तव में इसे अलग से पोस्ट करना चाहिए। Btw, मुझे +⌿∘↑((0,⊢)\,/)और अधिक सुंदर लगता है ।
— आदम
ओह, यह एक समाधान के एक भाग को सरल बनाने का एक स्पष्ट मामला है , न कि एक नया विचार
— ngn
इस बीच, इस CMC को हल करें !
— अड्म
मुझे यकीन नहीं है कि यह यहाँ टिप्पणियों में विषय है, लेकिन आप "प्रत्येक" का उपयोग क्यों नहीं करते हैं? 2{(⊃⌽⍺),⊃⍵}/⊢->2{⊃¨(⌽⍺)⍵}/⊢
— ngn
4

जेली , 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.
— डेनिस
स्रोत
3

जाप , 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
— झबरा
स्रोत
" यह काम करने के लिए बहुत लंबा समय लगा जबs > L/2 मैं ! " अन्य परीक्षण मामले आसान हैं, लेकिन यह कि पहले एक (और दो मैंने अंत में जोड़ा है) कष्टप्रद थे! .. +1 मुझसे!
— केविन क्रूज़सेन
1

आर , 52 51 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह लकोनी के उत्तर के बराबर है ।

seq(l)1...length(l)तब से सूचकांकों का length(l)>1उत्पादन होता है (अन्यथा यह उत्पादन होता है 1...l[1])। मैं इसे सहेजता हूंx , इसके विपरीतy , और Laikoni के उत्तर को पोर्ट करने के लिए y( length(l)) का पहला तत्व लेता हूं और एक बाइट बचाता हूं!

मूल उत्तर, 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

उत्पादन lतत्व के न्यूनतम s, तत्व के 1-आधारित सूचकांक द्वारा गुणा किया जाता है x,length(l)-x+1 , और length(L)-s+1।

यह भी Laikoni के जवाब के बराबर है, L-xइसके बजाय rev(x)यह छोटा है।

— ग्यूसेप
स्रोत
1

एपीएल + विन, 25 बाइट्स

एल के स्क्रीन इनपुट के लिए संकेत इसके बाद एस

+/(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
— ग्राहम
स्रोत
1

के (ओके) , 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

स्पष्टीकरण:

मुझे नहीं लगता कि मैं इस पर जम्मू के साथ प्रतिस्पर्धा कर सकता हूं । स्लाइडिंग-विंडो सूची में जोड़ा और प्रस्तुत किए जाने वाले शून्य की सूची बनाएं, फिर योग करें:

{ 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
— streetster
स्रोत
1

भूसी , 4 बाइट्स

mΣ∂X

इसे ऑनलाइन आज़माएं!

से विचार का उपयोग करता है गैलेन इवानोव के जे उत्तर ।

व्याख्या

     -- 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]
— Laikoni
स्रोत
0

सी (जीसीसी) , 83 81 79 बाइट्स

सूची में हेरफेर करने के लिए मूल रूप से तीन "चरण" हैं: रैंप-अप, निरंतर और कूल-ऑफ। जैसे ही हम सूची में जाएंगे, हम अपने कारक को बढ़ाएंगे जब तक कि हम कुछ अधिकतम तक नहीं पहुंच जाते। यदि स्लाइस का एक पूरा रन सूची में फिट हो सकता है, तो यह अधिकतम स्लाइस की लंबाई के समान होगा। अन्यथा, यह फिट होने वाले स्लाइस की संख्या के समान होगा। दूसरे छोर पर, हम फिर से कारक को कम कर देंगे, अंतिम तत्व पर 1 पर उतरेंगे।

इस पठार को बुक करने वाले रैंप-अप और कूल-डाउन चरणों की लंबाई उस अधिकतम कारक से एक कम है।

उन्हें उम्मीद से मिलाने से पहले अपराजित छोरों से यह स्पष्ट हो जाता है (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;}

इसे ऑनलाइन आज़माएं!

— gastropner
स्रोत
0

पर्ल, 45 44 बाइट्स

+4 के लिए -ai यह भी शामिल है कि यह कोड स्टार्टअप पर 2 पर्ल चेतावनी देता है। आप इन्हें एक स्ट्रोक की कीमत पर दबाकर जोड़ सकते हैंX विकल्प

-iSTDIN पर एक लाइन पर विकल्प और सरणी के बाद मास्क की लंबाई दें :

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
— टन हास्पेल
स्रोत
0

रूबी , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनिवार्य रूप से अरनुल्ड के जावास्क्रिप्ट उत्तर का एक बंदरगाह , सिवाय इसके कि जरूरत with_indexसे ज्यादा दर्दनाक है।

वास्तव में इसे प्रस्तुत करने का निर्णय लेने के लिए समय लगने पर, मैं इस 70-बाइट संस्करण से नीचे गिर गया, जो डेनिस के एल्गोरिथ्म के करीब है ।

->a,l{c=a.map{0};(0...a.size).each_cons(l){|h|h.map{|i|c[i]+=a[i]}};c}
— benj2240
स्रोत
0

क्लोजर, 72 बाइट्स

#(let[R(range 1(inc(count %)))](map *(map min(repeat %2)R(reverse R))%))
— NikoNyrh
स्रोत
0

पाइट , 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

इसे ऑनलाइन आज़माएं!

— mudkip201
स्रोत
0

पायथन + सुन्न, 64 बाइट्स

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

इस सूची के रूप में एल के साथ कॉल करें, और एन लंबाई के रूप में।

— user2699
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.