Un tableau de défis # 3: Moyennes mobiles

16

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]
code-golf math arithmetic array-manipulation statistics FlipTack
la source
Devons-nous arrondir les valeurs flottantes ou pouvons-nous les laisser telles quelles?
caird coinheringaahing
3
@cairdcoinheringaahing Notez que, pour plus de lisibilité , toutes les valeurs sont arrondies à une décimale . À mon avis, vous pouvez certainement les laisser tels quels (du moins c'est ce que je comprends).
M. Xcoder
@cairdcoinheringaahing J'ai été assez libéral avec les E / S: les valeurs entières ou flottantes sont correctes, vous pouvez arrondir si vous le souhaitez mais n'y êtes pas obligé, et les erreurs en virgule flottante sont autorisées
FlipTack
Est-il correct de renvoyer des fractions au lieu de nombres à virgule flottante?
JungHwan Min
@JungHwanMin Si pour plus de précision, votre langue stockera les valeurs sous forme de fractions plutôt que de flottants, il est bon de les imprimer sous forme de fractions précises dans leurs formes les plus simples.
FlipTack

Réponses:

7

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
caird coinheringaahing
la source
7

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

JungHwan Min
la source
6
MovingAverageಠ _____ ಠ Je refuse de le croire
M. Xcoder
@cairdcoinheringaahing Prend la valeur numérique. MovingAveragerenvoie un ensemble de fractions. Maintenant que cela a été autorisé par le PO, cela MovingAveragedevrait suffire.
M. Xcoder
7

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!

Lynn
la source
1
tail apeut être extrait dans la garde.
2017
Gah, je savais que je manquais quelque chose comme ça. Je vous remercie!
Lynn
7

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

Uriel
la source
Pourquoi ne pas diviser L par n avant la réduction. Enregistre un octet
Graham
⊢ + / ÷
jimmy23013
Ou + / ÷ ⊣
jimmy23013
@ jimmy23013 merci beaucoup! J'ai essayé celui-là plus tôt, mais j'ai dû mal taper les arguments parce que cela ne fonctionnait pas.
Uriel
6

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.

xnor
la source
4

Inscrire , 3 octets

ṡÆm

Essayez-le en ligne!

M. Xcoder
la source
Polyglotte avec gelée: P
caird coinheringaahing
@cairdcoinheringaahing Je viens juste de remarquer votre réponse Jelly trop lol: P
M. Xcoder
4

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
}
Brad Gilbert b2gills
la source
4

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];
}
Steadybox
la source
4

J, 7 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
cole
la source
4

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
Nick Clifford
la source
3

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.
M. Xcoder
la source
3

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.

Luis Mendo
la source
2

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

Giuseppe
la source
2

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.

Hirsute
la source
1

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!

Okx
la source
1

Mathematica, 21 octets

Mean/@##~Partition~1&

Essayez-le en ligne!

-3 octets JungHwan Min

J42161217
la source
-3 octets:N[Mean/@##~Partition~1]&
JungHwan Min
1

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.

M. Xcoder
la source
1

CJam, 14 12 octets

-2 octets grâce à @aditsu 

{_@ew::+\f/}
Esolanging Fruit
la source
0

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!

jq170727
la source
0

JavaScript (ES6), 53 octets

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

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!

Jo.
la source
0

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.

Conor O'Brien
la source
0

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
streetster
la source
Il semble que vous n'ayez pas besoin du tableau inversé +, et si K a fait la navette comme APL, vous pouvez vous déplacer x%[commute]vers la gauche et supprimer les parens
Uriel
Le retournement est nécessaire pour s'assurer que la somme est à travers plutôt que vers le bas de chaque liste, et assez sûr qu'il n'y a pas d'opérateur de navette, du moins rien à suggérer dans le manuel . Bravo cependant!
streetster
0

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)
menduz
la source
0

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!

ATaco
la source
0

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
Kevin Cruijssen
la source