Görev basittir: bir dizi diziyi birleştirmek. Bu diziyi birleştirmek aşağıdakilerden oluşur:

• Tüm 0 örneklerinin dizinin sonuna taşınması gerekir.
• Sıfır olmayan tamsayılar arasında 0 olmamalıdır.
• Tüm sıfır olmayan endeksler sıralarını korumalıdır.

Meydan okuma

Bir diziyi en az bayt miktarında birleştirin.

Rasgele tamsayılarla dilinizin maksimumuna kadar bir boyuta sahip bir rasgele uzunluk dizisini birleştiriyorsunuz. Giriş, diliniz için herhangi bir doğal yol olabilir.

Örnekler

Giriş

0 5 8 8 3 5 1 6 8 4 0 3 7 5 6 4 4 7 5 6 7 4 4 9 1 0 5 7 9 3 0 2 2 4 3 0 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 0 5 0 6 0 3

Çıktı

5 8 8 3 5 1 6 8 4 3 7 5 6 4 4 7 5 6 7 4 4 9 1 5 7 9 3 2 2 4 3 4 8 7 3 1 4 7 5 1 2 1 8 7 8 7 7 2 6 3 1 2 8 5 1 4 2 5 6 3 0 0 0 0 0 0 0 0

Giriş

-1 -7 -6 5 1 -5 -2 7 -3 -8 0 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 0 -5 -7 3 8 1 1 3 -3 -2 -2 0 -7 0 -4 8 6 -3 6 0 5 3 2 2 2 -2 -7 -3 9 -1 6 0 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 0 3 3 7 -1 -5 1 -3 4 -7 0 3 2 -2 7 -3 0 0 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7

Çıktı

-1 -7 -6 5 1 -5 -2 7 -3 -8 8 9 1 -8 -1 6 -4 1 -2 1 -7 5 4 -6 7 -3 9 8 3 -1 -5 -7 3 8 1 1 3 -3 -2 -2 -7 -4 8 6 -3 6 5 3 2 2 2 -2 -7 -3 9 -1 6 6 -7 9 4 -2 8 -8 -4 1 -8 4 3 7 3 5 1 3 3 7 -1 -5 1 -3 4 -7 3 2 -2 7 -3 2 -5 8 -3 -2 -7 -5 7 -3 -9 -7 5 8 -3 9 6 7 -2 4 7 0 0 0 0 0 0 0 0 0 0

Örnek Kod (Java)

public class Consolidate {
    public static void main(String[] args) throws Exception {
        int[] toConsolidate = new int[args.length];
        for (int i=0; i<args.length; i++){
            toConsolidate[i]=Integer.parseInt(args[i]);
        }
        for (int i=0; i<toConsolidate.length; i++) {
            for (int k=0; k<toConsolidate.length-1; k++) {
                if (toConsolidate[k] == 0){
                    toConsolidate[k] = toConsolidate[k+1];
                    toConsolidate[k+1] = 0;
                }
            }
        }
        for (int i:toConsolidate)
            System.out.print(i+" ");
    }
}

Pyth, 3 bayt

!DQ

Açıklama:

  Q    Input
!D     Sort by logical NOT

Burada dene .

Jöle, 3 bayt

¬Ụị

Listeyi, değerlerinin mantıksal NOTuna göre sıralar. Çevrimiçi deneyin!

Nasıl çalışır

¬Ụị    Main link. Input: A (list)

¬      Compute the logical NOT of each element of A.
 Ụ     Grade up; sort the resulting list's indices by their corresponding values.
  ị    Retrieve the elements of A at that indices.

Octave, 18 bayt

@(A)[A(~~A) A(~A)]

sort()çok fazla bayt alır. Ben sadece mantıksal indeksleme kullanacağım.

İdeone Örnekleri .

R, 29 23 21 bayt

MarcoBreitig tarafından belirtildiği gibi, bir işlev olarak sağlamamız gerekmiyorsa 21 bayta kısaltabiliriz:

x=scan();x[order(!x)]

Önceki sürümler:

function(x)x[order(!x)]

İşlev bir vektörü girdi olarak alır ve girişi olumsuzlamaktan kaynaklanan mantıksal vektör tarafından sıralanır.

Orijinal cevap:

function(x)c(x[x!=0],x[x==0])

İşlev giriş olarak bir vektör alır ve concatenates ( c()) sıfır olmayan değerleri ve ardından sıfır değerleri.

Retina , 15

Basit tekrarlanan regex ikamesi:

+`\b0 (.*)
$1 0

Çevrimiçi deneyin.

ES6, 23 bayt

a=>a.sort((x,y)=>!x-!y)

Eskiden sortkararlı olmayan durumdu, bu durumda 41 bayta ihtiyacınız vardı:

a=>a.filter(x=>x).concat(a.filter(x=>!x))

Python bayt kodu (2.7.9), 252 bayt, 33 opcod, 0.0228 saniye

Bu, yarışma hala en hızlı kod yarışması olduğunda yapıldı

Geçerli dizinde 'SourceArray'kullanmak üzere çağrılan bir dosyayı açar.

LOAD_CONST          ''
STORE_FAST          no_zeroes#  no_zeroes = ''

LOAD_NAME           open
LOAD_CONST          'SourceArray'
CALL_FUNCTION       0,1#  open('SourceArray')
LOAD_ATTR           read
CALL_FUNCTION       0,0#  .read()

LOAD_ATTR           split
CALL_FUNCTION       0,0#  .split()

DUP_TOP
DUP_TOP             #Start if
BUILD_LIST          0
COMPARE_OP          ==
POP_JUMP_IF_TRUE    35#  if list == [], GOTO 35
LOAD_ATTR           pop
LOAD_CONST          0
CALL_FUNCTION       0,1#  list.pop(0)
DUP_TOP
LOAD_CONST          '0'
COMPARE_OP          ==
POP_JUMP_IF_TRUE    28#  if list.pop(0) == '0', GOTO 28
PRINT_ITEM          #  print list.pop(0)
JUMP_ABSOLUTE       13

POP_TOP
LOAD_CONST          '0%_'#  '0 '
LOAD_FAST           no_zeroes
INPLACE_ADD
STORE_FAST          no_zeroes#  no_zeroes = no_zeroes + '0 '
JUMP_ABSOLUTE       13

LOAD_FAST           no_zeroes
PRINT_ITEM          #  print no_zeroes

LOAD_CONST          None
RETURN_VALUE

co_code(Gerçek codey bit)

'd\x01\x00}\x00\x00\te\x00\x00\x83\x00\x00\tj\x01\x00\x83\x00\x00\t\x04\x04g\x00\x00k\x02\x00sG\x00j\x02\x00d\x02\x00\x83\x01\x00\x04d\x03\x00k\x02\x00s8\x00Gq\x15\x00\t\x01d\x04\x00|\x00\x007}\x00\x00q\x15\x00\t|\x00\x00G\td\x00\x00S'

Veya bir .pyc dosya sürümü 03F3

03 F3 0D 0A 40 FD B0 56 63 00 00 00 00 01 00 00 00 03 00 00 00 00 00 00 00 73 59 00 00 00 64 01 00 7D 00 00 09 65 00 00 64 02 00 83 01 00 6A 01 00 83 00 00 09 6A 02 00 83 00 00 09 04 04 67 00 00 6B 02 00 73 50 00 6A 03 00 64 03 00 83 01 00 04 64 04 00 6B 02 00 73 41 00 47 71 1E 00 09 01 64 05 00 7C 00 00 37 7D 00 00 71 1E 00 09 7C 00 00 47 09 64 00 00 53 28 06 00 00 00 4E 74 00 00 00 00 74 0B 00 00 00 53 6F 75 72 63 65 41 72 72 61 79 69 00 00 00 00 74 01 00 00 00 30 73 02 00 00 00 30 20 28 04 00 00 00 74 04 00 00 00 6F 70 65 6E 74 04 00 00 00 72 65 61 64 74 05 00 00 00 73 70 6C 69 74 74 03 00 00 00 70 6F 70 28 01 00 00 00 74 09 00 00 00 6E 6F 5F 7A 65 72 6F 65 73 28 00 00 00 00 28 00 00 00 00 74 09 00 00 00 70 79 6B 65 5F 63 6F 64 65 52 08 00 00 00 01 00 00 00 52 00 00 00 00

Kaynak kodumu kendim github kütüphanemdeki kütüphaneyi kullanarak derlemeye çalışabilirsiniz . Ben sadece yorumlara izin veren bir taahhütte bulundum, bu yüzden en hızlı kod gittiği sürece hala rekabet edeceğini umuyorum ;)

Kabaca eşdeğer

no_zeroes = ''
unamed_variable = open('SourceArray').read().split()
while unamed_variable != []:
    unamed_variable_2 = unamed_variable.pop()
    if unamed_variable_2 == '0':
        no_zeroes += '0 '
    else:
        print unamed_variable_2,
print no_zeroes,

Python, 32 bayt

lambda x:sorted(x,key=0..__eq__)

Herhangi bir yinelenebilir (argüman, liste vb.) Argümanı alır. Bana yeni bir numara öğrettiğin için @xnor'a teşekkürler!

Matlab: 21 bayt

@(a)[a(a~=0),a(a==0)]

Önce sıfır olmayan öğeleri yazdırır, sonra sıfır öğeleriyle birleştirir

@(a)____ bir giriş argümanıyla anonim bir fonksiyon yarat a

[___,___] virgülle ayırarak, parantez içindeki yatay vektörleri birleştirir

a(a~=0) vektörün sıfır olmayan unsurları ile vektörü döndürür a

a(a==0) vektörün tüm sıfır öğelerini içeren vektörü döndürür a

Haskell, 26 bayt

f x=filter(/=0)x++[0|0<-x]

Sıfır olmayan tüm sayıları ve ardından sıfırları al. (Burada: sabitleri Filtreleme 0) bir liste anlama kullanırken oldukça kısadır: [0|0<-x].

Zsh, 22 bayt

(girdi komut dosyasına / işleve argümanlar olarak iletildi ( $@aka $argvarray), stdout'ta boşlukla ayrılmış liste olarak çıktı, newline sona erdi)

<<<${@:#0}\ ${(M)@:#0}

• <<< string: here-string here $NULLCMDkomutuna stdin olarak geçer ( catvarsayılan olarak).
• ${@:#0} $@ 0 dışında öğeler.
• ${(M)@:#0} yukarıdakilerin tersi

Bu, (burada diğer birkaç cevap gibi) girdideki sıfırların hepsinin 0( 00ne 0x0de ne de 36#0) ifade edildiğini varsayar .

Javascript, 52 54 51 bayt

s=>s.replace(/\b0 /g,x=>++i&&'',i=0)+' 0'.repeat(i)

Mathematica, 14 bayt

Sort[#,#!=0&]&

APL: 8 bayt

(⍴a)↑a~0

a ~ 0 sıfırları ("0 a olmadan oku")
(⍴a) orjinal uzunluğu ("oku" şeklini ")
↑ sıfırlayın

Http://ngn.github.com/apl/web/index.html adresinde deneyin.

Test verileri: bir ← 1 0 1 2 3 4 0 1 0 0 0 0 0 1 2 3 4 5

Java 7, 78 bayt

void g(int[]a){int c=0;for(int o:a)a[o==0?c:c++]=o;for(;c<a.length;a[c++]=0);}

Diğer Java girişlerinin neden dizeleri kullandığından emin değilim. Bir tamsayı dizisini filtrelemek istiyorsanız, bir tamsayı dizisi kullanmak en iyisidir. Bu, girişi iki endeks tutarak ve ardından kalan yuvaları sıfırlarla doldurarak girişi değiştirir.

Ortak Lisp, 46 bayt

(lambda(a)(stable-sort a(lambda(_ b)(= 0 b))))

Diziyi, her çift için (a, b) , b sıfır ise , <b olacak şekilde sıralayın . Ne bir <b veya b <a değilse, sıralama kararlıdır: elemanlar arasındaki orijinal sıra korunur.

Adjust-array ve remove ile de denedim , ancak bu çok uzundu:

(lambda(a)(adjust-array(remove 0 a)(length a):initial-element 0))

PHP, 73 71 70 52 49 48 46 bayt - Ismael Miguel sayesinde BÜYÜK

// Assuming
$a = array(4,8,6,1,0,8,0,0,0,0,0,-4,'-5',-1,564,0);

// Produces a notice-level error
foreach($a as$v)$v?print"$v ":$b.="0 ";echo$b;

Bash + GNU yardımcı programları, 23

grep -v ^0 a
grep ^0 a

Girişin, çağrılan bir dosyada yeni satırlarla ayrılmış girişler olduğunu varsayar a. Puan, bu dosya adı için +1 içerir.

Perl 5, 26 bayt

23 artı üç kişi için -an( -Eücretsiz)

say for sort{!$a-!$b}@F

Bana hatırlattığın için iki bayt kurtardığın için teşekkürler Dennis-a .

CJam, 6 bayt

{{!}$}

Anonim bir işlev. Anahtar olarak “bir elemanın sıfır olup olmadığını” kullanarak sıralayın.

MATL , 7 bayt

t~FT#S)

Çevrimiçi deneyin!

t      % input array. Duplicate
~      % logical negate: nonzero values become false, zeros become true
FT#S   % sort (false, then true) and output a vector with the indices of the sorting
)      % apply that vector of indices to original array

Cidden, 12 bayt

4,n`Y`M@░)░+

Çevrimiçi deneyin!

Açıklama:

4,n`Y`M@░)░+
4,n           push 4 copies of input
   `Y`M       map logical negate
       @░)    filter (take zeroes) and push to bottom of stack
          ░   filter (take non-zeroes)
           +  append zeroes

Swift , 13 bayt

a.sort{$1==0}

Perl6, 11 bayt

{.sort(!*)}

Bir dizi oluşturur - bir dizi çağrılabilir:

{.sort(!*)}.([1,2,0,3]).say

Yazması daha doğal (ve daha kısa) olsa da:

[1,2,0,3].sort(!*).say

Nasıl çalışır: perl6 sıralama yordamı yalnızca bir argümanı kabul eden bir blokla çağrılırsa, liste öğeleri buna göre sıralanır by($a) cmp by($b). Bu durumda, blok!* hangi operatörün bir ihmali olduğu anlamına gelir .

Bunu farkettim:

• Sorudaki örnek, okumak için gerekli olan kazan plakasını içermeyen bir yöntem sağlayan bir sınıftır.
• Görevin açıklaması yazdırmayı gerektirmez ve örneğin yazdırması dışında bir dizinin döndürülebileceği anlamına gelir

TeX (Düz format), 160 bayt

Yap 0, sonra karakteri atlayıp bir sayaç artırmak için bu komutu tanımlar (olduğunu, bir komut olarak yorumlayıcı işlemi yapmak) aktif bir karakter. Dizenin sonunda, sayıldığı kadar sıfır yazdırın.

Bunu farklı kaydedin zero.texve girişi bu komutla komut satırından verin:

pdftex "\def\I{0 1 0 3 2 0 0 8 0 5 0 1 9 4}\input zero"

\def\I{}\newcount\Z\def\L{\loop\advance\Z by-1\ifnum\Z>00 \repeat}
\begingroup\catcode`\013 \def0{\advance\Z by1}
\scantokens\expandafter{\I\empty}\endgroup\L\bye

(Netlik için Newlines eklendi)

J, 4 bayt

/:0=

Açıklama:

/:      NB. upward sort on
  0=    NB. equality to zero

J'deki sıralama fonksiyonunun teknik özelliklere göre kararlıdır.

Alternatif çözüm, 6 bayt:

#{.*#+

   *#+  NB. replicate each item by its sign (removing zeroes)
#{.     NB. take as many items from this as the original list had
        NB.  (taking more items than there are in a list results in extra zeroes)

Straw , 30 29 bayt

<:([^0 ])()/,0()/ +,+( +) /}>

CP437 kodlamasını kullanın

açıklama

<:([^0 ])()/,0()/ +,+( +) /}>
<                             Take input
 :                            Duplicate
  ([^0 ])()/                  Remove every character that is not a 0 or a space
            ,                 Swap the two items on the top of the stack
             0()/             Remove every 0 on the top of the stack
                  +           Push a space and concatenate
                   ,          Swap
                    +         Concatenate
                     ( +) /   Remove duplicate spaces
                           }  Get the 'tail' of the string
                            > Output

Çevrimiçi deneyin! (Eklenen kod tüm test durumlarını test etmektir)

JavaScript ES6, 16 bayt

x=>x.sort(t=>!t)

Firefox'ta çalışıyor

Yakut , 25 bayt

->a{a-[0]+[0]*a.count(0)}

Çevrimiçi deneyin!

05AB1E , 15 14 bayt

Kod:

ED0¢r0KR`rFZ}|

Açıklama:

E               # Evaluate input
 D              # Duplicate top of the stack
  0¢            # Count zeroes
    r           # Reverse stack
     0K         # Delete all zeroes
       R        # Reverse top of the stack
        `       # Flatten
         r      # Reverse stack
          FZ}   # For N in range(amount zeroes): push zero
             |  # Print full stack

CP-1252 kodlamasını kullanır. Bunun gibi bir dizi alır:

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