Stack Overflow 에서이 질문 에서 가져 왔습니다 . 일부 사례를 해결하는 테스트 입력을 제안한 @miles 및 @Dada에게도 감사드립니다.

도전

정수 값의 배열이 주어지면, 0이 아닌 값이 측면에없는 모든 0을 제거하십시오.

마찬가지로 항목이 0이 아닌 경우 또는 0이 아닌 값에 즉시 가까운 0 인 경우 항목을 유지해야합니다.

유지되는 항목은 입력에서 순서대로 출력에 유지되어야합니다.

예

주어진

[2 0 4 -3 0 0 0 3 0 0 2 0 0]

제거해야하는 값은 x다음 과 같이 표시됩니다 .

[2 0 4 -3 0 x 0 3 0 0 2 0 x]

따라서 출력은

[2 0 4 -3 0 0 3 0 0 2 0]

규칙

입력 배열이 비어있을 수 있습니다 (그리고 출력도 비어 있어야합니다).

입력 및 출력 형식은 일반적으로 배열, 목록, 문자열 또는 합리적인 것만 큼 유연합니다.

가장 적은 코드 골프.

테스트 사례

[2 0 4 -3 0 0 0 3 0 0 2 0 0] -> [2 0 4 -3 0 0 3 0 0 2 0]
[] -> []
[1] -> [1]
[4 3 8 5 -6] -> [4 3 8 5 -6]
[4 3 8 0 5 -6] -> [4 3 8 0 5 -6]
[0] -> []
[0 0] -> []
[0 0 0 0] -> []
[0 0 0 8 0 1 0 0] -> [0 8 0 1 0]
[-5 0 5] -> [-5 0 5]
[50 0] -> [50 0]

자바 스크립트 (ES6), 35 바이트

a=>a.filter((e,i)=>e|a[i-1]|a[i+1])

두 개의 여분 바이트에 대해서도 float에서 작동합니다.

파이썬, 50 바이트

f=lambda l,*p:l and l[:any(l[:2]+p)]+f(l[1:],l[0])

튜플을 사용하는 재귀 함수입니다. 처음 두 요소 또는 마지막 시간부터 저장된 이전 값 중 0이 아닌 값이 있으면 첫 번째 요소를 포함합니다. 그런 다음 첫 번째 요소를 제거하고 반복합니다. 이전 요소는 singleton-list에 저장되며, p자동으로 목록으로 압축되어 비어있는 것으로 시작합니다 (이와 함께 3 바이트 동안 Dennis에게 감사합니다).

55 바이트 :

lambda l:[t[1]for t in zip([0]+l,l,l[1:]+[0])if any(t)]

목록의 모든 길이 -3 청크를 생성하고, 처음에 시작과 끝에 0을 넣고 모두 0이 아닌 중간 요소를 가져옵니다.

반복적 접근법이 더 길어졌습니다 (58 바이트)

a=0;b,*l=input()
for x in l+[0]:a|b|x and print(b);a,b=b,x

b,*lPython 3이 필요 하기 때문에 정확하게 작동하지 않지만 Python 3 input은 문자열을 제공합니다. 초기화도 추악합니다. 어쩌면 비슷한 재귀 접근법이 효과가있을 것입니다.

불행히도 인덱싱 방법은

lambda l:[x for i,x in enumerate(l)if any(l[i-1:i+2])]

시작하기 전의 지점이 아니라 목록의 끝으로 l[-1:2]해석 되므로 작동하지 않습니다 -1.

하스켈, 55 48 바이트

h x=[b|a:b:c:_<-scanr(:)[0]$0:x,any(/=0)[a,b,c]]

사용 예 : h [0,0,0,8,0,1,0,0]-> [0,8,0,1,0].

scanr시작과 끝에 x추가 0로 입력 목록 을 재구성합니다 . 각 단계에서 일치하는 요소 3 개를 패턴 화하고 0이 아닌 요소가 하나 이상있는 경우 중간 요소를 유지합니다.

에서 zip3로 전환하여 7 바이트 동안 @xnor에게 감사 합니다 scanr.

Matlab, 29 27 바이트

입력은 1*n매트릭스 로 구성되어야합니다 ( n=0가능한 경우). ( 0*0매트릭스에 오류가 발생합니다 .)

@(a)a(conv(a.*a,1:3,'s')>0) 

컨볼 루션은 성공의 열쇠입니다.

J, 17 14 바이트

#~0<3+/\0,~0,|

@ Zgarb의 도움으로 3 바이트를 저장 했습니다.

용법

   f =: #~0<3+/\0,~0,|
   f 2 0 4 _3 0 0 0 3 0 0 2 0 0
2 0 4 _3 0 0 3 0 0 2 0
   f ''

   f 0 0 0 8 0 1 0 0
0 8 0 1 0

설명

#~0<3+/\0,~0,|  Input: array A
             |  Get the absolute value of each in A
           0,   Prepend a 0
        0,~     Append a 0
    3  \        For each subarray of size 3, left to right
     +/           Reduce it using addition to find the sum
  0<            Test if each sum is greater than one
                (Converts positive values to one with zero remaining zero)
#~              Select the values from A using the previous as a mask and return

여기에서 시도하십시오.

MATL , 8 바이트

tg3:Z+g)

출력은 숫자가 공백으로 구분 된 문자열입니다. 출력에서 빈 배열은 아무것도 아닌 줄 바꿈으로 표시되지 않습니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

이 코드는 입력을 논리 유형으로 변환합니다. 즉, 0이 아닌 항목은 true(또는 1)가되고 0의 항목은 false(또는 0)가됩니다. 이것은 커널과 관련이 [1 2 3]있습니다. 0이 아닌 값은 해당 위치와 인접 위치에서 0이 아닌 결과를 발생시킵니다. 논리로 변환하면 true유지해야 할 값이 제공 되므로 입력을 색인화하면 원하는 출력이 생성됩니다.

t    % Input array implicitly. Duplicate
g    % Convert to logical: nonzero becomes true, zero becomes false
3:   % Push array [1 2 3]
Z+   % Convolution, keeping size of first input
g    % Convert to logical
)    % Index into original array. Implicitly display

줄프, 14 바이트

제가 생각하기에 Jolf는 골프 언어의 자바입니다. 한숨을 쉬 세요.

ψxd||H.nwS.nhS

설명

ψxd||H.nwS.nhS
ψxd             filter input over this function
   ||           or with three args
     H           the element
      .nwS       the previous element
          .nhS   or the next element

파이썬 3, 55 바이트

lambda s:[t[1]for t in zip([0]+s,s,s[1:]+[0])if any(t)]

젤리 , 9 바이트

0,0jo3\Tị

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

0,0jo3\Tị  Main link. Argument: A (array)

0,0        Yield [0, 0].
   j       Join, separating with A. This prepends and appends a 0 to A.
    o3\    Reduce each group of three adjacent integers by logical OR.
       T   Truth; get the indices of all truthy results.
        ị  At-index; retrieve the elements of A at those indices.

Perl, 34 + 1 ( -p플래그) = 35 바이트

s/([^1-9]0 |^)\K0 ?(?=0|$)//&&redo

실행하려면 -p 플래그가 필요합니다. 숫자 목록을 대치로 사용합니다. 예를 들면 :

perl -pe 's/([^1-9]0 |^)\K0 ?(?=0|$)//&&redo' <<< "0 0 0 8 0 1 0 0
0 0 0
-5 0 5"

하스켈, 48 바이트

p%(h:t)=[h|any(/=0)$p:h:take 1t]++h%t
p%e=e
(0%)

이전 요소 p, 첫 번째 요소 h및 이후 요소 (있는 경우)를보고 0이 아닌 경우 첫 번째 요소를 앞에 추가합니다 h.

조건 any(/=0)$p:h:take 1t이 특히 길다 take 1t. 패턴 일치를 통해 단축하는 방법을 찾겠습니다.

레티 나 , 42 35 33 바이트

Martin Ender 덕분에 7 바이트.

(? <= ^ | \ b0) 0 (? = $ | 0)

 +

^ | $

마지막 줄이 필요합니다.

모든 테스트 케이스를 한 번에 확인하십시오. (모든 테스트 케이스를 한 번에 실행하도록 약간 수정했습니다.)

이 작업을 수행하기에 완벽한 언어 인 것 같습니다 ... 여전히 대부분의 답변으로 패배했습니다.

수학, 43 바이트

ArrayFilter[If[#.#>0,#[[2]],Nothing]&,#,1]&

C, 96 바이트

f()정수 목록에 대한 포인터와 목록 크기에 대한 포인터를 사용하여 호출 하십시오. 목록과 크기가 제자리에서 수정됩니다.

i,t,e,m;f(int*p,int*n){int*s=p;for(i=m=e=0;i++<*n;s+=t=m+*s||i<*n&&p[1],e+=t,m=*p++)*s=*p;*n=e;}

ideone에서 사용해보십시오 .

Brachylog , 44 38 바이트

,0gL:?:Lc:1fzbh.
~c[A:.:B],[0:0:0]'.l3

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

이 언어는 우리가 사용할 것임을 증명하는 것만 큼 좋습니다.

술어 0 (주 술어)

,0gL:?:Lc:1fzbh.
 0gL               [0] = L    (assignment works both ways)
   L:?:Lc          [L:input:L] = temp
         :1f       find all solutions of predicate 1 with temp as input
            zbh.   then transpose and take the middle row and assign to output

술어 1 (보조 술어)

~c[A:.:B],[0:0:0]'.l3
~c[A:.:B]                 input is in the form of [A:output:B]
         ,                and
          [0:0:0]'.       output is not [0:0:0]
                  .l3     and length of output is 3

이미지 처리 도구 상자가있는 Matlab, 27 바이트

@(a)a(~imerode(~a,~~(1:3)))

이것은 익명의 기능입니다.

사용 예 :

>> @(a)a(~imerode(~a,~~(1:3)))
ans = 
    @(a)a(~imerode(~a,~~(1:3)))
>> ans([0 0 0 8 0 1 0 0])
ans =
     0     8     0     1     0

배쉬 + GNU 유틸리티, 25

grep -vC1 ^0|grep -v \\-$

줄 바꿈으로 구분 된 목록으로 입력을 승인합니다.

Ideone- 테스트 드라이버 코드를 추가하여 공백으로 구분하고 줄 바꿈으로 변환하여 모든 테스트 케이스를 함께 실행합니다.

체다 , 78 바이트

a->([[]]+a.map((e,i)->e|(i?a[i-1]:0)|(i-a.len+1?a[i+1]:0)?[e]:[])).reduce((+))

테스트 스위트.

체다에는 필터가 없으므로 원하는 요소를 래핑하고 원하지 않는 요소를 빈 배열로 변환 한 다음 모든 것을 연결하여 필터링이 수행됩니다.

예를 들어, [0,0,0,8,0,1,0,0]는 [[],[],[0],[8],[0],[1],[0],[]]이고 연결된 배열은입니다 [0,8,0,1,0].

APL, 14 바이트

{⍵/⍨×3∨/0,⍵,0}

테스트:

      {⍵/⍨×3∨/0,⍵,0}2 0 4 ¯3 0 0 0 3 0 0 2 0 0
2 0 4 ¯3 0 0 3 0 0 2 0

설명:

• 0,⍵,0: ⍵의 시작과 끝에 0을 추가
• ×3∨/: 인접한 3 개의 숫자로 구성된 모든 그룹의 GCD 부호를 찾습니다 (모두 0이면 0, 그렇지 않으면 1).
• ⍵/⍨: 결과가 1 인 ⍵에서 모든 항목을 선택합니다.

루비 2.x, 63 바이트

f=->(x){x.select.with_index{|y,i|x[i-1].to_i|y|x[i+1].to_i!=0}}

그것이 예상되는 곳의 크레딧, 이것은 본질적으로 Neil의 우수한 ES6 답변의 포트입니다.

그것은 또한 나의 첫번째 pcg 제출이다. 예.

Brain-Flak 142 바이트

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

(<()>)(()){{}([]<([]){{}({}<>)<>({}<>)<>({}<>)<>(<>({}<>)<>({}<>)<>({})<>){{}((<()>))}{}{}([][()])}{}{}<>{}([]){{}({}<>)<>([])}{}<>>[[]])}{}{}

설명

(<()>)                    #Pad the top with an extra zero
(()){{}([]<...>[[]])}{}   #Until the stack height remains the same
 ([]){{}...([][()])}{}    #Until the stack height is one
  ({}<>)<>                #Move the top three to the other stack
  ({}<>)<>
  ({}<>)<>
  (...)                   #Push the sum of the top three
   <>({}<>)               #Move the second and third back
   <>({}<>)
   <>({})<>               #Leave the top of the stack
  {{}...}{}               #If the sum is not zero
   ((<()>))               #Add a buffer to the top of the stack
  {}                      #Pop the buffer/middle value
 {}                       #Remove extra zero
 <>                       #Switch to the off stack
 {}                       #Remove extra zero
 ([]){{}({}<>)<>([])}{}<> #Move the entire off stack back