La tarea es simple: consolidar una serie de entradas. La consolidación de esta matriz consta de lo siguiente:

• Todas las instancias de 0 deben moverse al final de la matriz.
• No debería haber ceros entre los enteros distintos de cero.
• Todos los índices distintos de cero deben conservar su orden.

Reto

Consolidar una matriz en la menor cantidad de bytes.

Está consolidando una matriz de longitud aleatoria con un tamaño hasta el máximo de su idioma con enteros aleatorios. La entrada puede ser cualquier forma natural para su idioma.

Ejemplos

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

Salida

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

Salida

-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 ejemplo (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 bytes

!DQ

Explicación:

  Q    Input
!D     Sort by logical NOT

Probarlo aquí .

Jalea, 3 bytes

¬Ụị

Ordena la lista por el NOT lógico de sus valores. Pruébalo en línea!

Cómo 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.

Octava, 18 bytes

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

sort()Toma demasiados bytes. Solo usaré la indexación lógica.

Ejemplos sobre ideona .

R, 29 23 21 bytes

Como señaló MarcoBreitig, podemos acortarlo a 21 bytes si no necesitamos proporcionarlo como una función:

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

Versión anterior:

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

La función toma un vector como entrada y ordena por el vector lógico que resulta de negar la entrada.

Respuesta original:

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

La función toma un vector como entrada y concatena ( c()) los valores distintos de cero y luego los valores cero.

Retina , 15

Sustitución simple de expresiones regulares repetidas:

+`\b0 (.*)
$1 0

Pruébalo en línea.

ES6, 23 bytes

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

Solía ​​ser el caso que sortno era estable, en cuyo caso necesitabas 41 bytes:

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

Código de bytes de Python (2.7.9), 252 bytes, 33 códigos de operación, 0.0228 segundos

Esto fue construido cuando el concurso todavía era un concurso de código más rápido

Abre un archivo en el directorio actual llamado '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

El co_code(El bit de 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'

O una versión de archivo .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

Puede intentar compilar mi código fuente usted mismo usando mi biblioteca en github. Acabo de publicar un compromiso que permitió comentarios, así que espero que todavía compita en lo que respecta al código más 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__)

Toma el argumento como cualquier iterable (lista, tupla, etc.). ¡Gracias a @xnor por enseñarme un nuevo truco!

Matlab: 21 bytes

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

Imprime primero elementos distintos de cero, luego concatena con cero elementos

@(a)____ crear una función anónima con un argumento de entrada a

[___,___] concatena horizontalmente vectores dentro de corchetes, separados por comas

a(a~=0) devuelve vector con todos los elementos distintos de cero del vector a

a(a==0) devuelve vector con todos los elementos cero del vector a

Haskell, 26 bytes

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

Tome todos los números que no sean cero seguidos de todos los ceros. Filtrado constantes (aquí: 0) es muy corto cuando se utiliza una lista por comprensión: [0|0<-x].

Zsh, 22 bytes

(entrada pasada como argumentos a la secuencia de comandos / función ( $@también conocida como $argvmatriz), salida en stdout como lista separada por espacios, nueva línea terminada)

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

• <<< string: here-string aquí pasó como stdin al $NULLCMDcomando ( catpor defecto).
• ${@:#0} $@ excepto que los elementos son 0.
• ${(M)@:#0} reverso de lo anterior

Eso supone (como muchas otras respuestas aquí) que los ceros en la entrada se expresan como 0(no, 00ni 0x0tampoco 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 elimina ceros de a (lee "a sin 0")
(⍴a) longitud original de a (lee "forma de a")
↑ rellena a sin ceros a la longitud original de a

Pruébelo en http://ngn.github.com/apl/web/index.html

Datos de prueba: 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);}

No estoy seguro de por qué las otras entradas de Java están usando cadenas. Si desea filtrar una matriz de enteros, parece mejor utilizar una matriz de enteros. Esto modifica la entrada en su lugar manteniendo dos índices y luego simplemente rellenando los espacios restantes con ceros.

Lisp común, 46 bytes

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

Ordene la matriz de manera que para cada pareja (a, b) , tengamos a <b si b es cero. Cuando ni a <b o b <a , la ordenación es estable: se conserva el orden original entre los elementos.

También probé con ajustar-matriz y eliminar , pero esto fue demasiado largo:

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

PHP, 73 71 70 52 49 48 46 bytes - GRANDES gracias 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;

Bash + GNU utilidades, 23

grep -v ^0 a
grep ^0 a

Asume que la entrada es entradas separadas por nueva línea en un archivo llamado a. La puntuación incluye +1 para este nombre de archivo.

Perl 5, 26 bytes

23 más tres para -an( -Ees gratis)

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

Gracias a Dennis por recordarme -a, guardar dos bytes.

CJam, 6 bytes

{{!}$}

Una función anónima. Ordenar utilizando "si un elemento es cero o no" como clave.

MATL , 7 bytes

t~FT#S)

Pruébalo en línea!

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

En serio, 12 bytes

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

Pruébalo en línea!

Explicación:

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(!*)}

Produce un bloque, que se puede invocar en una matriz:

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

Aunque sería más natural (y más corto) escribir:

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

Cómo funciona: si la rutina de ordenación perl6 se llama con un bloque que acepta solo un argumento, los elementos de la lista se ordenan según by($a) cmp by($b). En este caso, el bloque es !*, es decir, una negación del operador que sea .

Me doy cuenta de que:

• El ejemplo en la pregunta es una clase que proporciona un método, sin incluir repeticiones necesarias para leer en
• La descripción de la tarea no requiere impresión y, a excepción del hecho de que el ejemplo se imprime, implica que se puede devolver una matriz

TeX (formato normal), 160 bytes

Active el 0carácter (es decir, haga que el intérprete lo procese como un comando), luego defina ese comando para omitir el carácter e incrementar un contador. Al final de la cadena, imprima tantos ceros como se contaron.

Guarde esto como zero.texy dé la entrada a través de la línea de comando con 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

(Se agregaron nuevas líneas para mayor claridad)

J, 4 bytes

/:0=

Explicación:

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

La función de clasificación en J está garantizada como estable por la especificación.

Solución 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)

Paja , 30 29 bytes

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

Use la codificación CP437

Explicación

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

Pruébalo en línea! (El código agregado es para probar todos los casos de prueba)

JavaScript ES6, 16 bytes

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

Funciona en firefox

Rubí , 25 bytes

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

Pruébalo en línea!

05AB1E , 15 14 bytes

Código:

ED0¢r0KR`rFZ}|

Explicación:

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

Utiliza la codificación CP-1252. Toma una 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]