Étant donné une liste / un tableau non vide contenant uniquement des entiers non négatifs comme celui-ci:

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

Sortez la liste avec les zéros de fin et de tête supprimés.

La sortie pour cela serait:

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

Quelques autres cas de 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]

Victoires de code les plus courtes

Gelée , 2 octets

Code:

t0

Explication:

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

Essayez-le en ligne!

JavaScript (ES6) 43

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

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

Tester

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 octets

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

Avec le tableau entré.

Version plus longue:

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 octets

.sQ0

Démo:

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 octets

Code:

0Û0Ü

Essayez-le en ligne!

Explication:

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

Utilise l'encodage CP-1252.

Rétine, 12 octets

^0 ?

)` 0$

Le saut de ligne arrière est important.

Merci à @Martin Büttner et @FryAmTheEggman pour avoir économisé quelques octets.

Essayez-le en ligne

R, 43 octets

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

ou en lecture / écriture STDIN / STDOUT

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

Ceci trouve le maximum cumulatif à partir de la chaîne de début et de fin (inversée). L' &opérateur convertit ces deux vecteurs en un logique de la même taille que x, (les zéros seront toujours convertis en FALSEet tout le reste en TRUE), de cette façon, il permet de sous-ensemble en xfonction des conditions remplies.

Haskell , 29 octets

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

Mathematica 34 27 octets

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

Cela applique à plusieurs reprises des règles de remplacement jusqu'à ce qu'une telle action ne fournisse pas de nouvelle sortie. 7 octets économisés grâce à Alephalpha.

La première règle supprime un zéro au début; la deuxième règle supprime un zéro à la fin du tableau.

05AB1E, 4 octets

0Û0Ü

Coupe essentiellement les zéros de début puis de fin de l'entrée, donnés sous forme de tableau.

Essayez-le en ligne!

Perl, 19 + 1 = 20 octets

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

-pDrapeau requis :

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

Gelée, 10 octets

Uo\U,o\PTị

Cela n'utilise pas la fonction intégrée.

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.

Essayez-le ici .

Perl, 38 octets

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

Exécutez avec perl -p, (3 octets ajoutés pour -p).

Accepte les numéros sur STDIN, un par ligne; émet des numéros sur STDOUT, un par ligne, comme le devrait un utilitaire Unix bien comporté.

Ne traite que les nombres représentés exactement par «0» comme des zéros; il serait possible de prendre en charge d'autres représentations avec quelques octets supplémentaires dans l'expression régulière.

Version plus longue, toujours à exécuter avec -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

Version étendue, montrant les interactions avec l'indicateur -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 octets

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

l est le tableau.

Edit: wah! copie / pâtes échouent. bien sûr, il faut importer Enum, ce qui augmente le nombre d'octets de 12 (ou utiliser Enum.function_name, ce qui le rendra encore plus long).

Vitsy, 13 octets

Vitsy s'améliore lentement ... (Je viens pour toi Jelly. ಠ_ಠ)

1mr1m
D)[X1m]

Cela se termine avec le tableau sur la pile. Pour plus de lisibilité, TryItOnline! le lien que j'ai fourni ci-dessous l'explication produira une liste formatée.

Explication:

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.

Notez que cela lèvera une StackOverflowException pour des entrées déraisonnablement grandes.

TryItOnline!

R, 39 octets

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

Quatre octets de moins que la réponse R de David Arenburg . Cette implémentation trouve le premier et le dernier index dans le tableau qui est supérieur à zéro et renvoie tout dans le tableau entre ces deux indices.

MATL , 9 octets

2:"PtYsg)

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le ici .

Rubis, 49 44 octets

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

Merci à manatwork pour couper 5 octets avec une méthode complètement différente!

C'est juste drople premier élément du tableau, whilec'est 0, inverse le tableau, se répète et, enfin, inverse le tableau pour le remettre dans le bon ordre.

Vim 16 frappes

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

L'entrée doit être tapée par l'utilisateur entre iet esc, et ne compte pas comme une frappe. Cela suppose qu'il y aura au moins un zéro de début et un zéro de fin. Si ce n'est pas une hypothèse valide, nous pouvons utiliser cette version légèrement plus longue: (18 frappes)

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

ES6, 51 octets

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

test défini sur l'index après la dernière valeur non nulle, tandis qu'il fest incrémenté tant que seuls des zéros ont été vus jusqu'à présent.

Perl 6 , 23 octets

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

Usage:

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

Rétine, 11 octets

+`^0 ?| 0$
<empty>

Assez facile. Remplace récursivement les zéros au début et à la fin de la ligne.

Essayez-le en ligne!

JavaScript (ES6), 47 octets

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

Où aest le tableau.

Python, 84 caractères

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 octets

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

L'entrée et la sortie se présentent sous la forme d'une liste délimitée par des espaces, telle que "0 4 1 2 0 1 2 4 0".

Javascript (ES6) 40 octets

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

PHP, 56 54 52 octets

Utilise l'encodage Windows-1252

Solution basée sur les chaînes

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

Courez comme ceci:

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

Si votre terminal est réglé sur UTF-8, c'est la même chose:

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

Tweaks

• Enregistré 2 octets en annulant les chaînes et en supprimant les délimiteurs de chaînes
• Enregistré 2 octets en utilisant une balise d'impression courte

Python 2, 69 67 octets

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

PowerShell, 49 octets

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

Prend l'entrée $args[0]et les -joins avec des virgules pour former une chaîne. Nous utilisons ensuite la .Trim()fonction appelée deux fois pour supprimer d'abord les derniers zéros et les virgules. Nous avons ensuite -splitla chaîne de virgules dans un tableau.

Version alternative, sans utiliser PowerShell de conversion
, 81 octets

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

Étant donné que PowerShell n'a pas de fonction pour couper les tableaux, nous définissons une nouvelle fonction fqui fera la moitié de cela pour nous. La fonction prend $aen entrée, puis parcourt chaque élément avec une boucle foreach |%{...}. A chaque itération, nous vérifions un conditionnel pour $_ -or $b. Étant donné que les entiers non nuls sont véridiques, mais $nullest falsey (et$b , comme ils n'ont pas été définis précédemment, commencent comme $null), cela n'évaluera qu'une $truefois que nous aurons atteint notre premier élément non nul dans le tableau. Nous avons ensuite défini $b=1et ajouté la valeur actuelle $_sur le pipeline. Cela continuera ensuite jusqu'à la fin du tableau d'entrée, avec des zéros au milieu et la fin étant ajoutés à la sortie, puisque nous avons défini la $bvérité.

Nous encapsulons et stockons tous les résultats de la boucle dans $a. Ensuite, nous indexons $adans l'ordre inverse (c'est-à-dire, en inversant le tableau), qui est laissé sur le pipeline et est donc la valeur de retour de la fonction.

Nous appelons la fonction deux fois sur l' $args[0]entrée du programme afin de "rogner" de l'avant, puis de nouveau de l'avant (qui est l'arrière, puisque nous avons inversé). L'ordre est conservé puisque nous inversons deux fois.

Cette version joue un peu avec les règles pour un tableau d'entrée de tous les zéros, mais comme ignorer STDERR est une pratique acceptée, le programme crachera deux Cannot index into a null arrayerreurs (verbeuses) dans _{(l'équivalent de PowerShell)} STDERR, puis ne produira rien.