Étant donné une entrée d'un entier n et une liste d'entiers positifs m ₁ , m ₂ , ..., sortir une liste d'entiers m ₁ ' , m ₂ ' , ... où m _x ' est défini comme la moyenne de m _xn à m _{x + n} .

Lors du calcul de ces moyennes, ignorez les indices qui sont hors limites (et ajustez ce que vous divisez la somme en conséquence). n sera toujours ≥ 1 mais jamais la moitié de la longueur de m (arrondie vers le bas) ou plus. Cela signifie que la longueur minimale de m est 4. Les éléments de m seront des entiers positifs, mais la sortie doit être précise à au moins 3 décimales.

Les éléments d'entrée / sortie qui sont des listes peuvent être des chaînes séparées par des espaces / virgules ou des tableaux / listes / etc. Pour la saisie, si votre solution est une fonction, vous pouvez en outre prendre un premier argument de n et des arguments supplémentaires comme m _x (cela s'applique également aux arguments de ligne de commande).

Voici une représentation visuelle de n=1:

1 4 5 7 10
__/ | | |
L avg(1,4) = 2.5
    | | |
\___/ | |
  L avg(1,4,5) = 3.333
      | |
  \___/ |
    L avg(4,5,7) = 5.333
        |
    \___/
      L avg(5,7,10) = 7.333

      \___
        L avg(7,10) = 8.5

Final output: 2.5 3.333 5.333 7.333 8.5

Puisqu'il s'agit de code-golf , le code le plus court en octets l'emporte.

Cas de test ( ceux-ci ont été effectués manuellement; veuillez me signaler toute erreur ):

In                             Out
----------------------------------------------------------------------
n=1, m=12 6 3 9                9 7 6 6
n=1, m=1 4 5 7 10              2.5 3.333 5.333 7.333 8.5
n=1, m=1 3 3 7 4 2 4 2         2 2.333 4.333 4.666 4.333 3.333 2.666 3
n=2, m=1 3 5 9 10 14 15 16 23  3 4.5 5.6 8.2 10.6 12.8 15.6 17 18
n=3, m=1 1 1 1 1 1 1 1         1 1 1 1 1 1 1 1
n=3, m=1 2 3 4 5 6 7 8         2.5 3 3.5 4 5 5.5 6 6.5

Pyth, 20 octets

m.O:vzeS,0-dQh+dQUvz

Suite de tests

Assez simple, coupez simplement la section appropriée de la liste, puis faites la moyenne.

MATL , 30 28 26 24 octets

2*1+:g2X53$X+1Mbgbb3$X+/

Testé sur Matlab et sur Octave. Utilise la version actuelle (9.1.0) du langage / compilateur.

L'entrée est: d'abord le nombre contrôlant la longueur de la fenêtre, puis le tableau avec le format [1 4 5 7 10].

EDIT (20 mai 2016): Essayez-le en ligne! Le code dans le lien a été X+remplacé parY+ pour se conformer à la version 18.0.0 de la langue.

Exemple

>> matl
 > 2*1+:g2X53$X+1Mbgbb3$X+/
 >
> 1
> [1 4 5 7 10]
2.5 3.333333333333333 5.333333333333333 7.333333333333333               8.5

>> matl
 > 2*1+:g2X53$X+1Mbgbb3$X+/
 >
> 2
> [1 3 5 9 10 14 15 16 23]
3               4.5               5.6 8.199999999999999              10.6               2.8              15.6        17                18

Explication

Le code Matlab équivalent serait

n = 1; %// first input: number controlling window length
x = [1 4 5 7 10]; %// second input: array
result = conv(x,ones(1,2*n+1),'same')./conv(ones(size(x)),ones(1,2*n+1),'same');

Le code MATL utilise les fonctionnalités récemment ajoutées de l'entrée implicite et du presse-papiers d'entrée de fonction automatique:

2*1+          % get implicit input "n". Multipliy by 2 and add 1
:g            % create a vector of 2*n+1 "true" values (will act as "one" values)
2X5           % 'same' string literal
3$X+          % get implicit input "x" (array). Convolution using three inputs
1M            % push all three inputs from last function
bgbb          % convert first input to "true" values. Will act as "one" values
3$X+          % convolution using three inputs
/             % divide element-wise. Implicitly print

CJam, 31 30 octets

ri_S*l~1$++\2*)ew{S-_:+\,d/}%`

Le format d'entrée est n [m1 m2 ... mx].

Exécutez tous les cas de test. (Convertit automatiquement la suite de tests au format d'entrée requis.)

Cela fonctionne en pré et en ajoutant des nespaces, puis en prenant toutes les sous-chaînes de longueur 2n+1et en supprimant à nouveau les espaces avant de calculer leurs moyennes.

Julia, 57 octets

f(n,m)=[mean(m[max(1,i-n):min(end,i+1)])for i=1:endof(m)]

Il s'agit d'une fonction qui accepte deux entiers et renvoie un tableau de flottants.

L'approche ici est très simple. Nous construisons un nouveau tableau en prenant la moyenne des sections du tableau d'entrée, en tronquant à l'avant et à l'arrière.

Haskell, 97 95 octets

import Data.List
n#x|t<-2*n+1=[sum a/sum(1<$a)|a<-take t<$>take t(inits x)++tails x,length a>n]

Exemple d'utilisation: 2 # [1,3,5,9,10,14,15,16,23]->[3.0,4.5,5.6,8.2,10.6,12.8,15.6,17.0,18.0] .

Comment ça fonctionne:

t<-2*n+1                      -- assign t to the maximum number of elements of a
                              -- of sublist
     take t(inits x)          -- build the sublists from t elements of the inits
                ++tails x     -- of the input and the tails of the input,
                              -- e.g. x=[1,2,3,4], t=3:
                              -- [[],[1],[1,2]] ++ [[1,2,3,4],[2,3,4],[3,4],[4],[]]
  a<-take t<$>                -- take at most t elements from every sublist
                ,length a>n   -- keep those with a minimum length of n+1
sum a/sum(1<$a)               -- calculate average, "sum(1<$a)" is the length of a

Pyth, 22 octets

.OMsM.:++J*]YKE]MQJhyK

Explication:

.OM sM .: +               Means of flattens of sublists of length 2K+1 of
            + J *         
                  ] Y     J is E copies of [].
                  K E     Save E to a variable to use it later.
               ]MQ        the input
            J             Put J on both sides of ]MQ.
          h y K           2K+1

Essayez-le ici .

JavaScript (ES6), 104

Total en cours d'exécution / taille de l'échantillon en cours d'exécution. En Javascript, la lecture d'une valeur en dehors des limites d'un tableau donne undefined, qui peut être converti en 0 en utilisant ~~

(l,n,p=0)=>l.map((v,i)=>(p+=~l[i-n-1]-~l[i+n])/(n+1+Math.min(n,l.length-1-i,i)),l.map((v,i)=>p+=i<n&&v))

Non golfé

(l, n) => {
    p = 0;
    for (i = 0; i < n; i++) p += v;
    r = [];
    for (i = 0; i < l.length; i++) {
        p += (l[i + n] || 0) - (i > n ? l[i - n - 1] : 0);
        r.push(p / Math.min(n, l.length - i - 1, i);
    }
    return r;
}

Tester

f=(n,l,p=0)=>l.map((v,i)=>(p+=~l[i-n-1]-~l[i+n])/(n+1+Math.min(n,l.length-1-i,i)),l.map((v,i)=>p+=i<n&&v))

console.log=x=>O.textContent+=x+'\n';


;[
  [1,[12,6,3,9],[9,7,6,6]]
, [1,[1,4,5,7,10],[2.5,3.333,5.333,7.333,8.5]]
, [1,[1,3,3,7,4,2,4,2],[2,2.333,4.333,4.667,4.333,3.333,2.667,3]]
, [2,[1,3,5,9,10,14,15,16,23],[3,4.5,5.6,8.2,10.6,12.8,15.6,17,18]]
, [3,[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,1,1]]
, [3,[1,2,3,4,5,6,7,8],[2.5,3,3.5,4,5,5.5,6,6.5]]
].forEach(t=>{
  var n=t[0],l=t[1],x=t[2],r=f(n,l)
  // verify (limited to 3 decimals)
  var ok = r.every((v,i)=>v.toFixed(3)==x[i].toFixed(3))
  
  console.log((ok?'OK   ':'Fail ')+n+' '+l+' -> '+r+' ('+x+')')
})

<pre id=O></pre>

JavaScript (ES6), 82 octets

code:

F=(n,a)=>a.map((e,i)=>(s=a.slice(i<n?0:i-n,i+n+1))&&s.reduce((l,c)=>l+c)/s.length)

tester:

F=(n,a)=>a.map((e,i)=>(s=a.slice(i<n?0:i-n,i+n+1))&&s.reduce((l,c)=>l+c)/s.length)

document.write('<pre>' +
  [
    [1, [12, 6, 3, 9], [9, 7, 6, 6] ],
    [1, [1, 4, 5, 7, 10], [2.5, 3.333, 5.333, 7.333, 8.5] ],
    [1, [1, 3, 3, 7, 4, 2, 4, 2], [2, 2.333, 4.333, 4.667, 4.333, 3.333, 2.667, 3] ],
    [2, [1, 3, 5, 9, 10, 14, 15, 16, 23], [3, 4.5, 5.6, 8.2, 10.6, 12.8, 15.6, 17, 18] ],
    [3, [1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1] ],
    [3, [1, 2, 3, 4, 5, 6, 7, 8], [2.5, 3, 3.5, 4, 5, 5.5, 6, 6.5] ]
  ].map(t => {
    var [n, m, e] = t;
    var r = F(n, m);
    // verify to precision of 3 decimals
    var test = r.every((v, i) => v.toPrecision(3) === e[i].toPrecision(3));

    return 'F(' + n + ', [' + m + '])\t' + (test ? 'Pass' : 'Fail') +
      '\n\t{' + r + '} ' + (test ? '=' : '≠') + ' {' + e + '}';
  }).join('\n\n') +
  '</pre>');