_{Remarque: Il s'agit du n ° 3 d'une série de défis de manipulation de tableaux . Pour le défi précédent, cliquez ici .}

Moyenne mobile d'une liste

La moyenne mobile d'une liste est un calcul résultant en une nouvelle liste lissée, créée en faisant la moyenne de petites sous-listes superposées de l'original.

Lors de la création d'une moyenne mobile, nous générons d'abord la liste des sous-listes qui se chevauchent en utilisant une certaine «taille de fenêtre», en déplaçant cette fenêtre vers la droite une fois à chaque fois.

Par exemple, étant donné la liste [8, 4, 6, 2, 2, 4]et la taille de la fenêtre 3, les sous-listes seraient:

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

Nous calculons ensuite la moyenne moyenne de chaque sous-liste pour obtenir le résultat: [6.0, 4.0, 3.3, 2.7](chaque valeur arrondie à une décimale).

Le défi

Votre tâche consiste à écrire un programme ou une fonction qui, étant donné une liste L et un entier 1 ≤ n ≤ longueur (L) , calcule la moyenne mobile de L en utilisant la taille de fenêtre n .

Règles:

• Votre programme peut utiliser une division entière ou une division flottante. Dans le cas de la division flottante, de petites inexactitudes dues aux limitations du type de données sont autorisées, tant que la valeur est par ailleurs correcte.
• Vous pouvez soumettre un programme complet ou une fonction (mais pas un extrait).
• Vous pouvez supposer que la liste ne contiendra que des entiers positifs .
• Les failles standard sont interdites.
• Il s'agit de code-golf , donc la réponse la plus courte (en octets) l'emporte!

Cas de test

Notez que, pour plus de lisibilité, toutes les valeurs sont arrondies à une décimale.

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]

Gelée , 3 octets

ṡÆm

Essayez-le en ligne!

Assez simple grâce à ṡ

Comment ça fonctionne

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

Wolfram Language (Mathematica) , 13 octets

^{Mathematica a une fonction intégrée pour tout}

MovingAverage

Essayez-le en ligne!

Prend une liste puis un rayon ...

Haskell , 47 octets

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

Essayez-le en ligne!

Sauvegardé deux octets grâce à xnor!

Dyalog APL, 4 octets

1 octet enregistré grâce à @Graham

2 octets enregistrés grâce à @ jimmy23013

Ai-je mentionné que l'APL n'est pas une langue de golf?

⊢+/÷

avec nà droite, ou

+/÷⊣

avec Là droite.

Essayez-le en ligne!

Comment?

÷- diviser Lparn

⊢+/- réduire +sur les fenêtres den

Python , 48 octets

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

Essayez-le en ligne!

Une fonction récursive. Plus court que le programme (50 octets)

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

Essayez-le en ligne!

Cela économise 2 octets en se terminant avec une erreur sur la whilecondition.

Inscrire , 3 octets

ṡÆm

Essayez-le en ligne!

Perl 6 , 33 octets

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

Essaye-le

Étendu:

{  # 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 octets

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

Essayez-le en ligne!

Déroulé:

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 octets

]+/\%

Essayez-le en ligne!

Prend ncomme argument de droite et la liste comme gauche. Nous remercions la solution d'Uriel pour l'idée de ne faire que la sommation dans l'infixe.

Explication

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

Solution précédente (7 octets)

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

Ohm v2 , 3 octets

ÇÆm

Essayez-le en ligne!

Explication:

ÇÆ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 octets

.O.:F

Essayez-le ici!

Comment ça marche

.O.: F - Programme complet.

    F - Réduisez l'entrée (liste imbriquée) avec ...
  .: - ... Sous-listes.
.O - Moyenne de chacun.

Octave , 33 31 octets

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

Essayez-le en ligne!

Explication

La convolution ( conv) est essentiellement une somme pondérée mobile. Si les poids sont choisis comme [1/n, ..., 1/n](obtenus comme ~~(1:n)/n) le résultat est une moyenne mobile, dont seule la 'valid'partie est conservée.

R , 72 octets

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

Essayez-le en ligne!

Calcule la meande toutes les nfenêtres de taille ; lorsque la fenêtre dépasse le bord de l, les résultats sont NAdonc nous les filtrons.

Forfait R + zoo, 13 octets

zoo::rollmean

Le zoopackage (infrastructure S3 pour les séries chronologiques régulières et irrégulières) possède de nombreuses fonctions pratiques. Vous pouvez l' essayer ici (R-violon) .

Japt v2.0a0, 7 octets

ãV ®x÷V

Essayez-le

Explication

Entrée implicite de tableau Uet d'entier V.

ãV

Obtenez des sous-sections de UlongueurV

®

Carte sur les sous-sections.

÷V

Divisez chaque élément par V.

x

Additionnez tous les éléments.

Python 3 , 61 octets

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

Essayez-le en ligne!

Python 3 , 55 octets

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

Essayez-le en ligne!

05AB1E , 5 octets

ŒsùÅA

Explication:

Π    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.

Essayez-le en ligne!

Mathematica, 21 octets

Mean/@##~Partition~1&

Essayez-le en ligne!

-3 octets JungHwan Min

Proton , 46 octets

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

Essayez-le en ligne!

Notez que cela prend une entrée via la syntaxe des fonctions de curry et retourne une liste de fractions.

CJam, 14 12 octets

^{-2 octets grâce à @aditsu}

{_@ew::+\f/}

Jq 1,5 , 61 octets

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

Étendu

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

Essayez-le en ligne!

JavaScript (ES6), 53 octets

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

PHP, 94 octets

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

Essayez-le en ligne!

Clojure , 48 octets

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

Essayez-le en ligne!

Empilé , 22 octets

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

Essayez-le en ligne!

Explication

infixesgénère toutes les fenêtres de la longueur donnée. Ensuite, nous mappons notre propre fonction moyenne sur chaque infixe.

Lisp commun , 77 octets

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

Essayez-le en ligne!

K (oK) , 13 11 octets

Solution:

{+/+x':y%x}

Essayez-le en ligne!

Exemples:

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

Explication:

oK a une fonction intégrée pour créer une fenêtre coulissante, puis résumez les tableaux résultants et divisez par taille de fenêtre coulissante pour obtenir la moyenne:

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

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 octets

Enregistrement d'un octet avec la syntaxe curry.

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

Essayez-le en ligne!

Java 8, 111 octets

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

Explication:

Essayez-le ici.

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