Bunun gibi yalnızca negatif olmayan tam sayılar içeren boş olmayan bir liste / dizi verilirse:

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

Listeyi sondaki ve çıkarılan sıfırlarla kaldırılmış olarak çıkarın.

Bunun için çıktı şöyle olurdu:

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

Diğer bazı test durumları:

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

En kısa kod kazanır

Jöle , 2 bayt

Kod:

t0

Açıklama:

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

Çevrimiçi deneyin!

JavaScript (ES6) 43

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

Daha az golf oynadı

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
}

Ölçek

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 bayt

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

Girilen dizi ile.

Daha uzun versiyon:

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 bayt

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

Gönderen Pyth enrev-doc.txt :

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

05AB1E , 4 bayt

Kod:

0Û0Ü

Çevrimiçi deneyin!

Açıklama:

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

CP-1252 kodlamasını kullanır.

Retina, 12 bayt

^0 ?

)` 0$

Sondaki satır besleme kayda değerdir.

Sayesinde @Martin Büttner ve @FryAmTheEggmanBirkaç byte tasarruf .

Çevrimiçi deneyin

R, 43 bayt

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

veya STDIN / STDOUT oku / yaz olarak

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

Bu, kümülatif maksimumu baştan ve sondan (ters) dize olarak bulur. &Gibi, operatör aynı boyutta mantıksal birine bu iki vektör dönüştürür x(sıfır zaman dönüştürülmüş olur, FALSEbaşka ve her şey TRUE), bunun mümkün kılan bu şekilde gelen alt kümesi için xbir araya koşullara göre.

Haskell , 29 bayt

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

Mathematica 34 27 bayt

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

Bu işlem, yeni bir çıktı sağlamada başarısız olana kadar sürekli olarak değiştirme kuralları uygular. Halep sayesinde 7 bayt kurtarıldı.

İlk kural başlangıçta bir sıfır siler; ikinci kural dizinin sonundaki sıfırı siler.

05AB1E, 4 bayt

0Û0Ü

Temelde öncül kırpma, sonra bir dizi olarak verilen girişin sıfırlarını takip eder.

Çevrimiçi deneyin!

Perl, 19 + 1 = 20 bayt

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

-pBayrak gerektirir :

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

Jöle, 10 bayt

Uo\U,o\PTị

Bu yerleşik kullanmaz.

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.

Burada dene .

Perl, 38 bayt

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

Çalıştır perl -p, (3 bayt için eklendi -p).

Her satırda bir tane olmak üzere STDIN üzerindeki sayıları kabul eder; STDOUT'a, her bir satır için bir tane olmak üzere sayıları yayar;

Yalnızca '0' ile temsil edilen sayıları sıfır olarak kabul eder; regex'te birkaç byte ile başka gösterimleri desteklemek mümkün olacaktır.

Daha uzun sürüm, hala çalıştırılmak üzere -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

Genişletilmiş sürüm, -p flag ile etkileşimleri gösterir:

# 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

İksir, 77 bayt

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

Ben dizi.

Düzenleme: wah! kopyala / makarna başarısız. Elbette kişi bayt sayısını 12'ye yükselten Enum almak zorunda (ya da daha da uzun hale getirecek Enum.function_name kullanın).

Vitsy, 13 bayt

Vitsy yavaş yavaş iyileşiyor ... (Senin için geliyorum Jelly. ಠ_ಠ)

1mr1m
D)[X1m]

Bu, yığındaki dizi ile çıkar. Okunabilirlik için TryItOnline! açıklamanın altında sağladığım bağlantı, biçimlendirilmiş bir liste çıkarır.

Açıklama:

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.

Bunun makul olmayan büyük girişler için bir StackOverflowException vereceğini unutmayın.

TryItOnline!

R, 39 bayt

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

David Arenburg'un R cevabından dört byte kısa . Bu uygulama dizideki ilk ve son dizini sıfırdan büyük olanı bulur ve dizideki her şeyi bu iki dizin arasında döndürür.

MATL , 9 bayt

2:"PtYsg)

Çevrimiçi deneyin!

açıklama

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 bayt

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

Burada dene .

Ruby, 49 44 bayt

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

Tamamen farklı bir yöntemle 5 byte'lık doğrama işlemine teşekkürler !

Bu sadece 0 dropdizisinin ilk elemanıdır, diziyi whiletersine çevirir, tekrarlar ve sonunda diziyi uygun sıraya döndürmek için tersine çevirir.

Vim 16 Tuş vuruşları

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

Girdi arasındaki kullanıcı tarafından yazılan edilecek ive escve bir tuş olarak sayılmaz. Bu, en az bir lider ve bir de sıfır sıfır olacağını varsayar. Bu geçerli bir varsayım değilse, bu biraz daha uzun versiyonunu kullanabiliriz: (18 Keystrokes)

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

ES6, 51 bayt

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

tson sıfır olmayan değerden sonra endekse ayarlanır, ancak fşimdiye kadar yalnızca sıfır göründüğü sürece artırılır.

Perl 6 , 23 bayt

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

Kullanımı:

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

+`^0 ?| 0$
<empty>

Oldukça basit. Satır başında ve sonunda sıfırları özyinelemeli olarak değiştirir.

Çevrimiçi deneyin!

JavaScript (ES6), 47 bayt

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

aDizi nerede ?

Python, 84 characters

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

Input and output are in the form of a space-delimited list, such as "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

Uses Windows-1252 encoding

String based solution

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

Run like this:

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

If your terminal is set to UTF-8, this is the same:

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

Tweaks

• Saved 2 bytes by negating strings and dropping string delimiters
• Saved 2 bytes by using short print tag

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

Takes input $args[0] and -joins them together with commas to form a string. We then use the .Trim() function called twice to remove first the trailing and then the leading zeros and commas. We then -split the string on commas back into an array.

Alternate version, without using conversion
PowerShell, 81 bytes

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

Since PowerShell doesn't have a function to trim arrays, we define a new function f that will do half of this for us. The function takes $a as input, then loops through each item with a foreach loop |%{...}. Each iteration, we check a conditional for $_ -or $b. Since non-zero integers are truthy, but $null is falsey (and $b, being not previously defined, starts as $null), this will only evaluate to $true once we hit our first non-zero element in the array. We then set $b=1 and add the current value $_ onto the pipeline. That will then continue through to the end of the input array, with zeros in the middle and the end getting added onto the output, since we've set $b truthy.

We encapsulate and store the results of the loop all back into $a. Then, we index $a in reverse order (i.e., reversing the array), which is left on the pipeline and thus is the function's return value.

We call the function twice on the $args[0] input to the program in order to "trim" from the front, then the front again (which is the back, since we reversed). The order is preserved since we're reversing twice.

This version plays a little loose with the rules for an input array of all zeros, but since ignoring STDERR is accepted practice, the program will spit out two (verbose) Cannot index into a null array errors to _{(PowerShell's equivalent of)} STDERR and then output nothing.