작업은 간단합니다. int 배열을 통합하십시오. 이 배열을 통합하면 다음과 같이 구성됩니다.

• 0의 모든 인스턴스는 배열의 끝으로 이동해야합니다.
• 0이 아닌 정수 사이에는 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

예제 코드 (자바)

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 바이트

¬Ụị

값의 논리 NOT을 기준으로 목록을 정렬합니다. 온라인으로 사용해보십시오!

작동 원리

¬Ụị    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()0이 아닌 값을 연결 한 다음 0을 연결합니다 ( ).

망막 , 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))

파이썬 바이트 코드 (2.7.9), 252 바이트, 33 개의 opcodes, 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,

파이썬, 32 바이트

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

반복 가능한 (리스트, 튜플 등) 인수를 취합니다. 새로운 트릭을 가르쳐 준 @xnor에게 감사드립니다!

MATLAB : 21 바이트

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

0이 아닌 요소를 먼저 인쇄 한 다음 0 개의 요소와 연결

@(a)____ 하나의 입력 인수로 익명 함수를 만듭니다. a

[___,___] 괄호 안에 쉼표로 구분 된 가로 벡터를 연결

a(a~=0) 0이 아닌 모든 벡터 요소를 가진 벡터를 반환 a

a(a==0) 벡터의 모든 0 요소를 가진 벡터를 반환 a

하스켈, 26 바이트

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

0이 아닌 모든 숫자와 0을 모두 취하십시오. 0목록 이해 :를 사용할 때 필터링 상수 (여기 :) 는 매우 짧습니다 [0|0<-x].

Zsh, 22 바이트

(입력은 스크립트 / 함수 ( $@일명 $argv배열)에 인수로 전달되고 , 공백으로 분리 된 목록으로 줄 바꿈으로 줄 바꿈으로 종료 됨)

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

• <<< string: here-string here은 stdin으로 $NULLCMD명령에 전달되었습니다 ( cat기본적으로).
• ${@:#0} $@ 요소가 0 인 것을 제외하고.
• ${(M)@:#0} 위의 반대

입력에서 제로 모두로 표시됩니다 (여기에 몇 가지 다른 답변처럼) 가정 그 0(아무 00도 0x0아니다 36#0).

자바 스크립트, 52 54 51 바이트

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

수학, 14 바이트

Sort[#,#!=0&]&

APL : 8 바이트

(⍴a)↑a~0

a ~ 0 a에서 0을 제거합니다 ( "0없이"a 읽기)
(⍴a) 원래 길이 ( "a의 모양"읽기)
A와 0이 붙지 않는 ↑ 패드 (A)는 원래 길이의

http://ngn.github.com/apl/web/index.html 에서 사용해보십시오

테스트 데이터 : a ← 1012 34 1 0 3 3 5

자바 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 항목이 문자열을 사용하는 이유를 잘 모르겠습니다. 정수 배열을 필터링하려면 정수 배열을 사용하는 것이 가장 좋습니다. 두 개의 인덱스를 유지 한 다음 나머지 슬롯을 0으로 채워서 입력을 수정합니다.

공통 리스프, 46 바이트

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

각 커플 (a, b) 에 대해 b 가 0 인 경우 a <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;

배쉬 + GNU 유틸리티, 23

grep -v ^0 a
grep ^0 a

input이 파일에서 줄 바꿈으로 구분 된 항목이라고 가정 a합니다. 이 파일 이름에 +1이 포함됩니다.

펄 5, 26 바이트

23 플러스 3 -an( -E무료)

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

나에게 상기 시켜서 2 바이트를 절약 해 준 Dennis 에게 감사 -a합니다.

CJam, 6 바이트

{{!}$}

익명의 기능. "요소가 0인지 여부"를 키로 사용하여 정렬하십시오.

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

스위프트 , 13 바이트

a.sort{$1==0}

Perl6, 11 바이트

{.sort(!*)}

배열에서 호출 할 수있는 블록을 생성합니다.

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

작성하는 것이 더 자연스럽고 짧습니다.

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

작동 방식 : perl6 정렬 루틴 이 하나의 인수 만 허용하는 블록으로 호출되면 목록 요소가에 따라 정렬됩니다 by($a) cmp by($b). 이 경우 블록은 !*즉, operator 의 부정입니다 .

나는 알아 차렸다 :

• 문제의 예는 읽을 수있는 상용구를 포함하지 않는 방법을 제공하는 클래스입니다.
• 작업에 대한 설명은 인쇄가 필요하지 않으며 예제 인쇄를 제외하고는 배열이 반환 될 수 있음을 의미합니다.

TeX (일반 형식), 160 바이트

확인 0후 문자를 생략하고 카운터를 증가하기 위해 그 명령을 정의 (즉, 명령으로 통역 과정이 만들) 활성 문자. 문자열의 끝에서 계산 된 수만큼 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

온라인으로 사용해보십시오! (추가 된 코드는 모든 테스트 사례를 테스트하는 것입니다)

자바 스크립트 ES6, 16 바이트

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

파이어 폭스에서 작동

루비 , 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]