# Remove leading and trailing zeroes

Given a non-empty list/array containing only non-negative integers like this:

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

Output the list with trailing and leading zeroes removed.

The output for this would be:

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

Some other test cases:

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

Shortest code wins

-
Are the numbers non-negative integers only? I suggest you clarify that or add test cases with other numbers – Luis Mendo Feb 12 at 20:08
Can we assume that there will be at least one leading and one trailing 0? – Dr Green Eggs and Iron Man Feb 12 at 20:24
@LuisMendo Yes, only non-negative integers. – Lamaro Feb 12 at 22:56
What constitutes nothing? I can think of several different things that are variations on nothing in Perl 6. `Nil` `()`/`[]` `slip()`/`Empty` `Any` `{}` some of them are undefined, some defined but singular, some that slip into other lists such that they don't increase the number of elements. ( There are as many different variations on `Any` as there are classes/types and roles ) – Brad Gilbert b2gills Feb 13 at 0:41
Is it a coincidence that there are no integers over 10 or can we assume that all the numbers are going to be single-digit? – A Simmons Feb 13 at 17:57

# Jelly, 2 bytes

Code:

``````t0
``````

Explanation:

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

Try it online!

-
This works? Jeez. I thought the MATL answers were insane. – Skyl3r Feb 12 at 18:55
wut y no don do dis jelly – VTCAKAVSMoACE Feb 21 at 16:09

# JavaScript (ES6) 43

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

Less golfed

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

Test

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

-
Nice. `f=(a,r=f(a,a))=>r.reverse().filter(x=>a|=x)` is also 43 bytes. – Neil Feb 13 at 18:58

## Pyth, 4 bytes

``````.sQ0
``````

Demo:

``````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]
``````
``````.s <seq> <any>
Strip from A maximal prefix and suffix of A consisting of copies of B.
``````
-

# 05AB1E, 4 bytes

Code:

``````0Û0Ü
``````

Try it online!

Explanation:

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

Uses CP-1252 encoding.

-

# Retina, 12 bytes

``````^0 ?

)` 0\$

``````

The trailing linefeed is significant.

Thanks to @Martin Büttner and @FryAmTheEggman for saving a few bytes.

Try it online

-

# CJam, 13 bytes

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

With the array inputted.

Longer version:

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

# Mathematica 34 27 bytes

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

This repeatedly applies replacement rules until such action fails to provide a new output. 7 bytes saved thanks to Alephalpha.

The first rule deletes a zero at the beginning; the second rule deletes a zero at the end of the array.

-
`#//.{0,a___}|{a___,0}:>{a}&` – alephalpha Feb 13 at 17:46
Thanks!, every byte counts. – DavidC Feb 13 at 19:18

# Perl, 19 + 1 = 20 bytes

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

Requires `-p` flag:

``````\$ perl -pE's/^(0 )+|( 0)+\$//g' <<< '0 0 0 1 2 3 4 5 6 0 0 0'
1 2 3 4 5 6
``````
-
@MartinBüttner I though about the same just after hitting [Add Comment], now I just need to figure out now to let markdown save my newline in a code block – andlrc Feb 12 at 19:03
Via evil HTML hacks. ;) – Martin Ender Feb 12 at 19:04
17+1 bytes: `s/^0 | 0\$//&&redo` – Kenney Feb 21 at 19:14
@Kenney That is beautiful :-) You should post that as an answer! – andlrc Feb 23 at 11:56
Thanks! My original was also 19+1 bytes but then I saw your answer which gave me an idea to shave off 2 more, so it's yours if you want it. Btw, your answer is actually 18+1 if you drop the `?` as in the example - but that won't reduce `"0"`.. – Kenney Feb 23 at 12:10

## Jelly, 10 bytes

``````Uo\U,o\PTị
``````

This doesn't use the builtin.

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

Try it here.

-

# Vitsy, 13 bytes

Vitsy is slowly getting better... (I'm coming for you Jelly. ಠ_ಠ)

``````1mr1m
D)[X1m]``````

This exits with the array on the stack. For readability, the TryItOnline! link that I have provided below the explanation will output a formatted list.

Explanation:

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

Note that this will throw a StackOverflowException for unreasonably large inputs.

TryItOnline!

-
Vitsy will get Jelly some day. – Cᴏɴᴏʀ O'Bʀɪᴇɴ Feb 21 at 17:40
Add auto-bracket matching on EOL/EOF – Cyoce Apr 12 at 21:54

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

## 05AB1E, 4 bytes

``````0Û0Ü
``````

Basically trimming leading then trailing zeroes of the input, given as an array.

Try it online !

-

# MATL, 9 bytes

``````2:"PtYsg)
``````

Try it online!

``````2:"     % for loop (repeat 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 bytes

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

⍣2     Apply this function twice:
+\⍵        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.
``````

Try it here.

-

## Ruby, 49 44 bytes

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

Thanks to manatwork for chopping off 5 bytes with a completely different method!

This just `drop`s the first element of the array `while` it's 0, reverses the array, repeats, and finally reverses the array to return it to the proper order.

-
Ouch. Now even a `.drop_while()` based solution would be shorter (if using 2 functions): `f=->a{a.drop_while{|i|i<1}.reverse};->a{f[f[a]]}` – manatwork Feb 12 at 19:31
Doh. No need for 2 functions, just some `eval` ugliness: `->a{eval ?a+'.drop_while{|i|i<1}.reverse'*2}`. – manatwork Feb 12 at 19:38
@manatwork Not sure why I didn't think of `<1`, anyway. Thanks! – Doorknob Feb 12 at 20:00

# Vim 16 Keystrokes

``````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>
``````
-
I don't think you need to include code to allow the user to input the numbers (`i` and `<esc>`). In vim golf the golfer starts with the input already in a file loaded the buffer and the cursor in the top left corner, but the user also has to save and exit (`ZZ` is usually the fastest way). Then you could do something like `d[1-9]<enter>\$NlDZZ` (13 keystrokes). Note `N`/`n` instead of `/<up><enter>` – daniero Feb 12 at 22:45

# Perl, 38 bytes

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

Run with `perl -p`, (3 bytes added for `-p`).

Accepts numbers on STDIN, one per line; emits numbers on STDOUT, one per line, as a well-behaved unix utility should.

Only treats numbers represented exactly by '0' as zeroes; it would be possible to support other representations with a few more bytes in the regex.

Longer version, still to be run with `-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
``````

Expanded version, showing interactions with -p flag:

``````# implicit while loop added by -p
while (<>) {
# append line to output record separator
\$\.=\$_
}{ # escape the implicit while loop
\$\=~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
``````
-

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

-

# Retina, 11 bytes

``````+`^0 ?| 0\$
<empty>
``````

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

Try it online!

-

## Elixir, 77 bytes

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

l is the array.

Edit:wah! copy/pasta fail. of course one has to import Enum, which raises the byte count by 12 (or use Enum.function_name, which will make it even longer).

-

# R, 43 bytes

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

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

This finds the cumulative maximum from the beginning and the end (reversed) string. The `&` operator converts these two vectors to logical one of the same size as `x`, (zeroes will always converted to `FALSE` and everything else to `TRUE`), this way it makes it possible to subset from `x` according to the met conditions.

-

## PowerShell, 49 bytes

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

Takes input `\$args[0]` and `-join`s 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.

-

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

# Mathematica, 33 bytes

``````#/.{Longest[0...],x__,0...}->{x}&
``````
-

# jq, 48 characters

``````. as\$a|map(.>0)|indices(1>0)|\$a[min:(max//-1)+1]
``````

Sample run:

(Command line option `-c` only used in this sample for readability to avoid pretty printing the result.)

``````bash-4.3\$ jq -c '. as\$a|map(.>0)|indices(1>0)|\$a[min:(max//-1)+1]' <<< '[0, 4, 1, 2, 0, 1, 2, 4, 0]'
[4,1,2,0,1,2,4]

bash-4.3\$ jq -c '. as\$a|map(.>0)|indices(1>0)|\$a[min:(max//-1)+1]' <<< '[0, 0, 0, 0, 0, 0]'
[]
``````

On-line test:

-

## JavaScript (ES6), 47 bytes

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

Where `a` is the array.

-
I think you need to make an anonymous function to take input: `a=>a.join(a="")...`. – andlrc Feb 13 at 17:11
This only handles integers properly when they're a single digit – aross Feb 13 at 23:30
@dev-null Done. – user2428118 Feb 14 at 16:37
Still returning wrong for multi-digit integers. `[14]` will return `[1, 4]`. – Mwr247 Feb 23 at 19:16
Actually, I was (and am) still awaiting a reply to this comment. Anyway, I unfortunately don't see a way to do handle multi-digit integers using the same technique I've used for my answer and I don't think I'll be able to beat this answer anyway. I may try when I have the time, though. – user2428118 Feb 23 at 19:43

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

# Groovy, 43 characters

``````{x={it.dropWhile{it<1}.reverse()};x(x(it))}
``````

Sample run:

``````groovy:000> ({x={it.dropWhile{it<1}.reverse()};x(x(it))})([0, 4, 1, 2, 0, 1, 2, 4, 0])
===> [4, 1, 2, 0, 1, 2, 4]

groovy:000> ({x={it.dropWhile{it<1}.reverse()};x(x(it))})([0, 0, 0, 0, 0, 0])
===> []
``````
-

# sed, 24 bytes

``````#!/bin/sed -f
:
s/ 0\$//
s/^0\b \?//
t
``````

Input as space-separated words on stdin.

It cost me five bytes (`\b \?`) to deal with the special case of all zeros.

### Test results

``````\$ ./71877.sed <<EOF
0 0 0 8 1 4 3 5 6 4 1 2 0 0 0 0
0 4 1 2 0 1 2 4 0
0 0 0 0 0 0
3 4 5 0 0
6
EOF
8 1 4 3 5 6 4 1 2
4 1 2 0 1 2 4

3 4 5
6
``````
-

# 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"`.

-