나는이 사이트를 잠시 스크롤하고 있었지만 최근에 실제로 몇 가지 도전 과제를 시도하는 데 실제로 관심이있었습니다. 기존 코드 골프 주제 중 일부를 시도하고 싶었지만 어제 한동안 인터넷에 액세스 할 수 없었으며 그 동안 내 자신의 도전을 생각했습니다.

당신의 작업은 Floats a와 integer 의 배열을 취하는 프로그램이나 함수를 n만든 다음 각 값 a을 그 옆의 두 n시간 의 평균으로 설정합니다 . 의 값을 증가시키면서 반복적으로 사용 n하면 물결 모양의 모션이 생성됩니다.

사양 :

• 에 항목이 하나만 a있거나 n0 이하인 경우 프로그램은 원래 배열을 반환해야합니다.
• 입력과 출력은 눈에 띄게 분리되어있는 한 원하는 형식이 될 수 있습니다.

각 단계마다 :

• 첫 번째 항목 a은 자체의 평균이되고 다음 항목이되어야합니다.
• 마지막 항목 a은 자체와 이전 항목의 평균이되어야합니다.
• 다른 항목 a은 이전 항목과 다음 항목의 평균이되어야합니다.
• 현재 단계가 아닌 이전 단계의 배열을 계산하고 있는지 확인하십시오!

테스트 사례 : 참고 : 입력 / 출력이이 형식 일 필요는 없습니다!

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

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다. 우승자는 1 주일 (8 월 1 일)에 선정됩니다. 행운을 빕니다!

편집 : 무려 18 바이트로 우승자 @issacg를 축하 합니다!

Pyth, 46 18 바이트

ucR2sV+hGGt+GeG.*Q

이 코드는 iterations, [wave1, wave2, wave3 ...]아래 첫 번째 링크에서 볼 수 있듯이 형식의 입력을 예상 합니다.

데모. 테스트 하네스.

프로그램은 reduce ( u) 함수 내의 코드 를 반복 횟수만큼 입력 목록 에 적용하여 작동합니다 .

나는 목록에 전파 기능을 시연 할 예정 [0, 1, 2, 3, 4, 5]에있다 G:

+hGG앞에 G첫 번째 요소를 추가 하여 G형성 [0, 0, 1, 2, 3, 4, 5]합니다.

t+GeGG의 마지막 요소를 추가 G하고 첫 번째 요소를 제거하여를 형성 [1, 2, 3, 4, 5, 5]합니다.

sV첫 번째 목록 [[0, 1], [0, 2], [1, 3], [2, 4], [3, 5], [4, 5]]의 마지막 요소는 잘려나 가면서 목록에서 첫 번째 쌍을 형성 합니다. 그런 다음 쌍을 s함수 를 통해 합산하여을 제공 [1, 2, 4, 6, 8, 9]합니다.

cR2부동 소수점 나누기를 사용하여 모든 숫자를 2로 나누고 원하는 결과를 얻습니다 [0.5, 1.0, 2.0, 3.0, 4.0, 4.5].

눈사람 1.0.0 , 219 자

{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

"가독성"에 대한 줄 바꿈 :

{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

언 골프 / 축소되지 않은 버전 :

{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

샘플 I / O 형식 :

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 바이트

열거를 사용하고 반복을 줄입니다.

u.ecs@L++hGGeG,khhk2GvzQ

여기에서 온라인으로 사용해보십시오 .

라켓, 164 145 바이트

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

언 골프

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

#lang racket이것을 실행 하려면 라인 이 필요할 수 있습니다 .

R, 109 바이트

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

이것은 벡터와 정수를 받아들이고 벡터를 반환하는 명명되지 않은 함수를 만듭니다. 여기서 접근 방식은 입력을 일 ​​변량 시계열로 취급하고 선형 컨벌루션 필터를 적용하는 것입니다.

언 골프 + 설명 :

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

예 :

> 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

하스켈, 76 자

트릭은 경계 조건을 처리하는 대신 첫 번째 숫자를 목록의 시작 부분에 추가하고 마지막 숫자를 목록의 끝 부분에 추가하는 것입니다.

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)

테스트 :

λ: [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 바이트

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

온라인으로 사용해보십시오

입력은 CJam 목록 형식입니다 (예 : 마지막 예).

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

출력은 CJam 목록이기도합니다.

[33.0 27.0 40.0 22.0 44.0 22.0 40.0 27.0 33.0]

기본 접근 방식은 각 단계에서 벡터가 왼쪽으로 한 위치 오른쪽으로 이동하는 것입니다. 두 벡터 각각은 첫 번째 / 마지막 요소로 채워지고 두 벡터의 평균이 계산됩니다.

설명:

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.

자바, 181 바이트

골프 버전은 다음과 같습니다.

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

언 골프 드 :

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

Java로 가능한 한 할당 및 조건을 줄이려고했습니다. 물론 개선도 환영합니다.

자바 스크립트 (ES6), 153 개 (132) 67 문자

6 개월 후 첫 답변으로 돌아 왔는데 어떻게해야합니까? 50 % 할인 된 가격입니다. ;)

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)

이 버전은 n1보다 작을 때까지 반복해서 호출 n되며 매번 1 씩 감소 합니다.

비 재귀 용액 ( 151 개 130 78 문자) :

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

언 골프 : (오래된)

재귀 :

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

비 재귀 :

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

자바, 203 바이트

Java로 첫 번째 시도. 개선 팁은 환영합니다 :)

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

꽤 인쇄 :

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

파이썬 2, 98 바이트

execwhile 루프를 사용하지 않는 간단한 접근 방식을 취했습니다 . 특별한 사례 위치를 파악하기 위해 논리를 수행하는 더 좋은 방법이 있다고 생각하지만 지금은 효과적입니다. 입력 형식은 다음과 같습니다 [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

언 골프 드 :

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

수학, 81 바이트

양성 상태를 다루는 더 좋은 방법을 찾을 수 있다면 골프를 더 많이 할 수 있다는 느낌이 듭니다.

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

주목할 점 : Mathematica는 다양한 목록 처리 및 필터 기능뿐만 아니라 다양한 내장 솔루션을 제공합니다 CellularAutomaton. 나는 Nest[... ListConvolve ...]목록의 끝에서 꼬임을 해결하는 가장 쉬운 방법이기 때문에 선택 했지만 다른 각도는 더 짧을 수 있습니다.

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

예 :

>> 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 =
     []

스칼라, 195 개 문자 (게으른 출력 (186), 예 Stream) 187 자

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

아마도 최적이 아닌 매핑 sliding(3) 이 아닐 수도 있습니다.이 경우 이 매우 유용합니다.

테스트 :

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

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

예

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 바이트

명명되지 않은 함수로

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}

넓히는

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
}

테스트

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

apt, 39 37 바이트 (비경쟁)

이 답변은 언어가 도전보다 새로운 것이기 때문에 경쟁이 아닙니다. 나는 내 골프 언어가 나의 첫 도전에 얼마나 잘 견딜 수 있는지 알고 싶었습니다.

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

온라인으로 사용해보십시오!

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 바이트

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

입력이 value_type==double같은 컨테이너 여야합니다 vector<double>.

언 골프 드 :

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

라켓 223 바이트

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

언 골프 드 :

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

테스트 :

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

산출:

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

젤리 , 14 바이트

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

온라인으로 사용해보십시오!

전체 프로그램.

C 번호 (카메라 C 번호 인터랙티브 컴파일러) , 160 (144) 바이트

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;

좋은 ol '재귀를 사용합니다.

온라인으로 사용해보십시오!