다음과 같이 음이 아닌 정수만 포함하는 비어 있지 않은 목록 / 배열이 제공됩니다.

[0, 0, 0, 8, 1, 4, 3, 5, 6, 4, 1, 2, 0, 0, 0, 0]

후행 및 선행 0이 제거 된 목록을 출력하십시오.

이에 대한 출력은 다음과 같습니다.

[8, 1, 4, 3, 5, 6, 4, 1, 2]

다른 테스트 사례 :

[0, 4, 1, 2, 0, 1, 2, 4, 0] > [4, 1, 2, 0, 1, 2, 4]
[0, 0, 0, 0, 0, 0] > nothing
[3, 4, 5, 0, 0] > [3, 4, 5]
[6] > [6]

최단 코드 승리

젤리 , 2 바이트

암호:

t0

설명:

t   # Trim off...
 0  #  zero at both sides

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

자바 스크립트 (ES6) 43

a=>(f=a=>a.reverse().filter(x=>a|=x))(f(a))

덜 골프

a=>{
  f=a=>a.reverse().filter(x=>a|=x) // reverse and remove leading 0
  // leverage js cast rules: operator | cast operands to integer
  // an array casted to integer is 0 unless the array is made of
  // a single integer value (that is ok for me in this case)
  return f(f(a)) // apply 2 times
}

테스트

F=a=>(f=a=>a.reverse().filter(x=>a|=x))(f(a))

function test(){
  var l=(I.value.match(/\d+/g)||[]).map(x=>+x)
  O.textContent=F(l)
}

test()

#I { width:90%}

<input id=I oninput='test()' value='0 0 1 3 7 11 0 8 23 0 0 0'>
<pre id=O></pre>

CJam, 13 바이트

l~{_{}#>W%}2*

배열이 입력 된 상태

더 긴 버전 :

l~             Puts input on the stack and parse as array
  {       }    Code block
   _           Duplicate the first thing on the stack
    {}#        Finds the index of the first non-0 value in the array, puts it on the stack
       >       Slices the array from that index
        W%     Reverses the array
           2*  Does the code block twice in total

Pyth, 4 바이트

.sQ0

데모:

llama@llama:~$ pyth -c .sQ0
[0, 0, 0, 1, 2, 0, 3, 4, 0, 0, 5, 0, 0, 0, 0]
[1, 2, 0, 3, 4, 0, 0, 5]

에서 Pyth의rev-doc.txt :

.s <seq> <any>
    Strip from A maximal prefix and suffix of A consisting of copies of B.

05AB1E , 4 바이트

암호:

0Û0Ü

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

설명:

0Û    # Trim off leading zeroes
  0Ü  # Trim off trailing zeroes

CP-1252 인코딩을 사용합니다.

레티 나, 12 바이트

^0 ?

)` 0$

후행 줄 바꿈이 중요합니다.

몇 바이트를 절약 한 @Martin Büttner 와 @FryAmTheEggman 에게 감사 합니다.

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

R, 43 바이트

function(x)x[cummax(x)&rev(cummax(rev(x)))]

또는 읽기 / 쓰기 STDIN / STDOUT

x=scan();cat(x[cummax(x)&rev(cummax(rev(x)))])

시작 및 끝 (역순) 문자열에서 누적 최대 값을 찾습니다. &같이 오퍼레이터가 동일한 크기의 논리 하나 이들 두 벡터 변환 x(항상 제로로 변환되며, FALSE다른 행 및 모든 TRUE), 그것을 가능하게이 방법은 서브셋 x메트 조건에 따라.

하스켈 , 29 바이트

t=f.f;f=reverse.dropWhile(<1)

매스 매 티카 34 27 바이트

#//.{0,a___}|{a___,0}:>{a}&

이는 이러한 조치가 새 출력을 제공하지 못할 때까지 대체 규칙을 반복해서 적용합니다. Alephalpha 덕분에 7 바이트가 절약되었습니다.

첫 번째 규칙은 처음에 0을 삭제합니다. 두 번째 규칙은 배열 끝에서 0을 삭제합니다.

05AB1E, 4 바이트

0Û0Ü

기본적으로 배열로 주어진 입력의 선행 및 후행 0을 트리밍합니다.

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

Perl, 19 + 1 = 20 바이트

s/^(0 ?)+|( 0)+$//g

-p플래그 필요 :

$ perl -pE's/^(0 )+|( 0)+$//g' <<< '0 0 0 1 2 3 4 5 6 0 0 0'
1 2 3 4 5 6

젤리, 10 바이트

Uo\U,o\PTị

이것은 내장을 사용하지 않습니다.

Uo\U            Backward running logical OR
    ,           paired with
     o\         Forward running logical OR
       P        Product
        T       All indices of truthy elements
         ị      Index the input at those values.

여기에서 시도 하십시오 .

펄, 38 바이트

$\.=$_}{$\=~s/^(0\n)*|(0\n)*\n$//gs

로 실행하십시오 perl -p(에 대해 3 바이트 추가 -p).

STDIN에서 한 줄에 하나씩 숫자를 허용합니다. 잘 동작하는 유닉스 유틸리티로서 STDOUT에서 한 줄에 하나씩 숫자를 내 보냅니다.

정확히 '0'으로 표시된 숫자 만 0으로 처리합니다. 정규식에서 몇 바이트를 더 사용하여 다른 표현을 지원할 수 있습니다.

더 긴 버전으로 계속 실행됩니다 -p.

    # append entire line to output record separator
    $\.=$_
}{
    # replace leading and trailng zeroes in output record separator
    $\ =~ s/^(0\n)*|(0\n)*\n$//gs
    # output record separator will be implicitly printed

-p 플래그와의 상호 작용을 보여주는 확장 된 버전 :

# implicit while loop added by -p
while (<>) {
    # append line to output record separator
    $\.=$_
}{ # escape the implicit while loop
    # replace leading and traling 
    $\=~s/^(0\n)*|(0\n)*\n$//gs
    # print by default prints $_ followed by
    # the output record separator $\ which contains our answer
    ;print # implicit print added by -p
} # implicit closing brace added by -p

엘릭서, 77 바이트

import Enum
z=fn x->x==0 end
reverse(drop_while(reverse(drop_while(l,z)),z))

l은 배열입니다.

편집 :와! 복사 / 파스타가 실패합니다. 물론 Enum을 가져와야하므로 바이트 수가 12 증가합니다 (또는 Enum.function_name을 사용하면 더 길어집니다).

Vitsy, 13 바이트

Vitsy가 점점 좋아지고 있습니다 ... (Jelly를 위해 왔습니다.

1mr1m
D)[X1m]

스택의 어레이와 함께 종료됩니다. 가독성을 위해 TryItOnline! 설명 아래에 제공 한 링크는 형식이 지정된 목록을 출력합니다.

설명:

1mr1m
1m      Do the second line of code.
  r     Reverse the stack.
   1m   I'ma let you figure this one out. ;)

D)[X1m]
D       Duplicate the top item of the stack.
 )[   ] If the top item of the stack is zero, do the stuff in brackets.
   X    Remove the top item of the stack.
    1m  Execute the second line of code.

불합리하게 큰 입력에 대해서는 StackOverflowException이 발생합니다.

TryItOnline!

R, 39 바이트

function(x)x[min(i<-which(x>0)):max(i)]

David Arenburg의 R answer 보다 4 바이트 짧습니다 . 이 구현은 배열에서 0보다 큰 첫 번째 인덱스와 마지막 인덱스를 찾아 두 인덱스 사이의 배열에있는 모든 것을 반환합니다.

MATL , 9 바이트

2:"PtYsg)

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

설명

2:"     % For loop (do the following twice)
  P     %   Flip array. Implicitly asks for input the first time
  t     %   Duplicate
  Ys    %   Cumulative sum
  g     %   Convert to logical index
  )     %   Apply index
        % Implicitly end for
        % Implicitly display stack contents

Dyalog APL, 15 바이트

{⌽⍵↓⍨+/0=+\⍵}⍣2

               ⍣2     Apply this function twice:
{             }       Monadic function:
           +\⍵        Calculate the running sum.
       +/0=           Compare to zero and sum. Number of leading zeroes.
   ⍵↓⍨               Drop the first that many elements from the array.
 ⌽                   Reverse the result.

여기에서 시도 하십시오 .

루비, 49 44 바이트

->a{eval ?a+'.drop_while{|i|i<1}.reverse'*2}

완전히 다른 방법으로 5 바이트를 자르는 manatwork 덕분에 !

이것은 drop배열의 첫 번째 요소 인 while0이며 배열을 뒤집고 반복하며 마지막으로 배열을 뒤집어 올바른 순서로 반환합니다.

Vim 16 키 스트로크

i<input><esc>?[1-9]<enter>lD0d/<up><enter>

The input is to be typed by the user between i and esc, and does not count as a keystroke. This assumes that there will be at least one leading and one trailing zero. If that is not a valid assumption, we can use this slightly longer version: (18 Keystrokes)

i <input> <esc>?[1-9]<enter>lD0d/<up><enter>

ES6, 51 bytes

f=a=>a.map(x=>x?t=++i:f<i++||++f,f=i=0)&&a.slice(f,t)

t is set to the index after the last non-zero value, while f is incremented as long as only zeros have been seen so far.

Perl 6, 23 bytes

{.[.grep(?*):k.minmax]}
{.[minmax .grep(?*):k]}

Usage:

# replace the built-in trim subroutine
# with this one in the current lexical scope
my &trim = {.[.grep(?*):k.minmax]}

say trim [0, 0, 0, 8, 1, 4, 3, 5, 6, 4, 1, 2, 0, 0, 0, 0];
# (8 1 4 3 5 6 4 1 2)
say trim [0, 4, 1, 2, 0, 1, 2, 4, 0];
# (4 1 2 0 1 2 4)
say trim [0, 0, 0, 0, 0, 0];
# ()
say trim [3, 4, 5, 0, 0];
# (3 4 5)
say trim [6];
# (6)

Retina, 11 bytes

+`^0 ?| 0$
<empty>

Quite simple. Recursively replaces zeroes at beginning and end of line.

Try it online!

JavaScript (ES6), 47 bytes

a=>a.join(a="").replace(/(^0+|0+$)/g,a).split(a)

Where a is the array.

Python, 84 characters

def t(A):
 if set(A)<={0}:return[]
 for i in(0,-1):
  while A[i]==0:del A[i]
 return A

JavaScript (ES6), 34 bytes

a=>a.replace(/^(0 ?)*|( 0)*$/g,'')

Input and output are in the form of a space-delimited list, such as "0 4 1 2 0 1 2 4 0".

Javascript (ES6) 40 bytes

a=>/^(0,)*(.*?)(,0)*$/.exec(a.join())[2]

PHP, 56 54 52 bytes

Uses Windows-1252 encoding

String based solution

<?=preg_replace(~ÜÒ×ßÏÖÔƒ×ßÏÖÔÛÜ,"",join($argv,~ß));

Run like this:

echo '<?=preg_replace(~ÜÒ×ßÏÖÔƒ×ßÏÖÔÛÜ,"",join($argv,~ß));' | php -- 0 0 123 234 0 500 0 0 2>/dev/null;echo

If your terminal is set to UTF-8, this is the same:

echo '<?=preg_replace("#-( 0)+|( 0)+$#","",join($argv," "));' | php -- 0 0 123 234 0 500 0 0 2>/dev/null;echo

Tweaks

• Saved 2 bytes by negating strings and dropping string delimiters
• Saved 2 bytes by using short print tag

Python 2, 69 67 bytes

def f(a):
 for i in(0,-1):
  while a and a[i]==0:a.pop(i)
 return a

PowerShell, 49 bytes

($args[0]-join',').trim(',0').trim('0,')-split','

Takes input $args[0] and -joins them together with commas to form a string. We then use the .Trim() function called twice to remove first the trailing and then the leading zeros and commas. We then -split the string on commas back into an array.

Alternate version, without using conversion
PowerShell, 81 bytes

function f{param($a)$a=$a|%{if($_-or$b){$b=1;$_}};$a[$a.Count..0]}
f(f($args[0]))

Since PowerShell doesn't have a function to trim arrays, we define a new function f that will do half of this for us. The function takes $a as input, then loops through each item with a foreach loop |%{...}. Each iteration, we check a conditional for $_ -or $b. Since non-zero integers are truthy, but $null is falsey (and $b, being not previously defined, starts as $null), this will only evaluate to $true once we hit our first non-zero element in the array. We then set $b=1 and add the current value $_ onto the pipeline. That will then continue through to the end of the input array, with zeros in the middle and the end getting added onto the output, since we've set $b truthy.

We encapsulate and store the results of the loop all back into $a. Then, we index $a in reverse order (i.e., reversing the array), which is left on the pipeline and thus is the function's return value.

We call the function twice on the $args[0] input to the program in order to "trim" from the front, then the front again (which is the back, since we reversed). The order is preserved since we're reversing twice.

This version plays a little loose with the rules for an input array of all zeros, but since ignoring STDERR is accepted practice, the program will spit out two (verbose) Cannot index into a null array errors to _{(PowerShell's equivalent of)} STDERR and then output nothing.