Dada una lista / matriz no vacía que contiene solo enteros no negativos como este:

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

Salida de la lista con ceros a la izquierda y al final eliminados.

El resultado para esto sería:

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

Algunos otros casos de prueba:

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

El código más corto gana

Jalea , 2 bytes

Código:

t0

Explicación:

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

Pruébalo en línea!

JavaScript (ES6) 43

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

Menos golf

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
}

Prueba

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 bytes

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

Con la matriz ingresada.

Versión más larga:

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 bytes

.sQ0

Manifestación:

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]

De Pyth'srev-doc.txt :

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

05AB1E , 4 bytes

Código:

0Û0Ü

Pruébalo en línea!

Explicación:

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

Utiliza la codificación CP-1252.

Retina, 12 bytes

^0 ?

)` 0$

El avance de línea final es significativo.

Gracias a @Martin Büttner y @FryAmTheEggman por guardar algunos bytes.

Pruébalo en línea

R, 43 bytes

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

o como lectura / escritura STDIN / STDOUT

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

Esto encuentra el máximo acumulativo desde el principio y la cadena final (invertida). El &operador convierte estos dos vectores en uno lógico del mismo tamaño que x, (los ceros siempre se convertirán a FALSEy todo lo demás a TRUE), de esta manera hace posible el subconjunto de xacuerdo con las condiciones cumplidas.

Haskell , 29 bytes

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

Mathematica 34 27 bytes

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

Esto aplica repetidamente reglas de reemplazo hasta que dicha acción no proporcione una nueva salida. 7 bytes guardados gracias a Alephalpha.

La primera regla elimina un cero al principio; la segunda regla elimina un cero al final de la matriz.

05AB1E, 4 bytes

0Û0Ü

Básicamente, recortar los ceros iniciales y finales de la entrada, dados como una matriz.

Pruébalo en línea!

Perl, 19 + 1 = 20 bytes

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

Requiere -pbandera:

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

Jalea, 10 bytes

Uo\U,o\PTị

Esto no usa el incorporado.

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.

Probarlo aquí .

Perl, 38 bytes

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

Ejecutar con perl -p, (3 bytes agregados para-p ).

Acepta números en STDIN, uno por línea; emite números en STDOUT, uno por línea, como debería hacerlo una utilidad Unix con buen comportamiento.

Solo trata los números representados exactamente por '0' como ceros; sería posible soportar otras representaciones con unos pocos bytes más en la expresión regular.

Versión más larga, aún por ejecutar con -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

Versión ampliada, que muestra interacciones con el indicador -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

Elixir, 77 bytes

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

l es la matriz.

Editar: wah! copia / pasta falla. por supuesto, uno tiene que importar Enum, que aumenta el recuento de bytes en 12 (o usar Enum.function_name, lo que lo hará aún más largo).

Vitsy, 13 bytes

Vitsy está mejorando lentamente ... (Voy por ti, Jelly. ಠ_ಠ)

1mr1m
D)[X1m]

Esto sale con la matriz en la pila. Para facilitar la lectura, el TryItOnline! El enlace que he proporcionado debajo de la explicación generará una lista formateada.

Explicación:

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.

Tenga en cuenta que esto generará una StackOverflowException para entradas excesivamente grandes.

TryItOnline!

R, 39 bytes

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

Cuatro bytes menos que la respuesta R de David Arenburg . Esta implementación encuentra el primer y el último índice en la matriz que es mayor que cero, y devuelve todo en la matriz entre esos dos índices.

MATL , 9 bytes

2:"PtYsg)

Pruébalo en línea!

Explicación

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 bytes

{⌽⍵↓⍨+/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.

Probarlo aquí .

Rubí, 49 44 bytes

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

Gracias a manatwork por cortar 5 bytes con un método completamente diferente!

Este dropes solo el primer elemento de la matriz while, es 0, invierte la matriz, se repite y finalmente invierte la matriz para devolverla al orden correcto.

Vim 16 pulsaciones de teclas

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

El usuario debe escribir la entrada entre iy esc, y no cuenta como una pulsación de tecla. Esto supone que habrá al menos un cero inicial y uno posterior. Si esa no es una suposición válida, podemos usar esta versión un poco más larga: (18 pulsaciones de teclas)

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)

tse establece en el índice después del último valor distinto de cero, mientras que fse incrementa siempre que solo se hayan visto ceros hasta ahora.

Perl 6 , 23 bytes

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

Uso:

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

Bastante sencillo. Reemplaza recursivamente ceros al principio y al final de la línea.

Pruébalo en línea!

JavaScript (ES6), 47 bytes

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

¿Dónde aestá la matriz?

Python, 84 caracteres

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,'')

La entrada y la salida tienen la forma de una lista delimitada por espacios, como "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

Utiliza la codificación de Windows-1252

Solución basada en cadenas

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

Corre así:

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

Si su terminal está configurado en UTF-8, esto es lo mismo:

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

Ajustes

• Ahorró 2 bytes al negar cadenas y quitar delimitadores de cadena
• Se guardaron 2 bytes mediante el uso de una etiqueta de impresión corta

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','

Toma entrada $args[0] y -joinlos une con comas para formar una cadena. Luego usamos el.Trim() función llamada dos veces para eliminar primero el final y luego los ceros y las comas iniciales. Luego, -splitla cadena de comas vuelve a una matriz.

Versión alternativa, sin usar conversión
PowerShell de , 81 bytes

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

Como PowerShell no tiene una función para recortar matrices, definimos una nueva función fque hará la mitad de esto por nosotros. La función toma $acomo entrada, luego recorre cada elemento con un bucle foreach |%{...}. Cada iteración, verificamos un condicional para $_ -or $b. Como los enteros distintos de cero son verdaderos, pero $nullfalsey (y$b , al no estar previamente definidos, comienzan como $null), esto solo se evaluará $trueuna vez que alcancemos nuestro primer elemento no cero en la matriz. Luego establecemos $b=1y agregamos el valor actual $_en la tubería. Eso continuará hasta el final de la matriz de entrada, con ceros en el medio y el final se agregará a la salida, ya que hemos establecido la $bverdad.

Encapsulamos y almacenamos los resultados del bucle de nuevo en $a . Luego, indexamos $aen orden inverso (es decir, invirtiendo la matriz), que queda en la tubería y, por lo tanto, es el valor de retorno de la función.

Llamamos a la función dos veces en el $args[0] entrada del programa para "recortar" desde el frente, luego el frente nuevamente (que es el reverso, ya que invertimos). El orden se conserva porque estamos invirtiendo dos veces.

Esta versión juega un poco flojo con las reglas para una matriz de entrada de todos los ceros, pero dado que ignorar STDERR es una práctica aceptada, el programa escupirá dos Cannot index into a null arrayerrores (detallados) a STDERR _{(el equivalente de PowerShell)} y luego no emitirá nada.