Дан непустой список / массив, содержащий только неотрицательные целые числа, как это:

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

Некоторые другие тестовые случаи:

[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

Попробуйте онлайн!

JavaScript (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'srev-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соответствии с условиями встречались.

Haskell , 29 байт

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

Mathematica 34 27 байт

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

Это постоянно применяет правила замены до тех пор, пока такое действие не сможет обеспечить новый вывод. 7 байтов сохранено благодаря Alephalpha.

Первое правило удаляет ноль в начале; второе правило удаляет ноль в конце массива.

05AB1E, 4 байта

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.

Попробуй это здесь .

Perl, 38 байт

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

Запуск с perl -p, (добавлено 3 байта -p).

Принимает числа на STDIN, по одному на строку; генерирует числа в STDOUT, по одному на строку, как и должна делать утилита unix.

Только числа, представленные в точности как 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))

л это массив.

Edit: вау! копирование / макароны не удаются. Конечно, нужно импортировать Enum, который увеличивает количество байтов на 12 (или использовать Enum.function_name, что сделает его еще длиннее).

Витси, 13 байт

Витси постепенно поправляется ... (Я иду за тобой, Джелли. ಠ_ಠ)

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

На четыре байта короче R-ответа Дэвида Аренбурга . Эта реализация находит первый и последний индекс в массиве, который больше нуля, и возвращает все в массиве между этими двумя индексами.

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

Дьялог АПЛ, 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}

Спасибо manatwork за то, что вырубили 5 байт совершенно другим методом!

Это просто dropпервый элемент массива, whileон равен 0, обращает массив, повторяет его и, наконец, обращает массив, чтобы вернуть его в правильном порядке.

Vim 16 нажатий клавиш

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

Ввод вводится пользователем между iи esc, и не считается нажатием клавиши. Это предполагает, что будет по крайней мере один ведущий и один конечный ноль. Если это неверное предположение, мы можем использовать эту немного более длинную версию: (18 нажатий клавиш)

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

ES6, 51 байт

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

tустанавливается на индекс после последнего ненулевого значения, в то время fкак увеличивается до тех пор, пока пока видны только нули.

Perl 6 , 23 байта

{.[.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)

Сетчатка, 11 байт

+`^0 ?| 0$
<empty>

Довольно просто. Рекурсивно заменяет нули в начале и конце строки.

Попробуйте онлайн!

JavaScript (ES6), 47 байт

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

Где aнаходится массив.

Python, 84 символа

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 байта

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

Ввод и вывод выполняются в форме списка, разделенного пробелами, например "0 4 1 2 0 1 2 4 0".

Javascript (ES6) 40 байт

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

PHP, 56 54 52 байта

Использует кодировку Windows-1252

Струнное решение

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

Запустите так:

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

Если ваш терминал установлен в UTF-8, это то же самое:

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

Tweaks

• Сохранено 2 байта путем отрицания строк и удаления разделителей строк
• Сохранено 2 байта с помощью короткого тега печати

Python 2, 69 67 байт

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

PowerShell, 49 байт

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

Принимает данные $args[0]и -joinвводит их вместе с запятыми для формирования строки. Затем мы используем .Trim()функцию, вызываемую дважды, чтобы удалить сначала завершающие, а затем начальные нули и запятые. Затем мы помещаем -splitстроку с запятыми обратно в массив.

Альтернативная версия, без использования преобразования
PowerShell, 81 байт

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

Поскольку PowerShell не имеет функции для обрезки массивов, мы определяем новую функцию f, которая сделает для нас половину этого. Функция принимает в $aкачестве входных данных, затем перебирает каждый элемент с помощью цикла foreach |%{...}. Каждую итерацию мы проверяем на условность $_ -or $b. Так как ненулевые целые числа являются правдивыми, но $nullложными (и $b, будучи ранее не определенными, начинаются как $null), это будет только $trueпосле того, как мы попадем в наш первый ненулевой элемент в массиве. Затем мы устанавливаем $b=1и добавляем текущее значение $_в конвейер. Затем это будет продолжаться до конца входного массива, с нулями в середине и концом, добавляемым на выход, так как мы установили $btruey.

Мы инкапсулируем и сохраняем результаты цикла обратно в $a. Затем мы индексируем $aв обратном порядке (т. Е. Обращаем массив), который остается в конвейере и, таким образом, является возвращаемым значением функции.

Мы дважды вызываем функцию на $args[0]входе в программу, чтобы «обрезать» ее спереди, а затем снова спереди (то есть сзади, поскольку мы перевернули). Порядок сохраняется, так как мы дважды меняем направление.

Эта версия немного не соответствует правилам для входного массива всех нулей, но поскольку игнорирование STDERR является общепринятой практикой, программа выдаст две (подробные) Cannot index into a null arrayошибки _{(эквивалент PowerShell) в} STDERR и затем ничего не выдаст.