Tôi đã cuộn quanh trang web này một thời gian, nhưng gần đây mới thực sự quan tâm đến việc thực sự thử một số thử thách. Tôi đã có ý định thử sức mình với một số chủ đề golf-code hiện có, nhưng tôi đã không truy cập Internet trong một ngày hôm qua, và trong lúc đó, tôi đã nghĩ ra thử thách của riêng mình.

Nhiệm vụ của bạn là tạo ra một chương trình hoặc hàm lấy một mảng Floats avà một số nguyên n, sau đó đặt từng giá trị vào amức trung bình của hai bên cạnh nó, nlần. Khi được sử dụng nhiều lần với giá trị tăng dần n, điều này tạo ra một chuyển động giống như sóng:

Cụ thể:

• Nếu chỉ có một mục trong ahoặc nếu n0 hoặc ít hơn, chương trình sẽ trả về mảng ban đầu.
• Đầu vào và đầu ra có thể ở bất kỳ định dạng nào bạn muốn, miễn là chúng được phân tách rõ ràng.

Đối với mỗi bước:

• Mục đầu tiên trong a sẽ trở thành mức trung bình của chính nó và mục tiếp theo.
• Mục cuối cùng asẽ trở thành mức trung bình của chính nó và mục trước đó.
• Bất kỳ mục nào khác asẽ trở thành mức trung bình của mục trước và mục tiếp theo.
• Hãy chắc chắn rằng bạn đang tính toán mảng của bước trước chứ không phải mảng hiện tại!

Các trường hợp kiểm tra: LƯU Ý: Đầu vào / đầu ra của bạn không phải ở định dạng này!

[0, 0, 1, 0, 0], 1          -> [0, 0.5, 0, 0.5, 0]
[0, 0, 1, 0, 0], 2          -> [0.25, 0, 0.5, 0, 0.25]
[0, 0, 1, 0, 0], 0          -> [0, 0, 1, 0, 0]
[0, 0, 1, 0, 0], -39        -> [0, 0, 1, 0, 0]
[0, 16, 32, 16, 0], 1       -> [8, 16, 16, 16, 8]
[0, 1, 2, 3, 4, 5], 1       -> [0.5, 1, 2, 3, 4, 4.5]
[0, 64], 1                  -> [32, 32]
[0], 482                    -> [0]
[32, 32, 32, 16, 64, 16, 32, 32, 32], 4 -> [33, 27, 40, 22, 44, 22, 40, 27, 33]

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng. Người chiến thắng sẽ được chọn trong một tuần (vào ngày 1 tháng 8). Chúc may mắn!

Chỉnh sửa: Chúc mừng người chiến thắng, @issacg , với con số khổng lồ 18 byte!

Bình thường, 46 18 byte

ucR2sV+hGGt+GeG.*Q

Mã này mong đợi đầu vào trong biểu mẫu iterations, [wave1, wave2, wave3 ...], như được thấy ở liên kết đầu tiên bên dưới.

Trình diễn. Khai thác thử nghiệm.

Chương trình hoạt động bằng cách áp dụng mã trong hàm less ( u) vào danh sách đầu vào, gấp nhiều lần số lần lặp.

Tôi sẽ chứng minh chức năng truyền sóng trong danh sách [0, 1, 2, 3, 4, 5] , nằm trong G:

+hGGchuẩn bị Gyếu tố đầu tiên để Ghình thành[0, 0, 1, 2, 3, 4, 5] .

t+GeGnối Gphần tử cuối cùng vào Gvà loại bỏ phần tử đầu tiên của nó, tạo thành[1, 2, 3, 4, 5, 5] .

sVđầu tiên hình thành các cặp từ danh sách, đưa ra [[0, 1], [0, 2], [1, 3], [2, 4], [3, 5], [4, 5]]với yếu tố cuối cùng của danh sách đầu tiên bị cắt ngắn. Sau đó, các cặp được tóm tắt thông qua schức năng, đưa ra[1, 2, 4, 6, 8, 9] .

cR2sử dụng phép chia dấu phẩy động để chia tất cả các số cho 2, cho kết quả mong muốn , [0.5, 1.0, 2.0, 3.0, 4.0, 4.5].

Người tuyết 1.0.0 , 219 ký tự

{vg" "aS:10sB;aM0aa,AAg**-:|al|'NdE'0nRal@(%}{->:1*?{0AaG;:?{;bI:dUNiNwR'NdEwRaC;aM(~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;:0wRdUaCwR*?{#aC;#bI:*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM|*0*;bR|tSsP

Với ngắt dòng cho "khả năng đọc":

{vg" "aS:10sB;aM0aa,AAg**-:|al|'NdE'0nRal@(%}{->:1*?{0AaG;:?{;bI:dUNiNwR'NdEwRaC;
aM(~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;:0wRdUaCwR*?{#aC;#
bI:*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM|*0*;bR|tSsP

Phiên bản chưa được chỉnh sửa / chưa hoàn thành:

{vg" "aS:10sB;aM  // input space-separated list of numbers
0aa,AAg           // get first element and array of all-but-first elements
**                // discard original input and the 0

// execute the following (input[0]) times
-:
    |al|'NdE'0nR               // get range from (0..input.length-1]
    al@(%}{->:1*?{0AaG;:?{;bI  // chop off first element if any
    :dUNiNwR'NdEwRaC;aM        // map n -> [n-1 n+1]
    // if the input consisted of a single element, append [0 0]
    // otherwise prepend [0 1] and append [len-2 len-1]
    (~:?{(()1wR]0wRaC*))#'wRaC|*#|(()#aLNdEdUNdEwR]wR]aCwR*))#aC;
        :0wRdUaCwR*?{#aC;#bI
    // map indeces to avg(input[i1], input[i2])
    :*#0aA'|aa|'!*+'(()#1aA*))#|,aa|'*`nA2nD;aM
    // replace old input, reset permavar
    |*0*
;bR

|tSsP  // output result

Định dạng I / O mẫu:

llama@llama:...Code/snowman/ppcg53799waves$ snowman waves.snowman 
4 32 32 32 16 64 16 32 32 32
[33 27 40 22 44 22 40 27 33]

Pyth - 25 24 byte

Sử dụng liệt kê, giảm để làm lặp đi lặp lại.

u.ecs@L++hGGeG,khhk2GvzQ

Hãy thử trực tuyến tại đây .

Vợt 164 145 byte

(define(f a n)(if(< n 1)a(f(let([l(length a)][r list-ref])(for/list([i(in-range l)])(/(+(r a(max(- i 1)0))(r a(min(+ i 1)(- l 1))))2)))(- n 1))))

Bị đánh cắp

(define (f a n)
  (if (< n 1)
      a
      (f (let ([l (length a)] [r list-ref])
           (for/list ([i (in-range l)])
             (/ (+ (r a (max (- i 1) 0))
                   (r a (min (+ i 1) (- l 1))))
                2))) (- n 1))))

Lưu ý, bạn có thể cần #lang racketdòng để chạy này.

R, 109 byte

function(x,n){l=length(x);t=if(l>2)c(.5,0,.5)else if(l==2)c(.5,.5)else 1;for(i in 1:n)x=filter(x,t,c=T);c(x)}

Điều này tạo ra một hàm không tên chấp nhận một vectơ và một số nguyên và trả về một vectơ. Cách tiếp cận ở đây là coi đầu vào là một chuỗi thời gian đơn biến và áp dụng bộ lọc tích chập tuyến tính.

Ungolfed + giải thích:

f <- function(x, n) {
    # Define filter coefficients
    t <- if (length(x) > 2)
        c(0.5, 0, 0.5)
    else if (length(x) == 2)
        c(0.5, 0.5)
    else
        1

    # Apply the filter n times
    for (i in 1:n) {
        # The circular option wraps the filter around the edges
        # of the series, otherwise the ends would be set to NA.
        x <- filter(x, t, circular = TRUE)
    }

    # Returned the modified input, stripped of the extraneous
    # properties that the filter function adds.
    c(x)
}

Ví dụ:

> f(c(32, 32, 32, 16, 64, 16, 32, 32, 32), 4)
[1] 33 27 40 22 44 22 40 27 33

> f(0, 482)
[1] 0

> f(c(0, 64), 1)
[1] 32 32

Haskell, 76 ký tự

Bí quyết là thêm số đầu tiên vào đầu danh sách và số cuối vào cuối danh sách thay vì xử lý các điều kiện biên.

f a@(x:s)=(/2)<$>zipWith(+)(x:a)(s++[last s])
f x=x
a#n|n<1=a|n>0=f a#(n-1)

Các xét nghiệm:

λ: [0, 0, 1, 0, 0]#1  
[0.0,0.5,0.0,0.5,0.0]
λ: [0, 0, 1, 0, 0]#2
[0.25,0.0,0.5,0.0,0.25]
λ: [0, 0, 1, 0, 0]#0  
[0.0,0.0,1.0,0.0,0.0]
λ: [0, 0, 1, 0, 0]#(-39) 
[0.0,0.0,1.0,0.0,0.0]
λ: [0, 16, 32, 16, 0]#1
[8.0,16.0,16.0,16.0,8.0]
λ: [0, 1, 2, 3, 4, 5]#1
[0.5,1.0,2.0,3.0,4.0,4.5]
λ: [0, 64]#1
[32.0,32.0]
λ: [0]#482
[0.0]
λ: [32, 32, 32, 16, 64, 16, 32, 32, 32]#4
[33.0,27.0,40.0,22.0,44.0,22.0,40.0,27.0,33.0]

CJam, 23 22 byte

q~{_(@)@@+@@+.+.5f*}*`

Dùng thử trực tuyến

Đầu vào ở định dạng danh sách CJam, ví dụ cho ví dụ cuối cùng:

[32 32 32 16 64 16 32 32 32] 4

Đầu ra cũng là một danh sách CJam:

[33.0 27.0 40.0 22.0 44.0 22.0 40.0 27.0 33.0]

Cách tiếp cận cơ bản là trong mỗi bước, vectơ được dịch chuyển một vị trí sang trái và một vị trí sang phải. Mỗi trong hai vectơ được đệm với phần tử đầu tiên / cuối cùng, và sau đó tính trung bình của hai vectơ.

Giải trình:

q~    Get and interpret input.
{     Loop over repeat count.
  _     Copy list.
  (     Pop off left element.
  @     Get original list to top.
  )     Pop off right element.
  @@    Get first element and list with last element removed to top.
  +     Concatenate. This gives right-shifted list with first element repeated.
  @@    Get list with first element removed and last element to top.
  +     Concatenate. This gives left-shifted list with last element repeated.
  .+    Perform vector addition of two shifted lists.
  .5f*  Multiply sum by 0.5 to give average.
}*    End loop over repeat count.
`     Convert result array to string.

Java, 181 byte

Đây là phiên bản chơi gôn:

float[]g(float[]i,int n){float[]c=i.clone();int l=c.length,s=1;if(n>0&&l>1){c[0]=(i[0]+i[1])/2f;c[--l]=(i[l]+i[l-1])/2f;while(s<l)c[s]=(i[s-1]+i[++s])/2f;return g(c,n-1);}return i;}

Ung dung:

float[] g(float[] i, int n) {
    float[] c = i.clone();
    int l = c.length,s=1;
    if(n>0&&l>1) {
        c[0] = (i[0]+i[1])/2f;
        c[--l] = (i[l]+i[l-1])/2f;
        while(s<l)
            c[s] = (i[s-1] + i[++s]) / 2f;
        return g(c, n-1);
    }
    return i;
}

Tôi đã cố gắng rút ngắn các bài tập và điều kiện càng nhiều càng tốt với Java. Cải tiến được chào đón, tất nhiên.

JavaScript (ES6), 153 132 67 ký tự

Tôi trở lại câu trả lời đầu tiên của tôi 6 tháng sau và tôi phải làm gì? Chơi golf giảm 50%, đó là những gì. ;)

s=(a,n)=>n<1?a:s(a.map((j,i)=>(a[i&&i-1]+a[a[i+1]+1?i+1:i])/2),n-1)

Phiên bản này tự gọi liên tục cho đến khi nít hơn 1, giảm n1 lần mỗi lần.

Một giải pháp không đệ quy ( 151 130 78 ký tự):

(a,n)=>n<1?a:eval("while(n--)a=a.map((j,i)=>(a[i&&i-1]+a[a[i+1]+1?i+1:i])/2)")

Ungolfed: (lỗi thời)

Đệ quy:

s = function (a, n) {
  if (n < 1)
    return a;
  b = [];
  l = a.length;
  x = y = 0;
  for(var i = 0; i < l; i++) {
    x = a[(i < 1) ? 0 : i-1];
    y = a[(i > l-2) ? i : i+1];
    b[i] = (x + y)/2;
  }
  if (n > 2)
    return b;
  return s(b,n-1);
}

Không đệ quy:

s = function (a, n) {
  if (n < 1)
    return a;
  b = [];
  l = a.length;
  x = y = 0;
  while(n-- > 0) {
    for(var i = 0; i < l; i++) {
      x = a[(i < 1) ? 0 : i-1];
      y = a[(i > l-2) ? i : i+1];
      b[i] = (x + y)/2;
      a = b.slice(0);   // setting a to a copy of b, for copyright reasons
    }
  return b;
}

Java, 203 byte

Thử đặt đầu tiên của tôi với Java. Lời khuyên cải tiến được chào đón :)

double[]f(double[]a,int n){int j,s,i=0;s=a.length-1;if(n<1||s<1)return a;double b[]=a;for(;i++<n;a=b.clone()){b[0]=.5*(a[0]+a[1]);b[s]=.5*(a[s]+a[s-1]);for(j=1;j<s;++j)b[j]=.5*(a[j-1]+a[j+1]);}return b;}

In đẹp:

double[] g(double[] a, int n) {
  int j, s, i = 0;
  s = a.length - 1;
  if (n < 1 || s < 1)
     return a;
  double b[] = a;
  for (; i++ < n; a = b.clone()) {
     b[0] = .5 * (a[0] + a[1]);
     b[s] = .5 * (a[s] + a[s - 1]);
     for (j = 1; j < s; ++j)
        b[j] = .5 * (a[j - 1] + a[j + 1]);
  }
  return b;
}

Python 2, 98 byte

Thực hiện phương pháp đơn giản, được sử dụng execđể thoát khỏi việc sử dụng vòng lặp while. Tôi nghĩ rằng có một cách tốt hơn để làm logic để tìm ra các vị trí trường hợp đặc biệt, nhưng điều này làm việc ngay bây giờ. Đầu vào phải được định dạng như thế nào [list], times.

b,c=input()
k=~-len(b)
exec'b=[(b[x-(0<x<k)]+b[x+(x<k)-(x==k)])/2.for x in range(-~k)];'*c
print b

Ung dung:

BASE,TIME = input()
TEMP = [0]*len(BASE)                               # Temporary array as to not modify base.
while TIME:
    for x in xrange(len(BASE)):
        if x == 0:                                
            TEMP[x] = (BASE[x]   + BASE[x+1])/2.0  # First element special case.
        elif x == len(BASE)-1:                    
            TEMP[x] = (BASE[x]   + BASE[x-1])/2.0  # Last element special case.
        else:                                     
            TEMP[x] = (BASE[x-1] + BASE[x+1])/2.0  # Every other element.
    BASE = TEMP                                    # Set base to temporary array.
    TEMP = [0]*len(BASE)                           # Reset temporary array to 0s.
    TIME = TIME - 1
print BASE

Toán học, 81 byte

Tôi có cảm giác nó có thể được đánh gôn nhiều hơn nếu tôi có thể tìm ra cách tốt hơn để xử lý tình trạng tích cực.

f[l_,_]:=l;f[l_,n_/;n>0]:=Nest[.5{1,0,1}~ListConvolve~ArrayPad[#,1,"Fixed"]&,l,n]

Đáng chú ý: Mathematica cung cấp rất nhiều giải pháp tích hợp tiềm năng trong phạm vi các chức năng xử lý danh sách và bộ lọc, cũng như CellularAutomaton. Tôi đã chọn Nest[... ListConvolve ...]bởi vì đó là cách dễ nhất để xử lý các nút thắt ở cuối danh sách, nhưng các góc khác có thể chứng minh ngắn hơn.

Matlab, 109

function a=f(a,n)
if numel(a)>1&n>0
for k=1:n
a=[a(1)+a(2) conv(a,[1 0 1],'valid') a(end-1)+a(end)]/2;end
end

Ví dụ:

>> f([0, 0, 1, 0, 0], 1)
ans =
         0    0.5000         0    0.5000         0

>> f([0, 0, 1, 0, 0], 2)
ans =
    0.2500         0    0.5000         0    0.2500

>> f([0, 0, 1, 0, 0], 0)
ans =
     0     0     1     0     0

>> f([0, 0, 1, 0, 0], -39)
ans =
     0     0     1     0     0

>> f([0], 482)
ans =
     0

>> f([], 10)
ans =
     []

Scala, 195 ký tự (186 với đầu ra lười biếng, tức là Stream) 187 ký tự

(t:Seq[Float],n:Int)⇒t.size match{case 0|1⇒t;case 2⇒{val a=t.sum/2;Seq(a,a)};case i⇒(t/:(1 to n)){(s,_)⇒(s.take(2).sum/2)+:s.sliding(3).map(l=>(l(0)+l(2))/2).toList:+(s.drop(i-2).sum/2)}}

có lẽ không tối ưu, ánh xạ sliding(3) là rất hữu ích trong trường hợp này.

kiểm tra:

scala> (t:Seq[Float],n:Int)⇒t.size match{case 0|1⇒t;case 2⇒{val a=t.sum/2;Seq(a,a)};case i⇒(t/:(1 to n)){(s,_)⇒(s.take(2).sum/2)+:s.sliding(3).map(l=>(l(0)+l(2))/2).toList:+(s.drop(i-2).sum/2)}}
res0: (Seq[Float], Int) => List[Float] = <function2>

scala> res0(Seq(0, 0, 1, 0, 0), 1)
res1: Seq[Float] = List(0.0, 0.5, 0.0, 0.5, 0.0)

scala> res0(Seq(0, 0, 1, 0, 0), 2)
res2: Seq[Float] = List(0.25, 0.0, 0.5, 0.0, 0.25)

scala> res0(Seq(0, 0, 1, 0, 0), 0)
res3: Seq[Float] = List(0.0, 0.0, 1.0, 0.0, 0.0)

scala> res0(Seq(0, 0, 1, 0, 0), -39)
res4: Seq[Float] = List(0.0, 0.0, 1.0, 0.0, 0.0)

scala> res0(Seq(0, 16, 32, 16, 0), 1)
res5: Seq[Float] = List(8.0, 16.0, 16.0, 16.0, 8.0)

scala> res0(Seq(1, 2, 3, 4, 5), 1)
res6: Seq[Float] = List(1.5, 2.0, 3.0, 4.0, 4.5)

scala> res0(Seq(0,64), 1)
res7: Seq[Float] = List(32.0, 32.0)

scala> res0(Seq(0), 482)
res8: Seq[Float] = List(0.0)

scala> res0(Seq(32, 32, 32, 16, 64, 16, 32, 32, 32), 4)
res9: Seq[Float] = List(33.0, 27.0, 40.0, 22.0, 44.0, 22.0, 40.0, 27.0, 33.0)

q (27 ký tự)

{avg x^/:1 -1 xprev\:x}/[;]

Ví dụ

q)f:{avg x^/:1 -1 xprev\:x}/[;]
q)f[4;32 32 32 16 64 16 32 32 32]
33 27 40 22 44 22 40 27 33f
//1-length input
q)f[10;enlist 1] 
,1f
//0-length input
q)f[10;`float$()]
`float$()

R, 93 byte

Là một chức năng không tên

function(a,n){l=length(a);while((n=n-1)>=0)a<-colMeans(rbind(c(a[-1],a[l]),c(a[1],a[-l])));a}

Mở rộng

function(a,n){
    l=length(a);             # get the length of the vector
    while((n=n-1)>=0)        # repeat n times
        a<-colMeans(         # do the column means and assign to a
          rbind(             # create an array
            c(a[-1],a[l]),   # shift the vector left and duplicate last
            c(a[1],a[-l])    # shift the vector right and duplicate first
          )
        );
    a                        # return the vector
}

Xét nghiệm

> f=function(a,n){l=length(a);while((n=n-1)>=0)a<-colMeans(rbind(c(a[-1],a[l]),c(a[1],a[-l])));a}
> f(c(0, 0, 1, 0, 0), 1)
[1] 0.0 0.5 0.0 0.5 0.0
> f(c(0, 0, 1, 0, 0), 2)         
[1] 0.25 0.00 0.50 0.00 0.25
> f(c(0, 0, 1, 0, 0), 0)         
[1] 0 0 1 0 0
> f(c(0, 0, 1, 0, 0), -39)        
[1] 0 0 1 0 0
> f(c(0, 16, 32, 16, 0), 1)       
[1]  8 16 16 16  8
> f(c(0, 1, 2, 3, 4, 5), 1)      
[1] 0.5 1.0 2.0 3.0 4.0 4.5
> f(c(0, 64), 1)                  
[1] 32 32
> f(c(0), 482)                    
[1] 0
> f(c(32, 32, 32, 16, 64, 16, 32, 32, 32),4)
[1] 33 27 40 22 44 22 40 27 33
> 

Japt, 39 37 byte (không cạnh tranh)

Câu trả lời này không cạnh tranh vì ngôn ngữ mới hơn thách thức. Tôi chỉ muốn xem ngôn ngữ chơi gôn của tôi có thể theo kịp thử thách đầu tiên của tôi như thế nào.

Vm0 o r_£ZgY©Y-1 +ZgY>Zl -2?Y:°Y)/2}U

Hãy thử trực tuyến!

Vm0 o r_£ZgY©Y-1 +ZgY>Zl -2?Y:°Y)/2}U
Vm0 o      // Generate the range of integers [0, max(V,0)).
r_     }U  // Reduce it with this function, with a starting value of U:
£          //  Return the argument, with each item X, index Y, and the full array Z mapped by this function:
ZgY©Y-1 +  //   Return (Z[max(Y-1,0)] plus
ZgY>Zl -2? //    Z[Y > Z.length-2?
Y:°Y)      //      Y:--Y],)
/2         //   divided by two.
           // Implicit: output last expression

C ++ 14, 158 byte

#define D(a,b)d[i]=(c[a]+c[b])/2;
auto f(auto c,int n){while(n-->0&&c.size()>1){auto d{c};int i{};D(0,1)while(++i<c.size()-1)D(i-1,i+1)D(i,i-1)c=d;}return c;}

Yêu cầu đầu vào là một container value_type==double, như thế nào vector<double>.

Ung dung:

#define D(a,b) d[i] = (c[a]+c[b])/2;   //average
auto f(auto c, int n) {
  while(n-- > 0 && c.size() > 1) {     //breaks
    auto d{c};                         //copy container
    int i{};
    D(0,1)                             //left
    while(++i < c.size()-1)            //count up to right
      D(i-1,i+1)                       //interior
    D(i,i-1)                           //right
    c=d;                               //overwrite container
  }
  return c;
}

Vợt 223 byte

(let p((l l)(m 0)(g list-ref))(cond[(> n m)(let*((j(length l))(k(for/list((i j))(cond[(= i 0)(/(+(g l 0)(g l 1))2)]
[(= i(- j 1))(/(+(g l(- j 2))(g l(- j 1)))2)][else(/(+(g l(+ i 1))(g l(- i 1)))2)]))))(p k(+ 1 m) g))][l]))

Ung dung:

(define(f l n)
  (let loop ((l l)
             (m 0)
             (lr list-ref))
    (cond
      [(> n m)
       (let* ((j (length l))
              (k (for/list ((i j))
                   (cond
                     [(= i 0)       (/ (+ (lr l 0)
                                          (lr l 1))
                                       2)]
                     [(= i (- j 1)) (/ (+ (lr l (- j 2))
                                          (lr l (- j 1)))
                                        2)]
                     [else          (/ (+ (lr l (+ i 1))
                                          (lr l (- i 1)))
                                       2)])
                   )))
         (loop k
               (+ 1 m)
               lr))]
      [else l]
      )))

Kiểm tra:

(f '[32 32 32 16 64 16 32 32 32] 4)

Đầu ra:

'(33 27 40 22 44 22 40 27 33)

Thạch , 14 byte

.ịṚjṡ3 .ịⱮÆmµ¡

Hãy thử trực tuyến!

Chương trình đầy đủ.

C # (Trình biên dịch tương tác Visual C #) , 160 144 byte

float[]a(float[]b,int c)=>c>0&b.Length>1?a(b.Select((_,w)=>w<1?(b[w]+b[w+1])/2:w>b.Length-2?(b[w]+b[w-1])/2:(b[w-1]+b[w+1])/2).ToArray(),c-1):b;

Sử dụng đệ quy ol 'tốt.

Hãy thử trực tuyến!