Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
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
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>
f=(a,r=f(a,a))=>r.reverse().filter(x=>a|=x) is also 43 bytes.
\$\endgroup\$
^0 ?
)` 0$
The trailing linefeed is significant.
Thanks to @Martin Büttner and @FryAmTheEggman for saving a few 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
.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]
From Pyth's rev-doc.txt:
.s <seq> <any>
Strip from A maximal prefix and suffix of A consisting of copies of B.
Code:
0Û0Ü
Explanation:
0Û # Trim off leading zeroes
0Ü # Trim off trailing zeroes
Uses CP-1252 encoding.
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.
function(x)x[cummax(x)&rev(cummax(rev(x)))]
or as read/write STDIN/STDOUT
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.
#//.{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Û0Ü
Basically trimming leading then trailing zeroes of the input, given as an array.
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
? as in the example - but that won't reduce "0"..
\$\endgroup\$
->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 drops 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.
.drop_while() based solution would be shorter (if using 2 functions): f=->a{a.drop_while{|i|i<1}.reverse};->a{f[f[a]]}
\$\endgroup\$
Feb 12, 2016 at 19:31
eval ugliness: ->a{eval ?a+'.drop_while{|i|i<1}.reverse'*2}.
\$\endgroup\$
Feb 12, 2016 at 19:38
<1, anyway. Thanks!
\$\endgroup\$
$\.=$_}{$\=~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
# 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
perl -E, the -p flag usually is only counted as one byte, since there's only one extra byte different between that and perl -pE.
\$\endgroup\$
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).
a=>a.join(a="").replace(/(^0+|0+$)/g,a).split(a)
Where a is the array.
a=>a.join(a="")....
\$\endgroup\$
Feb 13, 2016 at 17:11
[14] will return [1, 4].
\$\endgroup\$
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.
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".
function(x)x[min(i<-which(x>0)):max(i)]
Four bytes shorter than David Arenburg's R answer. This implementation finds the first and last index in the array which is greater than zero, and returns everything in the array between those two indices.
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
lambda a:map(int,''.join(map(str,a)).strip('0'))
{↔a₁.h>0∧}ⁱ²
The predicate fails in the case of "nothing".
a₁. Take the longest suffix of
↔ the input reversed
h the first element of which
>0 is greater than 0
∧ (which is not the output).
{ }ⁱ² Do it again.
If "nothing" has to be some actual value, like an empty list, it's only one more byte:
{↔a₁.h>0∨Ė}ⁱ²
If the input can be assumed to contain only single digits, it's quite a bit shorter:
c↔↔ℕ₁ẹ
{⌽⍵↓⍨+/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.
Try it here.
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 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>
\$\endgroup\$
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.
{.[.grep(?*):k.minmax]}
{.[minmax .grep(?*):k]}
# 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)
+`^0 ?| 0$
<empty>
Quite simple. Recursively replaces zeroes at beginning and end of line.
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
a=>/^(0,)*(.*?)(,0)*$/.exec(a.join())[2]
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
Nil()/[]slip()/EmptyAny{}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 onAnyas there are classes/types and roles ) \$\endgroup\$"0,4,1,2,0,1,2,4,0" => "4,1,2,0,1,2,4"EDIT: Just noticed many languages do this already. \$\endgroup\$