चुनौतियां # 3 का एक ऐरे: मूविंग एवरेज

Question

_{नोट: यह सरणी-हेरफेर चुनौतियों की एक श्रृंखला में # 3 है । पिछली चुनौती के लिए, यहां क्लिक करें ।}

सूची का औसत बढ़ना

औसत चलती सूची की गणना के लिए एक नया, सूची समतल, मूल के छोटे ओवरलैपिंग उप-सूचियों औसत के द्वारा बनाई गई है, जिसके परिणामस्वरूप है।

एक मूविंग एवरेज बनाते समय, हम पहली बार एक निश्चित 'विंडो साइज़' का उपयोग करके ओवरलैप करने वाले सब्लिस्ट की सूची बनाते हैं, इस विंडो को हर बार एक बार दाईं ओर शिफ्ट करते हैं।

उदाहरण के लिए, सूची [8, 4, 6, 2, 2, 4]और खिड़की के आकार को देखते हुए 3, उदात्त लोग होंगे:

[8,  4,  6,  2,  2,  4]          Sublists:
(         )                  <-  [8, 4, 6]
    (         )              <-  [4, 6, 2]
        (         )          <-  [6, 2, 2]
            (         )      <-  [2, 2, 4]

हम परिणाम प्राप्त करने के लिए प्रत्येक सबलिस्ट के औसत औसत की गणना करते हैं : [6.0, 4.0, 3.3, 2.7](प्रत्येक मूल्य एक दशमलव स्थान पर गोल)।

---

चुनौती

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है, जिसने एक सूची L , और एक पूर्णांक 1 ≤ n (लंबाई (L) दिया है , के लिए चलती औसत की गणना करें L के लिए विंडो के आकार n का उपयोग करके ।

नियम:

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

---

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

ध्यान दें कि पठनीयता में आसानी के लिए, सभी मानों को एक दशमलव स्थान पर रखा जाता है।

n=5, [1, 2, 3, 4, 5, 6, 7, 8]      ->      [3, 4, 5, 6]
n=3, [100, 502, 350, 223, 195]     ->      [317.3, 358.3, 256]
n=1, [10, 10, 10]                  ->      [10, 10, 10]
n=3, [10, 20, 30]                  ->      [20]
n=2, [90, 40, 45, 100, 101]        ->      [65, 42.5, 72.5, 100.5]

Comments

क्या हमें फ्लोट मानों को गोल करना है, या हम उन्हें छोड़ सकते हैं जैसे वे हैं?

— caird coinheringaahing

@cairdcoinheringaahing ध्यान दें कि पठनीयता में आसानी के लिए , सभी मानों को एक दशमलव स्थान पर रखा जाता है । मेरी राय में, आप निश्चित रूप से उन्हें छोड़ सकते हैं क्योंकि वे हैं (कम से कम यही मुझे समझ में आता है)।

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

@cairdcoinheringaahing मैं I / O के साथ काफी उदार रहा हूं: पूर्णांक या फ्लोट मान ठीक हैं, यदि आप चाहते हैं तो आप गोल कर सकते हैं और फ्लोटिंग पॉइंट त्रुटियां होने की अनुमति है

— FlipTack

क्या फ़्लोटिंग पॉइंट नंबरों के बजाय अंशों को वापस करना ठीक है?

— जुंगवान मिन

@JungHwanMin यदि सटीकता के लिए, आपकी भाषा मानों को फ़्लोट्स के बजाय भिन्न के रूप में संग्रहीत करेगी, तो उन्हें अपने सरलतम रूपों में सटीक अंशों के रूप में प्रिंट करना ठीक है।

— पलटें

Answer 1

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

ṡÆm

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

बहुत सरल धन्यवाद ṡ

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

ṡÆm - Main dyadic link. Arguments: l (list) and n (integer)
ṡ   - Split l into sublists of length n
 Æm - Mean of each

Answer 2

वोल्फ्राम लैंग्वेज (मैथेमेटिका) , 13 बाइट्स

^{गणितज्ञ के पास हर चीज के लिए एक अंतर्निर्मित है}

MovingAverage

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

एक सूची लेता है और फिर एक त्रिज्या ...

Comments

MovingAverageThis _____ ಠ मैं इस पर विश्वास करने से इनकार करता हूं

— श्री Xcoder

@cairdcoinheringaahing संख्यात्मक मान लेता है। MovingAverageभिन्न का एक सेट देता है। अब यह ओपी द्वारा अनुमति दी गई है, MovingAverageवास्तव में पर्याप्त होना चाहिए।

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

Answer 3

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

n!a|length a<n=[]|_:t<-a=div(sum$take n a)n:n!t

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

Xnor के लिए धन्यवाद दो बाइट्स सहेजे गए!

Comments

tail aगार्ड में निकाला जा सकता है।

— xnor

गह, मुझे पता था कि मुझे कुछ याद आ रहा है। धन्यवाद!

— लिन

Answer 4

Dyalog एपीएल, 4 बाइट्स

1 बाइट ने @ ग्राहम को धन्यवाद दिया

2 बाइट्स @ jimmy23013 की बदौलत बच गए

क्या मैंने उल्लेख किया है कि एपीएल एक गोल्फ भाषा नहीं है?

⊢+/÷

साथ nसही पर, या

+/÷⊣

साथ में L सही पर।

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

कैसे?

÷ - बांट लो L द्वाराn

⊢+/- की +खिड़कियों पर कम करेंn

Comments

कमी से पहले L को n से विभाजित क्यों नहीं करते। एक बाइट बचाता है

— ग्राहम

⊢ + /

— ⊢

या + /

— jimmy23013

@ jimmy23013 बहुत बहुत धन्यवाद! मैंने कोशिश की कि पहले एक, लेकिन तर्क गलत टाइप करना चाहिए क्योंकि यह काम नहीं किया।

— एरियल

Answer 5

पायथन , 48 बाइट्स

f=lambda n,l:l[n-1:]and[sum(l[:n])/n]+f(n,l[1:])

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

एक पुनरावर्ती कार्य। कार्यक्रम की तुलना में कम (50 बाइट्स)

n,l=input()
while l[-n]:print sum(l[:n])/n;l=l[1:]

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

इस whileशर्त पर त्रुटि के साथ समाप्त करके 2 बाइट्स बचाता है ।

Answer 6

सूची , 3 बाइट्स

ṡÆm

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

Comments

जेली के साथ पॉलीग्लॉट: पी

— केयर्ड सिक्काहिरिंगहिंग

@cairdcoinheringaahing मैंने केवल आपके जेली उत्तर पर बहुत अधिक ध्यान दिया है: P

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

Answer 7

पर्ल 6 , 33 बाइट्स

{@^a.rotor($^b=>1-$b)».sum X/$b}

झसे आज़माओ

विस्तारित:

{  # bare block with placeholder parameters ｢@a｣, ｢$b｣

  @^a                # declare and use first param

  .rotor(            # split it into chunks
    $^b              # declare and use second param
    =>               # pair it with
    1 - $b           # one less than that, negated

  )».sum             # sum each of the sub lists

  X/                 # cross that using &infix:«/»

  $b                 # with the second param
}

Answer 8

सी,  86   84  83 बाइट्स

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

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

unrolled:

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

Answer 9

जे, ₇ 5 बाइट्स

]+/\%

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

nसही तर्क के रूप में लेता है और सूची बाएं के रूप में। इनफ़िक्स में केवल योग करने के विचार के लिए उरीएल के समाधान का श्रेय।

व्याख्या

]+/\%
    %  Divide list by n
]+/\   Sum on overlapping intervals of size n

पिछला समाधान (7 बाइट्स)

(+/%#)\
      \  Apply to overlapping intervals of size n
(+/%#)   Mean
 +/        Sum
   %       Divided by
    #      Length

Answer 10

ओम v2 , 3 बाइट्स

ÇÆm

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

स्पष्टीकरण:

ÇÆm  Main wire, arguments l (list) and n (integer)

Ç    All consecutive sublists of l with length n
 Æm  Arithmetic mean of each sublist

Answer 11

अजगर , 5 बाइट्स

.O.:F

यहाँ यह कोशिश करो!

यह कैसे काम करता है

.ओ।: एफ - पूर्ण कार्यक्रम।

    एफ - के साथ इनपुट (नेस्टेड सूची) को कम करें ...
  :: - ... उदात्तवादी।
.ओ - प्रत्येक का औसत।

Answer 12

ऑक्टेव , 33 31 बाइट्स

@(x,n)conv(x,~~(1:n)/n,'valid')

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

व्याख्या

वार्तालाप ( conv) अनिवार्य रूप से एक चलती भारित राशि है। यदि वज़न चुना जाता है [1/n, ..., 1/n]( जैसा कि प्राप्त किया जाता है ~~(1:n)/n) तो परिणाम एक चलती औसत है, जिसमें से केवल 'valid'भाग रखा जाता है।

Answer 13

आर , 72 बाइट्स

function(l,n)(k=sapply(0:sum(l|1),function(x)mean(l[x+1:n])))[!is.na(k)]

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

meanसभी आकार की nखिड़कियों की गणना ; जब खिड़की किनारे जाती है l, तो परिणाम होते हैं NAइसलिए हम उन्हें फ़िल्टर करते हैं।

आर + चिड़ियाघर पैकेज, 13 बाइट्स

zoo::rollmean

zooपैकेज (नियमित और अनियमित समय श्रृंखला के लिए S3 बुनियादी ढांचे) काम कार्यों का एक बहुत कुछ है। आप इसे यहाँ (R-fiddle) आज़मा सकते हैं ।

Answer 14

Japt v2.0a0, 7 बाइट्स

ãV ®x÷V

कोशिश करो

---

व्याख्या

सरणी Uऔर पूर्णांक का निहित इनपुट V।

ãV

Uलंबाई के साथ उप-भाग प्राप्त करेंV

®

उपखंडों का नक्शा।

÷V

प्रत्येक तत्व को विभाजित करें V।

x

सभी तत्वों को सम।

Answer 15

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

lambda l,n:[sum(e)/n for e in zip(*[l[i:]for i in range(n)])]

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

Answer 16

पायथन 3 , 55 बाइट्स

lambda n,A:[sum(A[j:n+j])/n for j in range(-n-~len(A))]

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

Answer 17

05AB1E , 5 बाइट्स

ŒsùÅA

स्पष्टीकरण:

Π    All substrings
 sù   Keep those only where the length is equal to <the second input>
   ÅA Arithmetic mean of each element in the resulting array.

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

Answer 18

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

Mean/@##~Partition~1&

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

-3 बाइट्स जुंगवान मिन

Comments

-3 बाइट्स:N[Mean/@##~Partition~1]&

— जंगवान मिन

Answer 19

प्रोटॉन , 46 बाइट्स

n=>l=>[sum(l[h to h+n])/n for h:0..len(l)-n+1]

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

ध्यान दें कि यह क्यूरिंग फ़ंक्शंस सिंटैक्स के माध्यम से इनपुट लेता है, और भिन्न की एक सूची देता है।

Answer 20

CJam, 14 12 बाइट्स

^{-2 बाइट्स @aditsu को धन्यवाद}

{_@ew::+\f/}

Answer 21

Jq 1.5 , 61 बाइट्स

def f(N;L):[L|range(0;1+length-N)as$i|.[$i:$i+N]|add/length];

विस्तारित

def f(N;L):
  [   L
    | range(0;1+length-N) as $i        # generate
    | .[$i:$i+N]                       # sublists
    | add/length                       # compute mean
  ];

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

Answer 22

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

(l,n)=>l.map(e=>(s+=e-=a[i-n]||0)/n,s=i=0).slice(n-1)

Answer 23

PHP, 94 बाइट्स

function f($l,$n){while($i<=count($l)-$n)$r[]=array_sum(array_slice($l,$i++,$n))/$n;return$r;}

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

Answer 24

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

(fn[n a](map #(/(apply + %)n)(partition n 1 a)))

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

Answer 25

स्टैक्ड , 22 बाइट्स

[infixes[:sum\#'/]map]

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

व्याख्या

infixesदी गई लंबाई की सभी खिड़कियां बनाता है। फिर, हम प्रत्येक इन्फिक्स पर अपना औसत फ़ंक्शन मैप करते हैं।

Answer 26

आम लिस्प , 77 बाइट्स

(defun f(x y)(if(>=(length x)y)(cons(/(apply'+(subseq x 0 y))y)(f(cdr x)y))))

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

Answer 27

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

समाधान:

{+/+x':y%x}

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

उदाहरण:

{+/+x':y%x}[3;8 4 6 2 2 4]
6 4 3.3333 2.6667
{+/+x':y%x}[5;1 2 3 4 5 6 7 8]
3 4 5 6

स्पष्टीकरण:

oK स्लाइडिंग विंडो बनाने के लिए अंतर्निहित है, फिर परिणामी सरणियों को योग करें और औसत प्राप्त करने के लिए खिड़की के आकार को स्लाइड करके विभाजित करें:

{+/+x':y%x} / the solution
{         } / lambda function taking x and y as implicit parameters
       y%x  / y (list) by x (sliding array size)
    x':     / sliding window of size x over list y
   +        / flip array (rotate by 90 degrees)
 +/         / sum up array

Comments

ऐसा लगता है कि आपको फ्लिप सरणी + की आवश्यकता नहीं है, और यदि K में APL जैसा कम्यूट है तो आप x%[commute]बाईं ओर जा सकते हैं और परेंस को गिरा सकते हैं

— Uriel

फ्लिप सुनिश्चित करने के लिए योग है की जरूरत है भर के बजाय प्रत्येक सूची में नीचे, और काफी यकीन है कि वहाँ कोई लघुकरण ऑपरेटर है, कम से कम कुछ भी नहीं में यह सुझाव देने पर मैनुअल । चियर्स हालांकि!

— स्ट्रीटस्टर

Answer 28

DataWeave , 50 बाइट्स

fun s(l,w)=0 to(sizeOf(l)-w)map avg(l[$ to $+w-1])

%dw 2.0
output application/json

fun sma(list: Array<Number>, window: Number) =
  0 to (sizeOf(list) - window)  // generate starting indices of sublists
  map list[$ to $ + window - 1] // generate sublists
  map avg($)                    // calculate averages

---
sma([90, 40, 45, 100, 101], 2)

Answer 29

फंकी , 67 66 बाइट्स

करी वाक्यविन्यास के साथ एक बाइट को बचाया।

n=>t=>{k={}fori=0i<=(#t)-n i++k[i]=(forj=c=0c<n c++j+=t[i+c])/n k}

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

Answer 30

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

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

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

a->n->{                 // Method with array and int parameters and float-array return-type
  int l=a.length-n+1,   //  New length of the return-array
      i=0,j;            //  Index-integers
  float[]r=new float[l];//  Return-array
  for(;i<l;             //  Loop (1) from 0 to `l` (exclusive)
      r[i++]/=n)        //    After every iteration, divide the current item by input `n`
    for(j=i;j<i+n;      //   Inner loop (2) from `i` to `i+n` (exclusive)
      r[i]+=a[j++]      //    Sum the result at index `i` with the items of the input-array
    );                  //   End of inner loop (2)
                        //  End of loop (1) (implicit / single-line body)
  return r;             //  Return the resulting float-array
}                       // End of method