A tarefa é simples: consolidar uma matriz de entradas. A consolidação dessa matriz consiste no seguinte:

• Todas as instâncias de 0 precisam ser movidas para o final da matriz.
• Não deve haver zero entre os números inteiros diferentes de zero.
• Todos os índices diferentes de zero devem manter sua ordem.

Desafio

Consolide uma matriz na menor quantidade de bytes.

Você está consolidando uma matriz de tamanho aleatório com um tamanho até o máximo do seu idioma com números inteiros aleatórios. A entrada pode ser um caminho natural para o seu idioma.

Exemplos

Entrada

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

Saída

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

Entrada

-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

Saída

-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

Código de exemplo (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+" ");
    }
}

Pitão, 3 bytes

!DQ

Explicação:

  Q    Input
!D     Sort by logical NOT

Experimente aqui .

Gelatina, 3 bytes

¬Ụị

Classifica a lista pelo NOT lógico de seus valores. Experimente online!

Como funciona

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

Oitava, 18 bytes

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

sort()leva muitos bytes. Vou usar a indexação lógica.

Exemplos de ideona .

R, 29 23 21 bytes

Conforme observado por MarcoBreitig, podemos reduzi-lo para 21 bytes se não precisarmos fornecê-lo como uma função:

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

Versões prévias:

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

A função recebe um vetor como entrada e ordena pelo vetor lógico resultante da negação da entrada.

Resposta original:

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

A função pega um vetor como entrada e concatena ( c()) os valores diferentes de zero e depois os valores zero.

Retina , 15

Substituição simples de regex repetida:

+`\b0 (.*)
$1 0

Experimente online.

ES6, 23 bytes

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

Costumava ser o caso que sortnão era estável; nesse caso, você precisava de 41 bytes:

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

Código de bytes Python (2.7.9), 252 bytes, 33 códigos de operação, 0,0228 segundos

Este foi construído quando a competição ainda era um mais rápido código de concurso

Abre um arquivo no diretório atual chamado 'SourceArray'para uso

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

O co_code(o bit codey real)

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

Ou uma versão do arquivo .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

Você pode tentar compilar meu código fonte usando minha biblioteca no github. Acabei de publicar um commit que permitiu comentários, então espero que ainda esteja competindo no código mais rápido ;)

Aproximadamente equivalente a

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 bytes

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

Leva o argumento como qualquer iterável (lista, tupla, etc.). Obrigado a @xnor por me ensinar um novo truque!

Matlab: 21 bytes

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

Imprime elementos diferentes de zero primeiro e concatena com zero elementos

@(a)____ crie uma função anônima com um argumento de entrada a

[___,___] concatena vetores horizontalmente entre colchetes, separados por vírgulas

a(a~=0) retorna vetor com todos os elementos diferentes de zero do vetor a

a(a==0) retorna vetor com todos os zero elementos do vetor a

Haskell, 26 bytes

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

Pegue todos os números diferentes de zero, seguidos por todos os zeros. Filtrando constantes (aqui: 0) é bastante curta quando se usa uma compreensão da lista: [0|0<-x].

Zsh, 22 bytes

(entrada passada como argumentos para o script / função ( $@também conhecida como $argvmatriz), saída em stdout como lista separada por espaço, nova linha finalizada)

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

• <<< string: aqui-string aqui passada como stdin para o $NULLCMDcomando ( catpor padrão).
• ${@:#0} $@ exceto elementos sendo 0.
• ${(M)@:#0} reverso do acima

Isso pressupõe (como várias outras respostas aqui) que os zeros na entrada são todos expressos como 0(no 00nem 0x0nor 36#0).

Javascript, 52 54 51 bytes

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

Mathematica, 14 bytes

Sort[#,#!=0&]&

APL: 8 bytes

(⍴a)↑a~0

a ~ 0 remove zeros de a (leia "a sem 0")
(⍴a) comprimento original de a (leia "forma de a")
↑ preencha a sem zeros no comprimento original de a

Experimente em http://ngn.github.com/apl/web/index.html

Dados do teste: a ← 1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7, 78 bytes

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

Não sei por que as outras entradas Java estão usando seqüências de caracteres. Se você deseja filtrar uma matriz inteira, parece melhor usar uma matriz inteira. Isso modifica a entrada no local, mantendo dois índices e preenchendo os demais slots com zeros.

Lisp comum, 46 bytes

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

Classifique a matriz para que, para cada par (a, b) , tenhamos a <b se b for zero. Quando nem a <b ou b <a , a classificação é estável: a ordem original entre os elementos é mantida.

Eu também tentei com ajuste de matriz e remover , mas isso foi muito longo:

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

PHP, 73 71 70 52 49 48 46 bytes - MUITO obrigado a 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;

Utilitários Bash + GNU, 23

grep -v ^0 a
grep ^0 a

Assume que a entrada é entradas separadas por nova linha em um arquivo chamado a. A pontuação inclui +1 para este nome de arquivo.

Perl 5, 26 bytes

23 mais três para -an ( -Eé grátis)

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

Agradeço ao Dennis por me lembrar -a, salvando dois bytes.

CJam, 6 bytes

{{!}$}

Uma função anônima. Classifique usando "se um elemento é zero ou não" como chave.

MATL , 7 bytes

t~FT#S)

Experimente online!

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

Sério, 12 bytes

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

Experimente online!

Explicação:

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

Rápido , 13 bytes

a.sort{$1==0}

Perl6, 11 bytes

{.sort(!*)}

Produz um bloco - que pode ser chamado em uma matriz:

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

Embora fosse mais natural (e mais curto) escrever:

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

Como funciona: se a rotina de classificação perl6 é chamada com um bloco que aceita apenas um argumento, os elementos da lista são classificados de acordo com by($a) cmp by($b). Nesse caso, o bloco é !*, ou seja, uma negação do operador seja qual for .

Eu reparei nisso:

• O exemplo na pergunta é uma classe que fornece um método, não incluindo o padrão necessário para ler em
• A descrição da tarefa não requer impressão e, exceto pelo fato de o exemplo ser impresso, implica que uma matriz pode ser retornada

TeX (formato simples), 160 bytes

Torne o 0caractere ativo (ou seja, faça o intérprete processá-lo como um comando), depois defina esse comando para ignorar o caractere e incrementar um contador. No final da sequência, imprima quantos zeros forem contados.

Salve isso como zero.texe forneça a entrada através da linha de comando com este comando:

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

(Novas linhas adicionadas para maior clareza)

J, 4 bytes

/:0=

Explicação:

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

A função de classificação em J é garantida como estável pela especificação.

Solução alternativa, 6 bytes:

#{.*#+

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

Palha , 30 29 bytes

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

Use a codificação CP437

Explicação

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

Experimente online! (O código adicionado é para testar todos os casos de teste)

JavaScript ES6, 16 bytes

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

Funciona no firefox

Ruby , 25 bytes

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

Experimente online!

05AB1E , 15 14 bytes

Código:

ED0¢r0KR`rFZ}|

Explicação:

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

Usa a codificação CP-1252. Toma uma matriz como esta:

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