Lấy từ câu hỏi này tại Stack Overflow. Cũng xin cảm ơn @miles và @Dada vì đã đề xuất các đầu vào kiểm tra giải quyết một số trường hợp góc.

Các thách thức

Đưa ra một mảng các giá trị nguyên, loại bỏ tất cả các số không không nằm cạnh một số giá trị khác.

Tương tự, một mục nhập nên được giữ nếu nó là một giá trị khác hoặc nếu nó là số 0 ngay lập tức gần với giá trị khác không.

Các mục được giữ nên duy trì ở đầu ra thứ tự chúng có trong đầu vào.

Thí dụ

Được

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

các giá trị cần được loại bỏ được đánh dấu bằng x:

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

và vì vậy đầu ra phải là

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

Quy tắc

Mảng đầu vào có thể trống (và sau đó đầu ra cũng nên trống).

Các định dạng đầu vào và đầu ra linh hoạt như bình thường: mảng, danh sách, chuỗi hoặc bất cứ thứ gì hợp lý.

Mã golf, ít tốt nhất.

Các trường hợp thử nghiệm

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

JavaScript (ES6), 35 byte

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

Hoạt động trên float quá cho hai byte thêm.

Python, 50 byte

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

Một hàm đệ quy mất một tuple. Bao gồm phần tử đầu tiên nếu có một giá trị khác 0 trong số hai phần tử đầu tiên hoặc giá trị trước đó được lưu trữ từ lần trước. Sau đó, loại bỏ phần tử đầu tiên và đệ quy. Phần tử trước được lưu trữ trong danh sách đơn p, nó tự động đóng gói vào danh sách và bắt đầu trống (nhờ Dennis cho 3 byte với điều này).

55 byte:

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

Tạo tất cả các đoạn có độ dài 3 của danh sách, đầu tiên đặt các số 0 ở đầu và cuối và lấy các phần tử trung gian của các phần tử không phải là số không.

Một cách tiếp cận lặp đi lặp lại dài hơn (58 byte)

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

Điều này không chính xác hoạt động vì b,*lcần Python 3, nhưng Python 3 inputcung cấp một chuỗi. Việc khởi tạo cũng xấu. Có lẽ một cách tiếp cận đệ quy tương tự sẽ làm việc.

Thật không may, phương pháp lập chỉ mục của

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

không hoạt động vì l[-1:2]phiên dịch -1là phần cuối của danh sách, không phải là điểm trước khi bắt đầu.

Haskell, 55 48 byte

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

Ví dụ sử dụng: h [0,0,0,8,0,1,0,0]-> [0,8,0,1,0].

scanrxây dựng lại danh sách đầu vào xvới một bổ sung 0ở đầu và cuối. Trong mỗi bước, chúng ta tạo mẫu khớp với 3 phần tử và giữ nguyên phần giữa nếu có ít nhất một phần tử khác không.

Cảm ơn @xnor cho 7 byte bằng cách chuyển từ zip3sang scanr.

Matlab, 29 27 byte

Đầu vào phải bao gồm một 1*nma trận (nếu n=0có thể). (Nó sẽ đưa ra một lỗi cho 0*0ma trận.)

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

Thuyết phục là chìa khóa thành công.

J, 17 14 byte

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

Đã lưu 3 byte với sự trợ giúp từ @ Zgarb.

Sử dụng

   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

Giải trình

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

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

MATL , 8 byte

tg3:Z+g)

Đầu ra là một chuỗi với các số được phân tách bằng dấu cách. Một mảng trống ở đầu ra được hiển thị dưới dạng không có gì (thậm chí không phải là một dòng mới).

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Mã chuyển đổi đầu vào thành loại logic, tức là các mục nhập khác không trở thành true(hoặc 1) và các mục nhập không trở thành false(hoặc 0). Điều này sau đó được kết hợp với kernel [1 2 3]. Giá trị khác 0 gây ra kết quả khác 0 tại vị trí đó và tại các vị trí lân cận. Chuyển đổi thành logic cung cấp truecho các giá trị nên được giữ, do đó, lập chỉ mục đầu vào với đầu ra tạo ra đầu ra mong muốn.

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

Jolf, 14 byte

Bây giờ tôi nghĩ về nó, Jolf là Java của ngôn ngữ chơi gôn. Hãy thở dài Hãy thử nó ở đây.

ψxd||H.nwS.nhS

Giải trình

ψ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

Python 3, 55 byte

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

Thạch , 9 byte

0,0jo3\Tị

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

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

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 ( -pcờ) = 35 byte

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

Cần cờ -p để chạy. Đưa ra một danh sách các số là imput. Ví dụ :

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

Haskell, 48 byte

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

Nhìn vào phần tử trước p, phần tử đầu tiên hvà phần tử sau (nếu có) và nếu có khác không, hãy chuẩn bị phần tử đầu tiên h.

Các điều kiện any(/=0)$p:h:take 1tlà dài, đặc biệt là take 1t. Tôi sẽ tìm cách rút ngắn nó, có lẽ bằng cách khớp mẫu.

Võng mạc , 42 35 33 byte

7 byte nhờ Martin Ender.

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

 +

^ | $

Dòng cuối cùng là cần thiết.

Xác nhận tất cả các testcase cùng một lúc. (Sửa đổi một chút để chạy tất cả các testcase cùng một lúc.)

Có vẻ như ngôn ngữ hoàn hảo để thực hiện điều này trong ... vẫn bị đánh bại bởi hầu hết các câu trả lời.

Toán học, 43 byte

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

C, 96 byte

Gọi f()bằng một con trỏ tới danh sách các số nguyên và một con trỏ tới kích thước của danh sách. Danh sách và kích thước được sửa đổi tại chỗ.

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

Hãy thử nó trên ideone .

Brachylog , 44 38 byte

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

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

Ngôn ngữ này là tốt như chứng minh mọi thứ, đó là những gì chúng ta sẽ sử dụng.

Vị ngữ 0 (vị ngữ chính)

,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

Vị ngữ 1 (vị ngữ phụ)

~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 với Hộp công cụ xử lý ảnh, 27 byte

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

Đây là một chức năng ẩn danh.

Ví dụ sử dụng:

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

Đồ dùng Bash + GNU, 25

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

Chấp nhận đầu vào dưới dạng danh sách phân tách dòng mới.

Ideone - với mã trình điều khiển thử nghiệm được thêm vào để chạy tất cả các testcase cùng nhau bằng cách chuyển đổi sang / từ phân tách không gian và phân tách dòng mới.

Cheddar , 78 byte

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

Bộ thử nghiệm.

Cheddar không có bộ lọc, vì vậy việc lọc được thực hiện bằng cách gói các phần tử chúng ta muốn và chuyển đổi các phần tử mà chúng ta không muốn thành các mảng trống, sau đó ghép mọi thứ lại.

Ví dụ, [0,0,0,8,0,1,0,0]trở thành [[],[],[0],[8],[0],[1],[0],[]], và sau đó mảng được nối sẽ là [0,8,0,1,0].

APL, 14 byte

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

Kiểm tra:

      {⍵/⍨×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

Giải trình:

• 0,⍵,0: thêm số 0 vào đầu và cuối
• ×3∨/: tìm dấu của GCD của mỗi nhóm ba số liền kề (giá trị này sẽ là 0 nếu chúng đều bằng 0 và 1 nếu không).
• ⍵/⍨: chọn tất cả các mục từ mà kết quả là 1.

Ruby 2.x, 63 byte

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

Tín dụng đến hạn, đây thực chất là một câu trả lời ES6 vượt trội của Neil.

Đây cũng là bài nộp pcg đầu tiên của tôi. vâng

Brain-Flak 142 byte

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

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

Giải trình

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