_{หมายเหตุ: นี่คือ # 3 ในชุดของความท้าทายการจัดการอาร์เรย์ สำหรับความท้าทายก่อนหน้านี้คลิกที่นี่}

ค่าเฉลี่ยเคลื่อนที่ของรายการ

ค่าเฉลี่ยเคลื่อนที่ของรายการคือการคำนวณผลในใหม่เรียบออกรายการที่สร้างขึ้นโดยเฉลี่ย sublists ที่ทับซ้อนกันเล็ก ๆ ของเดิม

เมื่อสร้างค่าเฉลี่ยเคลื่อนที่อันดับแรกเราจะสร้างรายการของรายการย่อยที่ทับซ้อนกันโดยใช้ 'ขนาดหน้าต่าง' ที่แน่นอนเลื่อนหน้าต่างนี้ไปทางขวาหนึ่งครั้งในแต่ละครั้ง

ตัวอย่างเช่นเมื่อกำหนดรายการ[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]

เยลลี่ 3 ไบต์

ṡÆm

ลองออนไลน์!

ขอบคุณง่าย ๆ ṡ

มันทำงานอย่างไร

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

ภาษา Wolfram (Mathematica)ขนาด 13 ไบต์

^{Mathematica มีทุกสิ่งในตัว}

MovingAverage

ลองออนไลน์!

ใช้รายการแล้วรัศมี ...

Haskell , 47 ไบต์

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

ลองออนไลน์!

บันทึกสองไบต์ด้วย xnor!

Dyalog APL ขนาด 4 ไบต์

บันทึก 1 ไบต์ขอบคุณ @Graham

บันทึก 2 ไบต์ด้วย @ jimmy23013

ฉันพูดถึง APL ไม่ใช่ภาษากอล์ฟหรือไม่?

⊢+/÷

ด้วยnด้านขวาหรือ

+/÷⊣

ด้วยLด้านขวา

ลองออนไลน์!

อย่างไร?

÷- หารLด้วยn

⊢+/- ลด+บน windows ของn

Pythonขนาด 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:]

ลองออนไลน์!

สิ่งนี้จะช่วยประหยัด 2 ไบต์โดยยกเลิกด้วยข้อผิดพลาดในwhileเงื่อนไข

รายการ , 3 ไบต์

ṡÆm

ลองออนไลน์!

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

C,  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];}

ลองออนไลน์!

คลี่:

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

J, ₇ 5 ไบต์

]+/\%

ลองออนไลน์!

ใช้nเป็นอาร์กิวเมนต์ที่ถูกต้องและรายการเป็นด้านซ้าย ให้เครดิตกับโซลูชันของ Uriel สำหรับแนวคิดในการทำเพียงการรวมในมัด

คำอธิบาย

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

โซลูชันก่อนหน้า (7 ไบต์)

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

โอห์ม 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

Pyth , 5 ไบต์

.O.:F

ลองที่นี่!

วิธีนี้ใช้ได้ผล

.O.: F - โปรแกรมเต็มรูปแบบ

    F - ลดอินพุต (รายการซ้อนกัน) ด้วย ...
  .: - ... Sublists
.O - ค่าเฉลี่ยของแต่ละ

อ็อกเทฟ33 33ไบต์

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

ลองออนไลน์!

คำอธิบาย

Convolution ( conv) เป็นผลรวมถ่วงน้ำหนักที่เคลื่อนไหว หากน้ำหนักถูกเลือกเป็น[1/n, ..., 1/n](ได้รับตาม~~(1:n)/n) ผลที่ได้คือค่าเฉลี่ยเคลื่อนที่ซึ่งมีการ'valid'เก็บรักษาเฉพาะส่วน

R , 72 ไบต์

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

ลองออนไลน์!

คำนวณหน้าต่างmeanทุกขนาด nเมื่อหน้าต่างผ่านขอบlผลลัพธ์จะเป็นNAดังนั้นเราจึงกรองออก

แพ็คเกจ R + สวนสัตว์ขนาด 13 ไบต์

zoo::rollmean

zooแพคเกจ (โครงสร้างพื้นฐานสำหรับ S3 ปกติและผิดปกติเวลา Series) มีจำนวนมากของฟังก์ชั่นที่มีประโยชน์ คุณอาจจะลองมันนี่ (R-ซอ)

Japt v2.0a0, 7 ไบต์

ãV ®x÷V

ลองมัน

คำอธิบาย

การป้อนข้อมูลโดยปริยายของอาร์เรย์และจำนวนเต็มUV

ãV

รับส่วนย่อยของที่UมีความยาวV

®

แผนที่เหนือส่วนย่อย

÷V

Vแบ่งแต่ละองค์ประกอบโดย

x

รวมองค์ประกอบทั้งหมด

Python 3 , 61 ไบต์

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

ลองออนไลน์!

Python 3 , 55 ไบต์

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

ลองออนไลน์!

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.

ลองออนไลน์!

Mathematica ขนาด 21 ไบต์

Mean/@##~Partition~1&

ลองออนไลน์!

-3 bytes JungHwan Min

โปรตอนขนาด 46 ไบต์

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

ลองออนไลน์!

โปรดทราบว่าการทำเช่นนี้จะรับอินพุตผ่านทางไวยากรณ์ของฟังก์ชันการปิดกั้นและส่งกลับรายการเศษส่วน

CJam, 14 12 ไบต์

^{-2 ไบต์ขอบคุณ @aditsu}

{_@ew::+\f/}

Jq 1.5 , 61 bytes

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

ลองออนไลน์!

JavaScript (ES6), 53 ไบต์

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

PHP, 94 ไบต์

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

ลองออนไลน์!

Clojure 48 ไบต์

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

ลองออนไลน์!

ซ้อนกัน , 22 ไบต์

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

ลองออนไลน์!

คำอธิบาย

infixesสร้างหน้าต่างทั้งหมดตามความยาวที่กำหนด จากนั้นเราแมปฟังก์ชันการทำงานเฉลี่ยของเราเหนือแต่ละมัด

Lisp ทั่วไป , 77 ไบต์

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

ลองออนไลน์!

K (oK) , 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

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)

ฟังกี้ , 67 66 ไบต์

บันทึกไบต์ด้วยไวยากรณ์แกง

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

ลองออนไลน์!

Java 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