Bei einer Eingabe einer ganzen Zahl n und einer Liste positiver ganzer Zahlen m ₁ , m ₂ , ... wird eine Liste ganzer Zahlen m ₁ ' , m ₂ ' , ... ausgegeben , wobei m _x ' als Durchschnitt von m definiert ist _xn bis m _{x + n} .

Ignorieren Sie bei der Berechnung dieser Durchschnittswerte Indizes, die außerhalb der Grenzen liegen (und passen Sie an, durch was Sie die Summe entsprechend dividieren). n ist immer ≥ 1, aber niemals die Hälfte der Länge von m (abgerundet) oder mehr. Dies bedeutet, dass die Mindestlänge von m 4 beträgt. Die Elemente in m sind positive ganze Zahlen, die Ausgabe muss jedoch auf mindestens 3 Dezimalstellen genau sein.

Die Eingabe- / Ausgabeelemente, die Listen sind, können entweder durch Leerzeichen / Kommas getrennte Zeichenfolgen oder Arrays / Listen / etc. Sein. Wenn Ihre Lösung eine Funktion ist, können Sie als Eingabe zusätzlich ein erstes Argument von n und zusätzliche Argumente als m _{x verwenden} (dies gilt auch für Befehlszeilenargumente).

Hier ist eine visuelle Darstellung von 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

Da es sich um Code-Golf , der kürzeste Code in Bytes gewinnt.

Testfälle ( diese wurden manuell durchgeführt; bitte benachrichtigen Sie mich über eventuelle Fehler ):

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 Bytes

m.O:vzeS,0-dQh+dQUvz

Testsuite

Ziemlich einfach, schneiden Sie einfach den entsprechenden Abschnitt aus der Liste, dann durchschnittlich.

MATL , 30 28 26 24 Bytes

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

Getestet mit Matlab und Octave. Verwendet die aktuelle Version (9.1.0) der Sprache / des Compilers.

Die Eingabe ist: zuerst die Nummer, die die Fensterlänge steuert, dann das Array mit dem Format [1 4 5 7 10].

EDIT (20. Mai 2016): Probieren Sie es online! Der Code im Link wurde X+durch ersetzt Y+, um der Version 18.0.0 der Sprache zu entsprechen.

Beispiel

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

Erläuterung

Der äquivalente Matlab-Code wäre

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');

Der MATL-Code nutzt die kürzlich hinzugefügten Funktionen der impliziten Eingabe und der Zwischenablage für die automatische Funktionseingabe:

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 Bytes

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

Eingabeformat ist n [m1 m2 ... mx].

Führen Sie alle Testfälle aus. (Konvertiert die Testsuite automatisch in das erforderliche Eingabeformat.)

Dies funktioniert, indem nLeerzeichen vor- und angehängt , dann alle Teilzeichenfolgen mit der Länge genommen 2n+1und die Leerzeichen wieder entfernt werden, bevor ihre Mittelwerte berechnet werden.

Julia, 57 Bytes

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

Dies ist eine Funktion, die zwei Ganzzahlen akzeptiert und ein Array von Gleitkommazahlen zurückgibt.

Der Ansatz ist hier sehr einfach. Wir konstruieren ein neues Array, indem wir den Mittelwert von Abschnitten des Eingabearrays nehmen und vorne und hinten abschneiden.

Haskell, 97 bis 95 Bytes

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]

Anwendungsbeispiel: 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].

Wie es funktioniert:

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 Bytes

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

Erläuterung:

.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

Probieren Sie es hier aus .

JavaScript (ES6), 104

Laufende Summe / laufende Stichprobengröße. Wenn Sie in JavaScript einen Wert außerhalb der Grenzen eines Arrays lesen, erhalten Sie undefined, das mit ~~ in 0 konvertiert werden kann

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

Ungolfed

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

Prüfung

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 Byte

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)

Prüfung:

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>');