ওভারল্যাপিং স্লাইসগুলির কলাম-ভিত্তিক সংমিশ্রণ

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 
— মিঃ এক্সকোডার
সূত্র
2
প্রথম পরীক্ষার মামলাটি বিরক্তিকর। ;) সহজ কারণ এর sচেয়ে বড় L/2। সম্ভবত আরও কিছু পরীক্ষার কেস যুক্ত করুন যেখানে এটি [1, 1, 1, 1, 1, 1, 1], 6 -> [1, 2, 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
@ কেভিন ক্রুজসেন আপনি কি আমার জন্য সম্পাদনা করতে পারেন? সেগুলি কয়েকটি ভাল পরীক্ষার কেস, তবে আমি এখন মোবাইলে আছি;) ধন্যবাদ!
— মিঃ এক্সকোডার

উত্তর:

11

জে , 11, 9 8 বাইট

মাইল থেকে -1 বাইট ধন্যবাদ!

[:+//.]\

কিভাবে এটা কাজ করে?

বাম আর্গুমেন্ট গুলি, ডান এক - এল

]\ - দৈর্ঘ্যের এস সহ উপ-তালিকায় এলকে বিভক্ত করে

/. - তির্যক কর্ণগুলি (অ্যান্টি-ডায়াগোনাল) বের করে

+/ - এগুলি যোগ করুন

[: - উপরের ক্রিয়াগুলি থেকে একটি কাঁটাচামচ তৈরি করে

এখানে প্রথম পরীক্ষার ক্ষেত্রে জে সেশনের একটি উদাহরণ রয়েছে:

   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

এটি অনলাইন চেষ্টা করুন!

— গ্যালেন ইভানভ
সূত্র
"তির্যক তির্যক" এবং "তির্যক" এর মধ্যে কি কোনও পার্থক্য রয়েছে?
— লুইস মেন্ডো
@ লুইস মেন্ডো - আমি মনে করি "তির্যক" এর অর্থ মূল ডায়াগোনালটি /.উপরের-বাম থেকে নীচে-ডানদিকে যাওয়ার বিপরীতে জে ক্রিয়াবিজ্ঞানের ক্ষেত্রে নীচে থেকে বাম থেকে ডান দিকে যেতে হবে think
— গ্যালেন ইভানভ
1
আহ, ধন্যবাদ তাই এটিকে সাধারণত অ্যান্টি-ডায়াগোনাল
— লুইস মেন্ডো
2
আপনি প্রতিস্থাপন করতে পারে ,/\সঙ্গে]\
— মাইল
@ মাইলস হ্যাঁ, অবশ্যই! ধন্যবাদ!
— গ্যালেন ইভানভ
9

হাস্কেল , 59 56 বাইট

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

এটি অনলাইন চেষ্টা করুন!

একটি ফাংশন সংজ্ঞা দেয় (#)যা একটি তালিকা sএবং একটি সংখ্যা নেয় takesn আর্গুমেন্ট হিসাবে গ্রহণ করে।

এই পর্যবেক্ষণ উপর ভিত্তি করে তৈরি যে জন্য 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

জাভাস্ক্রিপ্ট (ES6), 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

এমএটিএল , 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 এনএনজি ধন্যবাদ।

বেনামী মৌন পোতা ফাংশন গ্রহণ গুলি বাম যুক্তি এবং এল অধিকার যুক্তি হিসেবে। অনুমান ⎕IO( আমি ndex হে rigin) হতে 0হিসাবে অনেক সিস্টেমে পূর্বনির্ধারিত।

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

এটি অনলাইন চেষ্টা করুন!

উদাহরণস্বরূপ কেস সহ ব্যাখ্যা [1,3,12,100,23]

(… ) নিম্নলিখিত বেনামে tacit ফাংশন প্রয়োগ করুন:

 ,/ যে আকারের ওভারল্যাপিং উইন্ডোজ; [[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]

— আদম
সূত্র
1
⊢,⍨¨0⍴⍨¨⍳∘≢->{0,⍵}\
— এনজিএন
@ জিএনএন আপনি সবসময় এই চতুর হ্রাস সম্পর্কে ভাবেন, তবে সত্যিই আপনার এটি আলাদাভাবে পোস্ট করা উচিত। বিটিডব্লিউ, আমি +⌿∘↑((0,⊢)\,/)আরও মার্জিত খুঁজে ।
— অ্যাডম
ওহ আসুন, এটি কোনও সমাধানের একটি অংশকে সরল করার একটি স্পষ্ট কেস , কোনও নতুন ধারণা নয়
— ngn
@ngn ইতিমধ্যে, এই সিএমসি সমাধান করুন !
— অ্যাডম
আমি এখানে মন্তব্যগুলিতে বিষয়বস্তু সম্পর্কে নিশ্চিত নই তবে আপনি "প্রত্যেকে" ব্যবহার করবেন না কেন? 2{(⊃⌽⍺),⊃⍵}/⊢->2{⊃¨(⌽⍺)⍵}/⊢
— এনজিএন
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 আমার কাছ থেকে!
— কেভিন ক্রুইজসেন 10
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এবং লাইকোনির উত্তরটি সুন্দরভাবে বন্দর করতে এবং একটি বাইট সংরক্ষণ করতে y( length(l)) এর প্রথম উপাদানটি নিয়ে যাই!

আসল উত্তর, 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।

এটি লাইকনির উত্তরের সমতুল্য, L-xপরিবর্তে rev(x)এটি সংক্ষিপ্ত হিসাবে ব্যবহার করা ।

— : Giuseppe
সূত্র
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 এ নামব।

র‌্যাম্প আপ এবং শীতল-ডাউন পর্যায়গুলির দৈর্ঘ্য যে এই মালভূমিটিকে বুকেন্ড করে দেয় এটি সর্বোচ্চ ফ্যাক্টরের চেয়ে কম।

অসম্পূর্ণ লুপগুলি তাদের সম্মিলনের আগে আশা করা যায় যে এটি পরিষ্কার হয়ে যায় (র‌্যাম্প-আপ পর্বের আর = দৈর্ঘ্য):

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;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বিকল্পগুলি

এর পরে মাস্কের দৈর্ঘ্য দিন -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
— টন হসপেল
সূত্র
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Ș¬*++*

অ্যারে হিসাবে প্রথম লাইনে এল লাগে এবং দ্বিতীয় লাইনে লাগে

ব্যাখ্যা:

                     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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.