_{注意：这是一系列阵列操作挑战中的第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]每个值四舍五入到小数点后一位）。

挑战

你的任务是写一个程序或其中，给定一个列表功能大号和整数1个≤N≤长度（L） ，计算移动平均为大号使用窗口大小Ñ。

规则：

• 您的程序可能使用整数除法或浮点除法。对于浮点除法，只要值是正确的，就可以允许由于数据类型的限制而产生的小误差。
• 您可以提交完整的程序或功能（而不是代码段）。
• 您可以假定列表仅包含正整数。
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此最短的答案（以字节为单位）获胜！

测试用例

请注意，为了便于阅读，所有值均四舍五入到小数点后一位。

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个字节

@Graham节省了1个字节

@ jimmy23013节省了2个字节

我是否提到APL 不是高尔夫语言？

⊢+/÷

与n右边，或

+/÷⊣

与L右侧。

在线尝试！

怎么样？

÷-分L由n

⊢+/-减少+窗户的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:]

在线尝试！

通过在while条件上终止错误来节省2个字节。

征募，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，_7个 5字节

]+/\%

在线尝试！

注意到n作为右边的参数和列表，左侧。归功于Uriel解决方案的想法，即只对infix进行求和。

说明

]+/\%
    %  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-使用...减少输入（嵌套列表）
  。：-...子列表。
.O-每个平均值。

八度，33 31字节

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

在线尝试！

说明

卷积（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 + zoo包，13字节

zoo::rollmean

该zoo程序包（用于定期和不定期时间序列的S3基础结构）具有许多方便的功能。您可以在这里尝试（R-fiddle）。

Japt v2.0a0，7个字节

ãV ®x÷V

尝试一下

说明

数组U和整数的隐式输入V。

ã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字节JungHwan Min

质子，46字节

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

在线尝试！

请注意，这通过currying函数语法获取输入，并返回分数列表。

CJam，14 12个字节

^{-2字节感谢@aditsu}

{_@ew::+\f/}

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

在线尝试！

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