स्टैक ओवरफ्लो में एक प्रश्न से प्रेरित ।

पूर्णांक के एक गैर-खाली सरणी xऔर एक सकारात्मक पूर्णांक को देखते हुए , सरणी के साथ लंबाई के प्रत्येक स्लाइडिंग ब्लॉक की राशि की nगणना करें , बाईं ओर लापता मानों को दाएं से मानों के साथ गोलाकार रूप से भरें:nx

पहले ब्लॉक में पहली प्रविष्टि होती है x, जो n-1गोलाकार रूप से स्थानांतरित प्रविष्टियों से पहले होती है ;
दूसरे ब्लॉक में पहली और दूसरी प्रविष्टियाँ हैं x, जो कि n-2गोलाकार रूप से स्थानांतरित प्रविष्टियों से पहले हैं; और इसी तरह।

आउटपुट सरणी yका आकार समान है x। यह संभव है nकी लंबाई से अधिक करने के लिए x, और उसके बाद के मूल्यों xचक्राकार कर रहे हैं पुन: उपयोग किया कई बार ।

उदाहरण

उदाहरण 1 (मान केवल एक बार पुन: उपयोग किए जाते हैं)

x = [2, 4, -3, 0, -4]
n = 3

आउटपुट के रूप में दे

y = [-2, 2, 3, 1, -7]

कहा पे

-2ब्लॉक का योग है [0, -4, 2](पहले दो मान परिपत्र स्थानांतरण से आते हैं)
2का योग है [-4, 2, 4](पहला मूल्य परिपत्र स्थानांतरण से आता है)
3का योग है [2, 4, -3](अब आवश्यक कोई परिपत्र स्थानांतरण नहीं)
1 का योग है [4, -3, 0]
-7का योग है [-3, 0, -4]।

उदाहरण 2 (मान कई बार पुन: उपयोग किए जाते हैं)

x = [1, 2]
n = 5

देना

y = [7, 8]

कहा पे

7ब्लॉक का योग है [1, 2, 1, 2, 1](पहले चार मानों को गोलाकार रूप से पुन: उपयोग किया गया है)
8ब्लॉक का योग है [2, 1, 2, 1, 2](पहले तीन मानों को गोलाकार रूप से पुन: उपयोग किया गया है)

अतिरिक्त नियम

एल्गोरिथ्म को मनमाने आकार के सरणियों के लिए और मनमाने ढंग से पूर्णांक मानों के लिए काम करना चाहिए। यह स्वीकार्य है यदि प्रोग्राम डेटा प्रकार या मेमोरी प्रतिबंधों द्वारा सीमित है; लेकिन सकारात्मक और साथ ही नकारात्मक पूर्णांक मानों को संभाला जाना चाहिए।
इनपुट / आउटपुट किसी भी उचित माध्यम से लिया / उत्पादित किया जा सकता है ।
प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।
बाइट्स में सबसे छोटा कोड जीतता है।

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

x, n, -> y

[2, 4, -3, 0, -4], 3          ->  [-2, 2, 3, 1, -7]
[1, 2], 5                     ->  [7, 8]
[2], 7                        ->  [14]
[-5, 4, 0, 1, 0, -10, -4], 4  ->  [-19, -15, -5, 0, 5, -9, -13]
[-5, 4, 0, 1, 0, -10, -4], 1  ->  [-5, 4, 0, 1, 0, -10, -4]
[-2, -1, 0, 1, 2, 3], 5       ->  [4, 3, 2, 1, 0, 5]
[-10, 0, 10], 4               ->  [-10, 0, 10]

— लुइस मेंडो
स्रोत

6

बाह, आपको पूर्ववर्ती प्रविष्टियों का उपयोग क्यों करना पड़ा?

— नील

3

जेली , 5 बाइट्स

ṙC€}S

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

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

ṙC€}S  Main link. Arguments: A (array), n (positive integer)

   }   Apply the link to the left to the right argument (n).
 C€      Complement each; map (z -> 1-z) over [1, ..., n], yielding [0, ..., 1-n].
ṙ      Rotate A 0, ..., 1-n units to the left (i.e., 0, ..., n-1 units to the
       right), yielding a 2D array.
    S  Take the sum of the rows.

— डेनिस
स्रोत

7

MATL, 11 10 9 7 बाइट्स

3 बाइट्स @Luis को धन्यवाद बचा लिया!

:gyn&Z+

पहला इनपुट विंडो का आकार और दूसरा इनपुट ऐरे है

इस पर प्रयास करें MATL ऑनलाइन आज़माएं

व्याख्या

       % Implicitly grab the first input (n)
       %     STACK: { 3 }
:      % Create the array [1...n]
       %     STACK: { [1, 2, 3] }
g      % Convert it to a logical array, yielding an array of 1's of length n
       %     STACK: { [1, 1, 1] }
y      % Implicitly grab the second input and duplicate it
       %     STACK: { [2, 4, -3, 0, -4], [1, 1, 1], [2, 4, -3, 0, -4]}
n      % Determine the length of the array
       %     STACK: { [2, 4, -3, 0, -4], [1, 1, 1], 5}
&Z+    % Perform circular convolution
       %     STACK: { [-2, 2, 3, 1, -7] }
       % Implicitly display the result

— Suever
स्रोत

6

गणितज्ञ, 29 बाइट्स

RotateLeft[#,1-n]~Sum~{n,#2}&

या समान लंबाई:

ListConvolve[1~Table~#2,#,1]&

— alephalpha
स्रोत

6

CJam (16 बाइट्स)

{_2$*ew1fb\,~)>}

ऑनलाइन टेस्ट सूट । यह एक गुमनाम ब्लॉक (फ़ंक्शन) है जो स्टैक पर सरणी और लंबाई लेता है और स्टैक पर एक सरणी छोड़ देता है।

विच्छेदन

{       e# Declare a block
  _2$*  e#   Repeat the array n times: this guarantees having enough windows even
        e#   if x is only a single element
  ew    e#   Take each window of n elements
  1fb   e#   Sum each of the windows
  \,~)  e#   Compute -n
  >     e#   Take the last n elements of the array of sums
}

— पीटर टेलर
स्रोत

4

हास्केल, 57 बाइट्स

a#n|l<-length a=[sum[a!!mod j l|j<-[i-n..i-1]]|i<-[1..l]]

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

इंडेक्स में इनपुट लिस्ट को एक्सेस करने वाले कुछ इंडेक्स लूपिंग और लिस्ट की लंबाई को मापता है।

— nimi
स्रोत

3

हास्केल , 69 65 64 बाइट्स

r=reverse
s#n=r$init[sum$take n$x++cycle(r s)|x<-scanr(:)[]$r s]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: [2, 4, -3, 0, -4] # 3।

पूर्ववर्ती प्रविष्टियों के बजाय n सफल का उपयोग करना हो सकता है 50 46 बाइट्स (शुरुआत और अंत में रिवर्स से छुटकारा पाना):

s#n=init[sum$take n$x++cycle s|x<-scanr(:)[]s]

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

— Laikoni
स्रोत

2

जाप , 12 बाइट्स

ËVo rÈ+UgE-Z

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

TIO समर्थन नहीं करता है Ë, इसलिए TIO लिंक काम नहीं करेगा। इसके बजाय, इसे यहाँ आज़माएँ ।

— ल्यूक
स्रोत

2

पायथ , 18 16 बाइट्स

2 बाइट्स @FryAmTheEggman के लिए धन्यवाद बचा लिया !

JEms<.>*JQ-JhdJl

इसे यहाँ आज़माएँ या सभी परीक्षण मामलों को सत्यापित करें।

-6 बाइट्स की लागत पर सभी खामियों को तय किया ! चैट में कार्य को समझने के लिए लुइस को बहुत धन्यवाद।

स्पष्टीकरण (अद्यतन किया जाना है)

KEms<>_*QhK-lQhdKU - Full program.

KE                 - Assign the second input to a variable K.
  m              U - Map over the range [0...len(first input)).
       *QhK        - First input * (Second input + 1).
      _            - Reverse.
     >     -lQhd   - All the elements of the above after len(x)-current element-1
    <          K   - Up until the second input.
   s               - Sum.

— मिस्टर एक्सकोडर
स्रोत

पलटने से पहले एक बेहतर तरीका हो सकता है, जल्द ही गोल्फ की कोशिश करना।

— श्री Xcoder

समझे 16 बाइट्स लेकिन मुझे लगता है कि वहाँ अभी भी कम कुछ किया जाना चाहिए।

— FryAmTheEggman

@FryAmTheEggman धन्यवाद। मुझे लगता है कि यह छोटा होना चाहिए, लेकिन मैं यह पता नहीं लगा सकता कि कैसे

— श्री एक्सकोडर

2

जावा 8, 102 बाइट्स

लैम्ब्डा (curried) से int[]लैम्ब्डा से Integerकरने के लिए int[]। को सौंपे Function<int[], Function<Integer, int[]>>।

a->n->{int l=a.length,o[]=new int[l],i=0,j;for(;i<l;i++)for(j=i-n;j++<i;)o[i]+=a[(j%l+l)%l];return o;}

यह ऑनलाइन की कोशिश करो

अघोषित लंबोदर

a ->
    n -> {
        int
            l = a.length,
            o[] = new int[l],
            i = 0,
            j
        ;
        for (; i < l; i++)
            for (j = i - n; j++ < i; )
                o[i] += a[(j % l + l) % l];
        return o;
    }

(j % l + l) % lकिसी के लिए एक अप्रतिबंधित शेष गणना करता है j। यहां से ले गए ।

— जेकब
स्रोत

2

सी, 91 बाइट्स

i,j,k,s;f(a,l,n)int*a;{for(i=0;i<l;printf("%d ",s))for(j=n*l+i++,k=n,s=0;k--;)s+=a[j--%l];}

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

— Steadybox
स्रोत

2

ऑक्टेव, 53 बाइट्स

@(x,n)shift(imfilter(x,+!!(1:n),'circular'),fix(n/2))

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

imfilterविकल्प के साथ समारोह circularखिड़की के केंद्र में परिपत्र घुमाव की गणना करता है तो परिणाम स्थानांतरित कर दिया जाना चाहिए।

— rahnema1
स्रोत

2

05AB1E , 10 बाइट्स

.×ŒùOR¹g£R

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

व्याख्या

.×           # repeat input_1 input_2 times
  Œù         # push all sublists of size input_2
    O        # sum each
     R       # reverse the list
      ¹g£    # take the first len(input_1) items
         R   # reverse the list

— Emigna
स्रोत

2

पर्ल 6 , 42 39 बाइट्स

{@^a;[«+»] map {@a.rotate(-$_)},^$^b}

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

मेरी पहली पर्ल 6 एंट्री। शायद सुधारा जा सकता है।

— nwellnhof
स्रोत

ध्यान दें कि आप कभी-कभी प्लेसहोल्डर पैरामीटर वाले ब्लॉक के बजाय सिग्लिस चर के साथ एक नुकीले ब्लॉक का उपयोग करके लंबाई को कम कर सकते हैं ->\a,\b{[«+»] map {a.rotate(-$_)},^b}ध्यान दें कि यह इस मामले में नहीं है, लेकिन अगर यह एक और उदाहरण था$b कोड में ।

— ब्रैड गिल्बर्ट ने

2

कोटलिन , 141 140 138 बाइट्स

बस एक पहली बार जाना

प्रस्तुत करने

fun c(a:List<Int>,n:Int):List<Int>{
return (0..(a.size-1)).map{var t=0
for (o in 0..(n-1)){var i=it-o
while(i<0) {i+=a.size};t+=a[i]}
t}}

सजा हुआ

fun c(a: List<Int>, n: Int): List<Int> {
    return (0..(a.size - 1)).map {    // Iterate over the items
        var t = 0                     // Start the total at 0
        for (o in 0..(n - 1)) {       // Start at the item, go over the window backwards
            var i = it - o            // -------------------------
            while (i < 0) {           //  Make the index in range
                i += a.size           //
            }                         // -------------------------
            t += a[i]                 // Add the item to the total
        }
        t                             // Return the total
    }
}

TryItOnline

संपादित करता

अंतिम क्लोजिंग ब्रैकेट से पहले नईलाइन निकाली गई

— jrtapsell
स्रोत

1

Röda , 52 बाइट्स

f a,n{(a*n)|slide n|tail#a*n|{head n|sum}while open}

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

स्पष्टीकरण:

f a,n{
  (a*n)|    /* Push the items in a n times to the stream */
  slide n|  /* Create a sliding block of length n */
  tail#a*n| /* Push the last n*len(a) values in the stream to the stream */
  {         /* While there are elements in the stream (stream is open): */
    head n| /*   Pull n values from the stream */
    sum     /*   Sum them and push the sum to the stream */
  } while open
}

— fergusq
स्रोत

1

जावास्क्रिप्ट ईएस 6 80 80 बाइट्स

x=>n=>x.map((_,i)=>eval('for(L=x.length,N=0,j=++i-n;j<i;j++)N+=x[(j%L+L)%L]'))

2 बाइट्स ने नील को धन्यवाद दिया

उपयोग:

f=x=>n=>x.map((_,i)=>eval('for(L=x.length,N=0,j=++i-n;j<i;j++)N+=x[(j%L+L)%L]'))

f([2, 4, -3, 0, -4])(3)

— Bálint
स्रोत

1

,Nदिखता है मेरे लिए अनावश्यक ...

— नील

@ नील आप सही कह रहे हैं, धन्यवाद

— Bálint

1

पर्ल 5 , 66 + 1 (-ए) = 67 बाइट्स

$n=pop@F;$,=$";say map{$q=$c++;$t=0;$t+=$F[$q--%@F]for 1..$n;$t}@F

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

— Xcali
स्रोत

1

पायथन 2 , 69 61 बाइट्स

- 8 बाइट्स बहुत बहुत धन्यवाद @muru

lambda x,n:[sum((x[-n+1:]+x*n)[i:i+n])for i in range(len(x))]

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

स्पष्टीकरण:

पहले हमें यह सुनिश्चित करने की आवश्यकता है कि मूल सूची के बाईं ओर पर्याप्त संख्या है, यह द्वारा प्राप्त किया गया है x*n+x भाग ।

उदाहरण के लिए [2,4,-3,0,4],5:

                   ,2,4,-3,0,-4
 ....-4,2,4,-3,0,-4,2,4,-3,0,-4

तब हम सूची को उल्टा कर देंगे:

 <original->
 -4,0,-3,4,2, -4,0,-3, 4........
           <-2's block->

आगे हम प्रत्येक तत्व के लिए इसी ब्लॉक प्राप्त करते हैं [len(x)+~i:][:n]। टुकड़ा उल्टा होगा यानी 2 एक ब्लॉक हासिल करेगा: [2,-4,0,-3,4]जो उम्मीद के विपरीत है [4,-3,0,-4,2], लेकिन हमें योग की आवश्यकता है। तो, यह काम करता है। :)

— officialaimm
स्रोत

निश्चित नहीं है कि आपको पहले उल्टा क्यों करना है? क्या आप इसके बजाय बाद में रिवर्स स्लाइस को संशोधित नहीं कर सकते?

— श्री एक्सकोडर

@ Mr.Xcoder मुझे लगता है कि वहाँ एक रास्ता है, लेकिन यह रास्ता कम थकाऊ था इसलिए मैं इस के साथ चिपका रहा ...: D

— officialaimm

1

मुझे लगता है कि x[-n+1:]+x*nआपको रिवर्स ( lambda x,n:[sum((x[-n+1:]+x*n)[i:i+n])for i in range(len(x))]) के बिना, दोनों तरफ पर्याप्त पैडिंग के साथ सूची देनी चाहिए

— muru

1

@ muru क्या आपने इसे संपादित किया? अब यह काम कर रहा है। आपका बहुत बहुत धन्यवाद!

— आधिकारिक 10

1

आर , 101 93 89 बाइट्स

function(x,n,w=sum(x|1)){for(j in 1:w)F=c(F,sum(c(tail(rep(x,n),n-1),x)[1:n+j-1]))
F[-1]}

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

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

1

के (ओके) , 18 बाइट्स

समाधान:

{+/+y':(1-y+#x)#x}

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

उदाहरण:

{+/+y':(1-y+#x)#x}[1 2;5]
7 8
{+/+y':(1-y+#x)#x}[-5 4 0 1 0 -10 -4;4]
-19 -15 -5 0 5 -9 -13
{+/+y':(1-y+#x)#x}[-10 0 10;4]
-10 0 10

स्पष्टीकरण:

एक 31 बाइट समाधान के बारे में पोस्ट करने के लिए गया था, तब मुझे याद आया कि ओके में खिड़कियों को स्लाइड करने के लिए एक अंतर्निहित है ...

{+/+y':(1-y+#x)#x} / the solution
{                } / lambda with implicit x and y parameters
               #x  / take (#) from list x
       (    #x)    / length of x
          y+       / add y (window size)
        1-         / subtract from 1 to give a negative
    y':            / sliding window of size y
   +               / flip
 +/                / sum

बोनस:

31 बाइट समाधान भी में काम करता है K4 :

q)k){+/+x#y#'|+(:':\|(1-y+x:#x)#x)}[2 4 -3 0 -4;3]
-2 2 3 1 -7

— streetster
स्रोत

सर्कुलर मूविंग योग

उदाहरण

उदाहरण 1 (मान केवल एक बार पुन: उपयोग किए जाते हैं)

उदाहरण 2 (मान कई बार पुन: उपयोग किए जाते हैं)

अतिरिक्त नियम

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

जेली , 5 बाइट्स

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

MATL, 11 10 9 7 बाइट्स

गणितज्ञ, 29 बाइट्स

CJam (16 बाइट्स)

विच्छेदन

हास्केल, 57 बाइट्स

हास्केल , 69 65 64 बाइट्स

जाप , 12 बाइट्स

पायथ , 18 16 बाइट्स

स्पष्टीकरण (अद्यतन किया जाना है)

जावा 8, 102 बाइट्स

अघोषित लंबोदर

सी, 91 बाइट्स

ऑक्टेव, 53 बाइट्स

05AB1E , 10 बाइट्स

पर्ल 6 , 42 39 बाइट्स

कोटलिन , 141 140 138 बाइट्स

प्रस्तुत करने

सजा हुआ

TryItOnline

संपादित करता

Röda , 52 बाइट्स

जावास्क्रिप्ट ईएस 6 80 80 बाइट्स

उपयोग:

पर्ल 5 , 66 + 1 (-ए) = 67 बाइट्स

पायथन 2 , 69 61 बाइट्स

आर , 101 93 89 बाइट्स

के (ओके) , 18 बाइट्स