_{Not: Bu, dizi manipülasyon zorluklarında bir numaradır. Önceki zorluk için burayı tıklayın .}

Listenin Ortalamasını Taşıma

Hareketli ortalama bir listenin orijinal küçük üst üste gelen sublists ortalama tarafından oluşturulan yeni, düzeltti listesi ile sonuçlanan bir hesaplamadır.

Hareketli bir ortalama oluştururken, öncelikle belirli bir 'pencere boyutu' kullanarak çakışan alt listelerin listesini oluştururuz ve bu pencereyi her seferinde bir kez sağa kaydırırız.

Örneğin, liste [8, 4, 6, 2, 2, 4]ve pencere boyutu göz önüne alındığında, alt listeler 3şöyle olur:

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

Daha sonra sonucu elde etmek için her alt listenin ortalama ortalamasını hesaplıyoruz : [6.0, 4.0, 3.3, 2.7](her değer bir ondalık basamağa yuvarlanır).

Meydan okuma

Görev, bir program ya da bir listesi verilen fonksiyon yazmak için L ve bir tamsayıyı 1 ≤ n ≤ uzunluğunun (L) için, hareketli ortalama hesaplamak L pencere boyutu kullanılarak , n .

Kurallar:

• Programınız tamsayı bölümü veya kayan bölüm kullanabilir. Şamandıra bölünmesi durumunda, değer doğru olduğu sürece veri türünün sınırlamaları nedeniyle küçük yanlışlıklara izin verilir.
• Tam bir program veya bir işlev gönderebilirsiniz (ancak snippet gönderemezsiniz).
• Listenin yalnızca pozitif tamsayılar içereceğini varsayabilirsiniz .
• Standart boşluklar yasaktır.
• Bu kod golf , bu yüzden en kısa cevap (bayt cinsinden) kazanır!

Test Durumları

Okunabilirliği kolaylaştırmak için tüm değerlerin bir ondalık basamağa yuvarlandığını unutmayın.

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]

Jöle , 3 bayt

ṡÆm

Çevrimiçi deneyin!

Sayesinde oldukça basit ṡ

Nasıl çalışır

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

Wolfram Dili (Mathematica) , 13 bayt

^{Mathematica'da her şey için yerleşik}

MovingAverage

Çevrimiçi deneyin!

Bir liste ve sonra bir yarıçap alır ...

Haskell , 47 bayt

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

Çevrimiçi deneyin!

Xnor sayesinde iki bayt kaydedildi!

Dyalog APL, 4 bayt

@Graham sayesinde 1 bayt kaydedildi

@ Jimmy23013 sayesinde 2 bayt kaydedildi

APL'nin bir golf dili olmadığını belirttim mi?

⊢+/÷

ile nsağda veya

+/÷⊣

ile L sağda.

Çevrimiçi deneyin!

Nasıl?

÷ - böl L tarafındann

⊢+/- +pencerelerinde azaltmakn

Python , 48 bayt

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

Çevrimiçi deneyin!

Özyinelemeli işlev. Programdan daha kısa (50 bayt)

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

Çevrimiçi deneyin!

Bu, whilekoşulda hata ile sonlanarak 2 bayt tasarrufu sağlar .

Enlist , 3 bayt

ṡÆm

Çevrimiçi deneyin!

Perl 6 , 33 bayt

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

Dene

Expanded:

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

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

Çevrimiçi deneyin!

unrolled:

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 bayt

]+/\%

Çevrimiçi deneyin!

Alır nsağ argüman ve solda olarak liste olarak. Sadece infixteki toplamı yapma fikri için Uriel'in çözümüne teşekkür ederiz.

açıklama

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

Önceki çözüm (7 bayt)

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

Ohm v2 , 3 bayt

ÇÆm

Çevrimiçi deneyin!

Açıklama:

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

.O.:F

Burada deneyin!

Bu nasıl çalışır?

.O.: F - Tam program.

    F - Girişi (iç içe liste) ile ...
  .: - ... Alt listeler.
.O - Her birinin ortalaması.

Oktav , 33 31 bayt

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

Çevrimiçi deneyin!

açıklama

Convolution ( conv) aslında hareketli bir ağırlıklı toplamdır. Ağırlıklar [1/n, ..., 1/n](olarak elde edilir ~~(1:n)/n) olarak seçilirse , sonuç sadece bir 'valid'kısmının tutulduğu hareketli bir ortalamadır .

R , 72 bayt

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

Çevrimiçi deneyin!

meanTüm boyut npencerelerini hesaplar ; pencere kenarı geçtiğinde l, sonuçlar NAböylece filtrelenir.

R + hayvanat bahçesi paketi, 13 bayt

zoo::rollmean

zooPaketi (Düzenli ve Düzensiz Zaman Serisi için S3 altyapı) kullanışlı bir çok fonksiyonu vardır. Sen olabilir burada deneyin (R-keman) .

Japt v2.0a0, 7 bayt

ãV ®x÷V

Dene

açıklama

Örtülü dizi Uve tamsayı girişi V.

ãV

Uzunluğa Usahip alt bölümleri alınV

®

Alt bölümleri eşleyin.

÷V

Her öğeyi böl V.

x

Tüm öğeleri topla.

Python 3 , 61 bayt

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

Çevrimiçi deneyin!

Python 3 , 55 bayt

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

Çevrimiçi deneyin!

05AB1E , 5 bayt

ŒsùÅA

Açıklama:

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

Çevrimiçi deneyin!

Mathematica, 21 bayt

Mean/@##~Partition~1&

Çevrimiçi deneyin!

-3 bayt JungHwan Min

Proton , 46 bayt

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

Çevrimiçi deneyin!

Bunun, körleme fonksiyonları sözdizimi yoluyla girdi aldığını ve kesirlerin bir listesini döndürdüğünü unutmayın.

CJam, 14 12 bayt

^{@Aditsu sayesinde -2 bayt}

{_@ew::+\f/}

Jq 1,5 , 61 bayt

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

Expanded

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

Çevrimiçi deneyin!

JavaScript (ES6), 53 bayt

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

PHP, 94 bayt

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

Çevrimiçi deneyin!

Clojure , 48 bayt

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

Çevrimiçi deneyin!

Yığılmış , 22 bayt

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

Çevrimiçi deneyin!

açıklama

infixesverilen uzunluktaki tüm pencereleri oluşturur. Ardından, her bir ek üzerinde kendi ortalama fonksiyonumuzu eşleriz.

Ortak Lisp , 77 bayt

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

Çevrimiçi deneyin!

K (oK) , 13 11 bayt

Çözüm:

{+/+x':y%x}

Çevrimiçi deneyin!

Örnekler:

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

Açıklama:

oK bir sürgülü pencere oluşturmak için yerleşiktir, daha sonra elde edilen dizileri toplar ve ortalama elde etmek için sürgülü pencere boyutuna böler:

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

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)

Korkak , 67 66 bayt

Köri sözdizimi ile bir bayt kaydedildi.

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

Çevrimiçi deneyin!

Java 8, 111 bayt

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

Açıklama:

Burada deneyin.

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