N tamsayısının bir girdisi ve m ₁ , m ₂ , ... pozitif tamsayılarının bir listesi verildiğinde , m ₁ ' , m ₂ ' , ... tamsayılarının bir listesini çıkarır ; burada m _x ' m ortalaması olarak tanımlanır _xn ila m _{x + n} .

Bu ortalamaları hesaplarken, sınırların dışındaki endeksleri göz ardı edin (ve toplamı buna göre böldüğünüz şeyi ayarlayın). n her zaman ≥ 1 olur ancak asla m (yuvarlatılmış) veya daha fazla uzunluğun yarısı olmaz . Bu araçlar, minimum uzunlukta olduğu m 4'tür elements m pozitif tamsayı olmak, ancak çıkış olarak en az 3 ondalık basamağa kadar hassas olması gerekir.

Listeler olan giriş / çıkış öğeleri boşlukla / virgülle ayrılmış dizeler veya diziler / listeler / vb. Olabilir. Girdi için, çözümünüz bir işlevse, ek olarak n'nin ilk bağımsız değişkenini ve ek _x değişkenlerini m _{x olarak alabilirsiniz} (bu komut satırı bağımsız değişkenleri için de geçerlidir).

İşte görsel bir temsili 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

Bu kod golf olduğundan , bayt cinsinden en kısa kod kazanır.

Test senaryoları ( bunlar manuel olarak yapıldı; lütfen hataları bana bildir ):

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 bayt

m.O:vzeS,0-dQh+dQUvz

Test odası

Oldukça basit, sadece uygun bölümü listeden dilimleyin, sonra ortalama.

MATL , 30 28 26 24 bayt

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

Matlab ve Octave üzerinde test edildi. Dilin / derleyicinin geçerli sürümünü (9.1.0) kullanır .

Girdi: ilk önce pencere uzunluğunu kontrol eden sayı, sonra formatlı dizi [1 4 5 7 10].

EDIT (20 Mayıs 2016): Çevrimiçi deneyin! Bağlantıdaki kod , dilin 18.0.0 sürümüne uyacak şekilde X+değiştirildi Y+.

Misal

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

açıklama

Eşdeğer Matlab kodu

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

MATL kodu, örtülü giriş ve otomatik işlev-giriş panosunun yakın zamanda eklenen özelliklerini kullanır:

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 bayt

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

Girdi biçimi n [m1 m2 ... mx].

Tüm test senaryolarını çalıştırın. (Test paketini otomatik olarak gerekli giriş biçimine dönüştürür.)

Bu n, boşlukları önceden ekleme ve ekleme , ardından tüm uzunluk alt dizelerini alarak 2n+1ve araçlarını hesaplamadan önce boşlukları yeniden kaldırma yoluyla çalışır.

Julia, 57 bayt

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

Bu, iki tamsayıyı kabul eden ve bir kayan noktalı sayı döndüren bir işlevdir.

Buradaki yaklaşım çok açık. Giriş dizisinin bölümlerinin ortalamasını alarak, ön ve arkada kısaltarak yeni bir dizi oluştururuz.

Haskell, 97 95 bayt

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]

Kullanım örneği: 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].

Nasıl çalışır:

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 bayt

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

Açıklama:

.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

Burada deneyin .

JavaScript (ES6), 104

Çalışan toplam / çalışan örnek büyüklüğü. Javascript'te, bir dizinin sınırlarının dışındaki bir değeri okumak, ~~ kullanılarak 0'a dönüştürülebilen tanımsız verir.

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

Ölçek

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 bayt

kod:

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)

Ölçek:

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