_{Примітка. Це номер 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]

Желе , 3 байти

ṡÆm

Спробуйте в Інтернеті!

Досить просто завдяки ṡ

Як це працює

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

Мова Вольфрама (Mathematica) , 13 байт

^{У Mathematica є вбудований для всього}

MovingAverage

Спробуйте в Інтернеті!

Знімає список, а потім радіус ...

Haskell , 47 байт

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

Спробуйте в Інтернеті!

Збережено два байти завдяки xnor!

Діалог APL, 4 байти

1 байт збережено завдяки @Graham

2 байти збережено завдяки @ jimmy23013

Я згадав, що APL не є мовою для гольфу?

⊢+/÷

з nправоруч, або

+/÷⊣

з Lправоруч.

Спробуйте в Інтернеті!

Як?

÷- ділити Lнаn

⊢+/- зменшити +на windowsn

Пітон , 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 - Зменшити вхід (вкладений список) за допомогою ...
  .: - ... Підсписки.
.O - середнє значення кожного.

Октава , 33 31 байт

@(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 інфраструктура для регулярних і нерегулярних тимчасових рядів) має багато корисних функцій. Ви можете спробувати тут (R-скрипка) .

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.

Спробуйте в Інтернеті!

Математика, 21 байт

Mean/@##~Partition~1&

Спробуйте в Інтернеті!

-3 байт Хв. Хван Мін

Протон , 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/}

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

Спробуйте в Інтернеті!

JavaScript (ES6), 53 байти

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

PHP, 94 bytes

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

Try it online!

Clojure, 48 bytes

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

Try it online!

Stacked, 22 bytes

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

Try it online!

Explanation

infixes generates all the windows of the given length. Then, we map our own average function over each infix.

Common Lisp, 77 bytes

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

Try it online!

K (oK), 13 11 bytes

Solution:

{+/+x':y%x}

Try it online!

Examples:

{+/+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

Explanation:

oK has a built-in for creating a sliding window, then sum up resulting arrays and divide by sliding window size to get mean:

{+/+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 bytes

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)

Funky, 67 66 bytes

Saved a byte with curry syntax.

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

Try it online!

Java 8, 111 bytes

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

Explanation:

Try it here.

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