Dato un elenco / array non vuoto contenente solo numeri interi non negativi come questo:

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

Output dell'elenco con zero finali e iniziali rimossi.

L'output per questo sarebbe:

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

Alcuni altri casi di test:

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

Il codice più corto vince

Gelatina , 2 byte

Codice:

t0

Spiegazione:

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

Provalo online!

JavaScript (ES6) 43

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

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

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>

CJam, 13 byte

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

Con l'array immesso.

Versione più lunga:

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 byte

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

Da Pyth'srev-doc.txt :

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

05AB1E , 4 byte

Codice:

0Û0Ü

Provalo online!

Spiegazione:

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

Utilizza la codifica CP-1252.

Retina, 12 byte

^0 ?

)` 0$

L'alimentazione di linea finale è significativa.

Grazie a @Martin Büttner e @FryAmTheEggman per aver salvato alcuni byte.

Provalo online

R, 43 byte

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

o come lettura / scrittura STDIN / STDOUT

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

Questo trova il massimo cumulativo dall'inizio e la fine (inversa) della stringa. L' &operatore converte questi due vettori in uno logico della stessa dimensione di x, (gli zero verranno sempre convertiti in FALSEe tutto il resto in TRUE), in questo modo consente di effettuare il sottoinsieme in xbase alle condizioni soddisfatte.

Haskell , 29 byte

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

Mathematica 34 27 byte

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

Ciò applica ripetutamente regole di sostituzione fino a quando tale azione non riesce a fornire un nuovo output. 7 byte salvati grazie ad Alephalpha.

La prima regola elimina uno zero all'inizio; la seconda regola elimina uno zero alla fine dell'array.

05AB1E, 4 byte

0Û0Ü

Fondamentalmente, tagliando gli zeri iniziali e finali dell'input, dati come un array.

Provalo online!

Perl, 19 + 1 = 20 byte

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

Richiede -pbandiera:

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

Gelatina, 10 byte

Uo\U,o\PTị

Questo non usa il built-in.

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.

Provalo qui .

Perl, 38 byte

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

Esegui con perl -p, (3 byte aggiunti per -p).

Accetta numeri su STDIN, uno per riga; emette numeri su STDOUT, uno per riga, come dovrebbe essere un'utilità unix ben educata.

Tratta solo i numeri rappresentati esattamente da '0' come zero; sarebbe possibile supportare altre rappresentazioni con qualche byte in più nella regex.

Versione più lunga, ancora da eseguire 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

Versione estesa, che mostra le interazioni con -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

Elisir, 77 byte

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

Sono l'array.

Edit: wah! copia / pasta fallita. ovviamente bisogna importare Enum, che aumenta il numero di byte di 12 (o usare Enum.function_name, che lo renderà ancora più lungo).

Vitsy, 13 byte

Vitsy sta lentamente migliorando ... (Vengo per te, Jelly. ಠ_ಠ)

1mr1m
D)[X1m]

Questo si chiude con l'array nello stack. Per leggibilità, TryItOnline! il link che ho fornito sotto la spiegazione produrrà un elenco formattato.

Spiegazione:

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.

Si noti che ciò genererà StackOverflowException per input irragionevolmente grandi.

TryItOnline!

R, 39 byte

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

Quattro byte più brevi della risposta R di David Arenburg . Questa implementazione trova il primo e l'ultimo indice nell'array che è maggiore di zero e restituisce tutto l'array tra quei due indici.

MATL , 9 byte

2:"PtYsg)

Provalo online!

Spiegazione

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 byte

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

Provalo qui .

Rubino, 49 44 byte

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

Grazie alla manatwork per tagliare 5 byte con un metodo completamente diverso!

Questo è solo dropil primo elemento dell'array whileche è 0, inverte l'array, si ripete e infine inverte l'array per riportarlo nell'ordine corretto.

Vim 16 sequenze di tasti

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

L'input deve essere digitato dall'utente tra ie esce non viene considerato come una sequenza di tasti. Questo presuppone che ci sarà almeno uno zero iniziale e uno finale. Se questo non è un presupposto valido, possiamo usare questa versione leggermente più lunga: (18 sequenze di tasti)

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

ES6, 51 byte

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

tviene impostato sull'indice dopo l'ultimo valore diverso da zero, mentre fviene incrementato fino a quando sono stati visti solo zeri finora.

Perl 6 , 23 byte

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

+`^0 ?| 0$
<empty>

Abbastanza semplice. Sostituisce in modo ricorsivo gli zeri all'inizio e alla fine della riga.

Provalo online!

JavaScript (ES6), 47 byte

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

Dov'è al'array.

Python, 84 caratteri

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 byte

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

L'input e l'output hanno la forma di un elenco delimitato da spazi, ad esempio "0 4 1 2 0 1 2 4 0".

Javascript (ES6) 40 byte

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

PHP, 56 54 52 byte

Utilizza la codifica Windows-1252

Soluzione basata su stringhe

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

Esegui in questo modo:

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

Se il terminale è impostato su UTF-8, questo è lo stesso:

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

Ritocchi

• Salvato 2 byte negando le stringhe e rilasciando i delimitatori di stringa
• Salvato 2 byte utilizzando un tag di stampa breve

Python 2, 69 67 byte

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

PowerShell, 49 byte

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

Prende input $args[0]e -joinli inserisce insieme alle virgole per formare una stringa. Quindi utilizziamo la .Trim()funzione chiamata due volte per rimuovere prima il trailing e poi gli zeri e le virgole iniziali. Quindi -splitriportiamo la stringa tra virgole in un array.

Versione alternativa, senza utilizzare la conversione
PowerShell, 81 byte

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

Poiché PowerShell non ha una funzione per tagliare gli array, definiamo una nuova funzione fche farà la metà di questo per noi. La funzione accetta $acome input, quindi scorre ciclicamente ogni elemento con un ciclo foreach |%{...}. Ogni iterazione, controlliamo un condizionale per $_ -or $b. Poiché i numeri interi diversi da zero sono veritieri, ma $nullsono falsi (e $b, non essendo precedentemente definiti, iniziano come $null), questo verrà valutato solo $truedopo aver raggiunto il nostro primo elemento diverso da zero nella matrice. Quindi impostiamo $b=1e aggiungiamo il valore corrente $_sulla pipeline. Ciò continuerà fino alla fine dell'array di input, con gli zeri nel mezzo e la fine che verrà aggiunta all'output, poiché abbiamo impostato$b verità.

Incapsuliamo e archiviamo nuovamente i risultati del loop $a. Quindi, indicizziamo $ain ordine inverso (cioè invertendo l'array), che viene lasciato sulla pipeline e quindi è il valore di ritorno della funzione.

Chiamiamo la funzione due volte $args[0]sull'ingresso al programma per "tagliare" dalla parte anteriore, quindi di nuovo dalla parte anteriore (che è la parte posteriore, poiché abbiamo invertito). L'ordine è conservato poiché ci stiamo invertendo due volte.

Questa versione gioca un po 'in disparte con le regole per un array di input di tutti gli zeri, ma poiché ignorare STDERR è una pratica accettata, il programma sputerà due Cannot index into a null arrayerrori (dettagliati) a _{(equivalente di PowerShell di)} STDERR e quindi non produrrà nulla.