タスクは簡単です。intの配列を統合します。このアレイの統合は、次のもので構成されています。

• 0のすべてのインスタンスは、配列の最後に移動する必要があります。
• ゼロ以外の整数の間に0があってはなりません。
• すべての非ゼロインデックスは順序を保持する必要があります。

チャレンジ

最小バイト数で配列を統合します。

ランダムな整数を使用して、言語の最大サイズまでのランダムな長さの配列を統合しています。入力はあなたの言語にとって自然な方法かもしれません。

例

入力

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

出力

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

入力

-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

出力

-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

サンプルコード（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バイト

!DQ

説明：

  Q    Input
!D     Sort by logical NOT

ここで試してみてください。

ゼリー、3バイト

¬Ụị

値の論理否定でリストをソートします。オンラインでお試しください！

使い方

¬Ụị    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.

オクターブ、18バイト

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

sort()バイトが多すぎます。論理インデックスを使用します。

イデオンの例。

R、29 23 21バイト

MarcoBreitigが述べたように、関数として提供する必要がない場合は21バイトに短縮できます。

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

以前のバージョン：

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

この関数は、ベクトルを入力として受け取り、入力の否定から生じる論理ベクトルで順序付けします。

元の回答：

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

この関数は入力としてベクトルを取り、c()ゼロ以外の値とゼロ値を連結（）します。

網膜、15

単純な繰り返し正規表現の置換：

+`\b0 (.*)
$1 0

オンラインでお試しください。

ES6、23バイト

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

以前sortは安定していないケースでした。その場合、41バイトが必要でした。

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

Pythonバイトコード（2.7.9）、252バイト、33オペコード、0.0228秒

これは、コンテストがまだ最速のコードコンテストであったときに作成されました

'SourceArray'使用のために呼び出される現在のディレクトリ内のファイルを開きます

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（実際のcodeyビット）

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

または.pycファイルバージョン 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

githubのライブラリを使用して、自分でソースコードをコンパイルしてみてください。コメントを許可するコミットを投稿したばかりなので、最速のコードに関する限りこれがまだ競合していることを願っています;）

とほぼ同等

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バイト

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

反復可能なもの（リスト、タプルなど）として引数を取ります。新しいトリックを教えてくれた@xnorに感謝します！

Matlab：21バイト

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

最初に非ゼロ要素を出力し、次にゼロ要素と連結します

@(a)____ 1つの入力引数を持つ無名関数を作成します a

[___,___] カンマで区切られた括弧内のベクトルを水平方向に連結します

a(a~=0) ベクトルのすべての非ゼロ要素を含むベクトルを返します a

a(a==0) ベクトルのすべての要素がゼロのベクトルを返します a

Haskell、26バイト

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

すべてのゼロ以外の数字の後にすべてゼロが続きます。0リスト内包表記を使用する場合、フィルタリング定数（ここでは）は非常に短いです[0|0<-x]。

Zsh、22バイト

（入力はスクリプト/関数（$@別名$argv配列）に引数として渡され、スペースで区切られたリストとして標準出力に出力され、改行が終了します）

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

• <<< string：here-stringは、$NULLCMDコマンドにstdinとして渡さcatれます（デフォルト）。
• ${@:#0} $@ 要素が0である場合を除きます。
• ${(M)@:#0} 上記の逆

（ここでの他のいくつかの答えのように）入力のゼロはすべて0（no 00nor 0x0nor 36#0）として表現されると仮定しています。

Javascript、52 54 51バイト

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

Mathematica、14バイト

Sort[#,#!=0&]&

APL：8バイト

(⍴a)↑a~0

a〜0はaからゼロを削除します（「aなしの読み取り」）（⍴a）aの元の長さ（「aの形状」を読み取ります）
↑aの元の長さまでゼロなしでaを埋め込みます

http://ngn.github.com/apl/web/index.htmlで試してください

試験データ：a←1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7、78バイト

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

他のJavaエントリが文字列を使用している理由はわかりません。整数配列をフィルタリングする場合は、整数配列を使用するのが最善のようです。これは、2つのインデックスを保持し、残りのスロットをゼロで埋めることにより、入力を変更します。

Common Lisp、46バイト

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

ソート配列ので、各カップルのためのことを（a、b）は、我々が持っている<Bを場合bはゼロです。a <bまたはb <aのいずれでもない場合、ソートは安定しています。要素間の元の順序は保持されます。

私はadjust-arrayとremoveも試しましたが、これは長すぎました：

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

PHP、73 71 70 52 49 48 46バイト-Ismael Miguelに感謝

// 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ユーティリティ、23

grep -v ^0 a
grep ^0 a

入力は、と呼ばれるファイル内の改行で区切られたエントリであると想定していますa。スコアには、このファイル名の+1が含まれます。

Perl 5、26バイト

23プラス3 -an（-E無料）

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

を思い出させてくれたDennisに感謝し-aます。2バイトの節約になります。

CJam、6バイト

{{!}$}

匿名関数。「要素がゼロかどうか」をキーとして使用してソートします。

MATL、7バイト

t~FT#S)

オンラインでお試しください！

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

真剣に、12バイト

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

オンラインでお試しください！

説明：

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バイト

a.sort{$1==0}

Perl6、11バイト

{.sort(!*)}

ブロックを生成します-配列で呼び出すことができます：

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

次のように書く方が自然（かつ短い）です。

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

仕組み：perl6ソートルーチンが1つの引数のみを受け入れるブロックで呼び出された場合、リスト要素はに従ってソートされby($a) cmp by($b)ます。この場合、ブロックはです!*。つまり、whatever演算子の否定です。。

私はそれに気づく：

• 質問の例は、メソッドを提供するクラスです。読み込みに必要な定型文は含まれません
• タスクの説明は印刷を必要とせず、例が印刷するという事実を除いて、配列が返される可能性があることを意味します

TeX（プレーン形式）、160バイト

作る 0た文字アクティブ（で、それはコマンドとして解釈プロセスを作成する）、そして文字をスキップし、カウンタをインクリメントし、そのコマンドを定義します。文字列の最後に、カウントされた数だけゼロを出力します。

これを名前を付けて保存zero.texし、次のコマンドを使用してコマンドラインから入力します。

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

（わかりやすくするために改行が追加されました）

J、4バイト

/:0=

説明：

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

Jのソート関数は、仕様によって安定していることが保証されています。

代替ソリューション、6バイト：

#{.*#+

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

わら、30 29バイト

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

CP437エンコードを使用する

説明

<:([^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

オンラインでお試しください！（追加されたコードは、すべてのテストケースをテストするためのものです）

JavaScript ES6、16バイト

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

Firefoxで動作します

ルビー、25バイト

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

オンラインでお試しください！

05AB1E、15 14バイト

コード：

ED0¢r0KR`rFZ}|

説明：

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エンコードを使用します。このような配列を取ります：

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