Bei einer nicht leeren Liste / Array, die nur nicht negative ganze Zahlen enthält, wie folgt vorgehen:

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

Geben Sie die Liste mit entfernten nachgestellten und führenden Nullen aus.

Die Ausgabe hierfür wäre:

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

Einige andere Testfälle:

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

Kürzester Code gewinnt

Gelee , 2 Bytes

Code:

t0

Erläuterung:

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

Probieren Sie es online!

JavaScript (ES6) 43

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

Weniger golfen

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
}

Prüfung

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*

Mit dem Array eingegeben.

Längere 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

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]

Von Pythsrev-doc.txt :

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

05AB1E , 4 Bytes

Code:

0Û0Ü

Probieren Sie es online!

Erläuterung:

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

Verwendet CP-1252-Codierung.

Retina, 12 Bytes

^0 ?

)` 0$

Der Zeilenvorschub am Ende ist signifikant.

Vielen Dank an @Martin Büttner und @FryAmTheEggman für die Einsparung einiger Bytes.

Probieren Sie es online aus

R, 43 Bytes

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

oder als Lese- / Schreib-STDIN / STDOUT

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

Hiermit wird das kumulative Maximum vom Anfang bis zum Ende der (umgekehrten) Zeichenfolge ermittelt. Der &Operator konvertiert diese beiden Vektoren in logische Vektoren der gleichen Größe wie x(Nullen werden immer in FALSEund alles andere in konvertiert TRUE). Auf diese Weise ist es möglich, eine Teilmenge xentsprechend den erfüllten Bedingungen zu erstellen.

Haskell , 29 Bytes

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

Mathematica 34 27 Bytes

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

Dies wendet wiederholt Ersetzungsregeln an, bis eine solche Aktion keine neue Ausgabe liefert. 7 Bytes dank Alephalpha gespart.

Die erste Regel löscht am Anfang eine Null. Die zweite Regel löscht eine Null am Ende des Arrays.

05AB1E, 4 Bytes

0Û0Ü

Grundsätzlich werden führende und nachfolgende Nullen der Eingabe in Form eines Arrays abgeschnitten.

Probieren Sie es online!

Perl, 19 + 1 = 20 Bytes

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

Benötigt -pFlagge:

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

Gelee, 10 Bytes

Uo\U,o\PTị

Dies nutzt nicht die eingebaute.

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.

Probieren Sie es hier aus .

Perl, 38 Bytes

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

Laufen Sie mit perl -p , (3 Bytes hinzugefügt für -p).

Akzeptiert Nummern auf STDIN, eine pro Zeile; Gibt Zahlen auf STDOUT aus, eine pro Zeile, wie es ein ordentliches Unix-Dienstprogramm tun sollte.

Nur Zahlen, die genau durch '0' dargestellt werden, werden als Nullen behandelt. Es wäre möglich, andere Darstellungen mit ein paar weiteren Bytes im regulären Ausdruck zu unterstützen.

Längere Version, noch lauffähig mit -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

Erweiterte Version, die Interaktionen mit dem Flag -p anzeigt:

# 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

Elixier, 77 Bytes

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

l ist das Array.

Edit: Wah! Kopieren / Pasta scheitern. Natürlich muss man Enum importieren, was die Byteanzahl um 12 erhöht (oder Enum.function_name verwenden, wodurch es noch länger wird).

Vitsy, 13 Bytes

Vitsy geht es langsam besser ... (Ich komme, um dich zu holen, Jelly. ಠ_ಠ)

1mr1m
D)[X1m]

Dies wird mit dem Array auf dem Stapel beendet. Zur besseren Lesbarkeit bietet TryItOnline! Ein Link, den ich unten angegeben habe, gibt eine formatierte Liste aus.

Erläuterung:

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.

Beachten Sie, dass dies eine StackOverflowException für unangemessen große Eingaben auslöst.

TryItOnline!

R, 39 Bytes

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

Vier Bytes kürzer als die R-Antwort von David Arenburg . Diese Implementierung findet den ersten und letzten Index im Array, der größer als Null ist, und gibt alles im Array zwischen diesen beiden Indizes zurück.

MATL , 9 Bytes

2:"PtYsg)

Probieren Sie es online!

Erläuterung

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.

Probieren Sie es hier aus .

Ruby, 49 44 Bytes

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

Dank der Handarbeit für das von 5 Bytes mit einer ganz anderen Methode!

Dies ist nur dropdas erste Element des Arrays, whilees ist 0, kehrt das Array um, wiederholt es und kehrt schließlich das Array um, um es in die richtige Reihenfolge zu bringen.

Vim 16 Tastenanschläge

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

Die Eingabe ist vom Benutzer zwischendurch zu tippen i undesc und gilt nicht als Tastendruck. Dies setzt voraus, dass es mindestens eine führende und eine nachfolgende Null geben wird. Wenn dies keine gültige Annahme ist, können wir diese etwas längere Version verwenden: (18 Tastenanschläge)

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)

twird auf den Index nach dem letzten Nicht-Null-Wert gesetzt, während finkrementiert wird, solange bis jetzt nur Nullen gesehen wurden.

Perl 6 , 23 Bytes

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

Verwendung:

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

Ziemlich einfach. Ersetzt rekursiv Nullen am Zeilenanfang und Zeilenende.

Probieren Sie es online!

JavaScript (ES6), 47 Byte

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

Wo aist das Array?

Python, 84 Zeichen

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

Eingabe und Ausgabe erfolgen in Form einer durch Leerzeichen getrennten Liste, z "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

Verwendet die Windows-1252-Codierung

String-basierte Lösung

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

Laufen Sie wie folgt:

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

Wenn Ihr Terminal auf UTF-8 eingestellt ist, ist dies dasselbe:

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

Optimierungen

• 2 Byte durch Negieren von Zeichenfolgen und Löschen von Zeichenfolgenbegrenzern gespart
• 2 Bytes mit kurzem Drucktag gespeichert

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 Byte

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

Nimmt Eingaben auf $args[0]und -joinfügt sie zusammen mit Kommas zu einem String zusammen. Wir verwenden dann die .Trim()Funktion, die zweimal aufgerufen wird, um zuerst die nachfolgenden und dann die führenden Nullen und Kommas zu entfernen. Wir setzen dann -splitdie Zeichenfolge mit Komma wieder in ein Array.

Alternative Version, ohne Konvertierung
PowerShell, 81 Bytes

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

Da PowerShell keine Funktion zum Trimmen von Arrays hat, definieren wir eine neue Funktion f, die die Hälfte davon für uns erledigt . Die Funktion nimmt $aals Eingabe und durchläuft dann jedes Element mit einer foreach-Schleife|%{...} . Bei jeder Iteration prüfen wir eine Bedingung auf $_ -or $b. Da Ganzzahlen ungleich Null wahr sind, aber $nullfalsch sind (und $b, da sie zuvor nicht definiert wurden, wie $nullfolgt beginnen ), wird dies erst ausgewertet, $truewenn wir unser erstes Element im Array treffen, das nicht Null ist. Dann setzen wir $b=1den aktuellen Wert und fügen ihn $_der Pipeline hinzu. Dies wird dann bis zum Ende des Eingabearrays fortgesetzt, wobei Nullen in der Mitte und das Ende zur Ausgabe hinzugefügt werden, da wir die $bWahrheit gesetzt haben.

Wir kapseln und speichern die Ergebnisse der Schleife wieder in $a. Dann indizieren wir$a in umgekehrter Reihenfolge (dh umkehren des Arrays), was in der Pipeline verbleibt und somit der Rückgabewert der Funktion ist.

Wir rufen die Funktion zweimal auf $args[0] Eingang des Programms auf, um von vorne zu "trimmen", dann wieder von vorne (das ist die Rückseite, da wir umgekehrt haben). Die Reihenfolge bleibt erhalten, da wir zweimal umkehren.

Diese Version spielt ein wenig locker mit den Regeln für ein Eingabearray mit allen Nullen, aber da das Ignorieren von STDERR als gängige Praxis gilt, gibt das Programm zwei (ausführliche) Cannot index into a null arrayFehler an _{(PowerShell-Entsprechung von)} STDERR aus und gibt dann nichts aus.