Cho đầu vào của một số nguyên n và một danh sách các số nguyên dương m ₁ , m ₂ , ..., xuất ra một danh sách các số nguyên m ₁ ' , m ₂ ' , ... trong đó m _x ' được định nghĩa là trung bình của m _xn qua m _{x + n} .

Khi tính các giá trị trung bình này, hãy bỏ qua các chỉ số nằm ngoài giới hạn (và điều chỉnh những gì bạn đang chia tổng cho phù hợp). n sẽ luôn là ≥ 1 nhưng không bao giờ bằng một nửa chiều dài của m (làm tròn xuống) hoặc nhiều hơn. Điều này có nghĩa là độ dài tối thiểu của m là 4. Các phần tử trong m sẽ là số nguyên dương, nhưng đầu ra phải chính xác đến ít nhất 3 chữ số thập phân.

Các phần tử đầu vào / đầu ra là các danh sách có thể là các chuỗi được phân tách bằng khoảng trắng / / dấu phẩy hoặc mảng / danh sách / vv. Đối với đầu vào, nếu giải pháp của bạn là một hàm, bạn cũng có thể lấy một đối số đầu tiên là n và các đối số bổ sung là m _x (điều này cũng áp dụng cho các đối số dòng lệnh).

Đây là một đại diện trực quan của 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

Vì đây là mã golf , mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm ( chúng được thực hiện thủ công; vui lòng thông báo cho tôi về bất kỳ lỗi nào ):

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

Bình thường, 20 byte

m.O:vzeS,0-dQh+dQUvz

Bộ kiểm tra

Khá đơn giản, chỉ cần cắt phần thích hợp ra khỏi danh sách, sau đó là trung bình.

MATL , 30 28 26 24 byte

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

Đã thử nghiệm trên Matlab và trên Octave. Sử dụng phiên bản hiện tại (9.1.0) của ngôn ngữ / trình biên dịch.

Đầu vào là: đầu tiên là số lượng chiều dài cửa sổ kiểm soát, sau đó là mảng với định dạng [1 4 5 7 10].

EDIT (20 tháng 5 năm 2016): Hãy thử trực tuyến! Mã trong liên kết đã được X+thay thế bằng Y+để phù hợp với phiên bản 18.0.0 của ngôn ngữ.

Thí dụ

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

Giải trình

Mã Matlab tương đương sẽ là

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

Mã MATL sử dụng các tính năng được thêm gần đây của đầu vào ẩn và bảng tạm nhập chức năng tự động:

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 byte

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

Định dạng đầu vào là n [m1 m2 ... mx].

Chạy tất cả các trường hợp thử nghiệm. (Tự động chuyển đổi bộ kiểm tra sang định dạng đầu vào cần thiết.)

Điều này hoạt động bằng cách thêm trước và nối các nkhoảng trắng, sau đó lấy tất cả các chuỗi con có chiều dài 2n+1và xóa lại khoảng trắng trước khi tính toán phương tiện của chúng.

Julia, 57 byte

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

Đây là một hàm chấp nhận hai số nguyên và trả về một mảng số float.

Cách tiếp cận ở đây rất đơn giản. Chúng tôi xây dựng một mảng mới bằng cách lấy giá trị trung bình của các phần của mảng đầu vào, cắt ngắn ở phía trước và phía sau.

Haskell, 97 95 byte

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]

Ví dụ sử dụng: 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].

Làm thế nào nó hoạt động:

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

Bình thường, 22 byte

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

Giải trình:

.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

Hãy thử nó ở đây .

JavaScript (ES6), 104

Chạy tổng số / chạy cỡ mẫu. Trong Javascript, việc đọc một giá trị nằm ngoài giới hạn của một mảng sẽ không xác định, có thể được chuyển đổi thành 0 bằng cách sử dụng ~ ~

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

Ung dung

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

Kiểm tra

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

mã:

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)

kiểm tra:

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