Nhiệm vụ rất đơn giản: hợp nhất một mảng ints. Hợp nhất mảng này bao gồm:

• Tất cả các trường hợp của 0 cần phải được di chuyển đến cuối mảng.
• Không nên có 0 nào giữa các số nguyên khác không.
• Tất cả các chỉ số khác không nên giữ lại thứ tự của chúng.

Thử thách

Hợp nhất một mảng với số lượng byte ít nhất.

Bạn đang hợp nhất một mảng có độ dài ngẫu nhiên với kích thước tối đa bằng ngôn ngữ của bạn với các số nguyên ngẫu nhiên. Đầu vào có thể là bất kỳ cách tự nhiên cho ngôn ngữ của bạn.

Ví dụ

Đầu vào

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

Đầu ra

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

Đầu vào

-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

Đầu ra

-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

Mã ví dụ (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+" ");
    }
}

Bình thường, 3 byte

!DQ

Giải trình:

  Q    Input
!D     Sort by logical NOT

Hãy thử nó ở đây .

Thạch, 3 byte

¬Ụị

Sắp xếp danh sách theo logic KHÔNG của các giá trị của nó. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

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

sort()mất quá nhiều byte. Tôi sẽ chỉ sử dụng lập chỉ mục logic.

Ví dụ về ideone .

R, 29 23 21 byte

Theo ghi nhận của MarcoBreitig, chúng ta có thể rút ngắn nó xuống còn 21 byte nếu chúng ta không cần cung cấp nó dưới dạng hàm:

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

Những phiên bản trước:

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

Hàm lấy một vectơ làm đầu vào và thứ tự bởi vectơ logic xuất phát từ việc phủ định đầu vào.

Câu trả lời gốc:

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

Hàm lấy một vectơ làm đầu vào và concatenates ( c()) các giá trị khác không và sau đó là các giá trị 0.

Võng mạc , 15

Thay thế regex đơn giản lặp lại:

+`\b0 (.*)
$1 0

Hãy thử trực tuyến.

ES6, 23 byte

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

Nó từng là trường hợp sortkhông ổn định, trong trường hợp đó bạn cần 41 byte:

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

Mã byte Python (2.7.9), 252 byte, 33 opcodes, 0.0228 giây

Điều này được xây dựng khi cuộc thi vẫn là cuộc thi có mã nhanh nhất

Mở một tệp trong thư mục hiện tại được gọi 'SourceArray'để sử dụng

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

Các co_code(Bit codey thực tế)

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

Hoặc phiên bản tệp .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

Bạn có thể thử tự biên dịch mã nguồn của tôi bằng thư viện của tôi trên github. Tôi vừa đăng một cam kết cho phép bình luận vì vậy tôi hy vọng điều này vẫn đang cạnh tranh khi có mã nhanh nhất ;)

Tương đương với

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 byte

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

Đưa ra đối số như bất kỳ lần lặp nào (danh sách, tuple, v.v.). Cảm ơn @xnor đã dạy tôi một mẹo mới!

Matlab: 21 byte

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

Trước tiên, in các phần tử khác không, sau đó ghép các phần tử bằng 0

@(a)____ tạo một hàm ẩn danh với một đối số đầu vào a

[___,___] nối các vectơ theo chiều ngang trong ngoặc, cách nhau bằng dấu phẩy

a(a~=0) trả về vector với tất cả các phần tử khác của vectơ a

a(a==0) trả về vectơ với tất cả các phần tử bằng không của vectơ a

Haskell, 26 byte

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

Lấy tất cả các số khác không, theo sau là tất cả các số không. Các hằng số lọc (ở đây 0:) khá ngắn khi sử dụng cách hiểu danh sách : [0|0<-x].

Zsh, 22 byte

(đầu vào được chuyển dưới dạng đối số cho tập lệnh / hàm ( $@còn gọi là $argvmảng), đầu ra trên thiết bị xuất chuẩn dưới dạng danh sách được phân tách bằng dấu cách, dòng mới kết thúc)

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

• <<< string: here-string ở đây được chuyển dưới dạng stdin cho $NULLCMDlệnh ( cattheo mặc định).
• ${@:#0} $@ ngoại trừ các yếu tố là 0.
• ${(M)@:#0} ngược lại ở trên

Điều đó giả định (giống như một số câu trả lời khác ở đây) rằng các số 0 trong đầu vào đều được thể hiện dưới dạng 0(không 00cũng 0x0không phải 36#0).

Javascript, 52 54 51 byte

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

Toán học, 14 byte

Sort[#,#!=0&]&

APL: 8 byte

(⍴a)↑a~0

a ~ 0 loại bỏ các số không từ một (đọc "a không có 0")
(⍴a) chiều dài ban đầu của một (đọc "hình dạng của một")
↑ pad a không có số không đến độ dài ban đầu

Hãy dùng thử trong http://ngn.github.com/apl/web/index.html

Dữ liệu kiểm tra: a ← 1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7, 78 byte

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

Tôi không chắc tại sao các mục Java khác lại sử dụng chuỗi. Nếu bạn muốn lọc một mảng số nguyên, có vẻ tốt nhất là sử dụng một mảng số nguyên. Điều này sửa đổi đầu vào tại chỗ bằng cách giữ hai chỉ số, sau đó chỉ cần điền vào các vị trí còn lại bằng số không.

Lisp thông thường, 46 byte

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

Sắp xếp mảng sao cho với mỗi cặp vợ chồng (a, b) , ta có <b nếu b bằng 0. Khi không có <b hoặc b <a , sắp xếp ổn định: thứ tự ban đầu giữa các phần tử được giữ lại.

Tôi cũng đã thử với mảng điều chỉnh và loại bỏ , nhưng điều này quá dài:

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

PHP, 73 71 70 52 49 48 46 byte - LỚN nhờ 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;

Tiện ích Bash + GNU, 23

grep -v ^0 a
grep ^0 a

Giả sử đầu vào là các mục được phân tách bằng dòng mới trong một tệp được gọi a. Điểm bao gồm +1 cho tên tệp này.

Perl 5, 26 byte

23 cộng ba cho -an( -Emiễn phí)

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

Cảm ơn Dennis đã nhắc nhở tôi -a, tiết kiệm hai byte.

CJam, 6 byte

{{!}$}

Một chức năng ẩn danh. Sắp xếp bằng cách sử dụng một phần tử có hay không một phần tử bằng 0.

MATL , 7 byte

t~FT#S)

Hãy thử trực tuyến!

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

Nghiêm túc, 12 byte

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

Hãy thử trực tuyến!

Giải trình:

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 byte

a.sort{$1==0}

Perl6, 11 byte

{.sort(!*)}

Tạo một Khối - có thể được gọi trên một mảng:

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

Mặc dù nó sẽ tự nhiên hơn (và ngắn hơn) để viết:

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

Cách thức hoạt động: nếu thường trình sắp xếp perl6 được gọi với một khối chỉ chấp nhận một đối số, các thành phần danh sách được sắp xếp theo by($a) cmp by($b). Trong trường hợp này, khối là !*, tức là phủ định của toán tử bất kỳ .

Tôi nhận thấy rằng:

• Ví dụ trong câu hỏi là một lớp cung cấp một phương thức, không bao gồm các mẫu soạn sẵn để đọc trong
• Mô tả của tác vụ không yêu cầu in và, ngoại trừ thực tế là ví dụ in, ngụ ý rằng một mảng có thể được trả về

TeX (Định dạng đơn giản), 160 byte

Làm cái 0 ký tự hoạt động (nghĩa là làm cho trình thông dịch xử lý nó như một lệnh), sau đó xác định lệnh đó để bỏ qua ký tự và tăng bộ đếm. Ở cuối chuỗi, in càng nhiều số không được tính.

Lưu cái này dưới dạng zero.texvà cung cấp đầu vào thông qua dòng lệnh bằng lệnh này:

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

(Dòng mới được thêm vào cho rõ ràng)

J, 4 byte

/:0=

Giải trình:

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

Hàm sort trong J được đảm bảo ổn định theo đặc tả.

Giải pháp thay thế, 6 byte:

#{.*#+

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

Rơm , 30 29 byte

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

Sử dụng mã hóa CP437

Giải trình

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

Hãy thử trực tuyến! (Mã được thêm vào là để kiểm tra tất cả các trường hợp thử nghiệm)

JavaScript ES6, 16 byte

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

Hoạt động trên firefox

Ruby , 25 byte

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

Hãy thử trực tuyến!

05AB1E , 15 14 byte

Mã số:

ED0¢r0KR`rFZ}|

Giải trình:

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

Sử dụng mã hóa CP-1252. Có một mảng như thế này:

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