Il compito è semplice: consolidare una matrice di ints. Il consolidamento di questo array è composto da:

• Tutte le istanze di 0 devono essere spostate alla fine dell'array.
• Non dovrebbero esserci 0 tra i numeri interi diversi da zero.
• Tutti gli indici diversi da zero devono mantenere il loro ordine.

Sfida

Consolidare un array nel minor numero di byte.

Stai consolidando una matrice di lunghezza casuale con una dimensione fino al massimo della tua lingua con numeri interi casuali. L'input può essere un modo naturale per la tua lingua.

Esempi

Ingresso

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

Produzione

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

Ingresso

-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

Produzione

-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

Codice di esempio (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 byte

!DQ

Spiegazione:

  Q    Input
!D     Sort by logical NOT

Provalo qui .

Gelatina, 3 byte

¬Ụị

Ordina l'elenco in base al NOT logico dei suoi valori. Provalo online!

Come funziona

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

Ottava, 18 byte

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

sort()richiede troppi byte. Userò solo l'indicizzazione logica.

Esempi su ideone .

R, 29 23 21 byte

Come notato da MarcoBreitig, possiamo accorciarlo a 21 byte se non è necessario fornirlo come funzione:

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

Versione precedente:

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

La funzione accetta un vettore come input e ordina dal vettore logico risultante dalla negazione dell'input.

Risposta originale:

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

La funzione accetta un vettore come input e concatena ( c()) i valori diversi da zero e quindi i valori zero.

Retina , 15

Sostituzione regex ripetuta semplice:

+`\b0 (.*)
$1 0

Provalo online.

ES6, 23 byte

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

In passato sortnon era stabile, nel qual caso erano necessari 41 byte:

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

Codice byte Python (2.7.9), 252 byte, 33 codici operativi, 0,0228 secondi

Questo è stato creato quando il concorso era ancora un concorso a codice più veloce

Apre un file nella directory corrente chiamato 'SourceArray'per l'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

Il co_code(il bit di codice attuale)

'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 versione del file .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

Puoi provare a compilare tu stesso il mio codice sorgente usando la mia libreria su github. Ho appena pubblicato un commit che ha consentito commenti, quindi spero che questo sia ancora in competizione per quanto riguarda il codice più veloce ;)

Praticamente 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 byte

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

Accetta l'argomento come qualsiasi iterabile (elenco, tupla, ecc.). Grazie a @xnor per avermi insegnato un nuovo trucco!

Matlab: 21 byte

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

Stampa prima gli elementi diversi da zero, quindi concatena con zero elementi

@(a)____ creare una funzione anonima con un argomento di input a

[___,___] concatena i vettori orizzontalmente all'interno delle parentesi, separati da virgole

a(a~=0) restituisce il vettore con tutti gli elementi diversi da zero del vettore a

a(a==0) ritorna vettore con tutti gli zero elementi del vettore a

Haskell, 26 byte

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

Prendi tutti i numeri diversi da zero seguiti da tutti gli zeri. Filtraggio costanti (qui: 0) è piuttosto breve quando si utilizza una lista di comprensione: [0|0<-x].

Zsh, 22 byte

(input passato come argomenti allo script / funzione ( $@aka $argvarray), output su stdout come elenco separato da spazi, newline terminato)

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

• <<< string: here-string qui passato come stdin al $NULLCMDcomando ( catper impostazione predefinita).
• ${@:#0} $@ tranne gli elementi che sono 0.
• ${(M)@:#0} retro di quanto sopra

Ciò presuppone (come molte altre risposte qui) che gli zero nell'input siano tutti espressi come 0(no 00né 0x0nor 36#0).

Javascript, 52 54 51 byte

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

Mathematica, 14 byte

Sort[#,#!=0&]&

APL: 8 byte

(⍴a)↑a~0

a ~ 0 rimuove gli zeri da a (leggi "a senza 0")
(⍴a) lunghezza originale di a (leggi "forma di a")
↑ pad a senza zeri alla lunghezza originale di a

Provalo in http://ngn.github.com/apl/web/index.html

Dati di prova: 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);}

Non sono sicuro del motivo per cui le altre voci Java utilizzano stringhe. Se vuoi filtrare un array intero, sembra meglio usare un array intero. Questo modifica l'input sul posto mantenendo due indici, quindi riempiendo gli spazi rimanenti con zeri.

Lisp comune, 46 byte

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

Ordinare l'array in modo che per ogni coppia (a, b) , abbiamo a <b se b è zero. Quando né a <b oppure b <a , l'ordinamento è stabile: viene mantenuto l'ordine originale tra gli elementi.

Ho anche provato a regolare-array e rimuovere , ma questo è stato troppo lungo:

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

PHP, 73 71 70 52 49 48 46 byte - GRANDE grazie 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à Bash + GNU, 23

grep -v ^0 a
grep ^0 a

Presuppone che l'input sia composto da voci separate da una nuova riga in un file chiamato a. Il punteggio include +1 per questo nome file.

Perl 5, 26 byte

23 più tre per -an( -Eè gratuito)

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

Grazie a Dennis per avermelo ricordato -a, risparmiando due byte.

CJam, 6 byte

{{!}$}

Una funzione anonima. Ordina usando "se un elemento è zero" come chiave.

MATL , 7 byte

t~FT#S)

Provalo 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

Scherzi a parte, 12 byte

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

Provalo online!

Spiegazione:

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

Rapido , 13 byte

a.sort{$1==0}

Perl6, 11 byte

{.sort(!*)}

Produce un blocco - che può essere chiamato su un array:

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

Anche se sarebbe più naturale (e più breve) scrivere:

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

Come funziona: se la routine di ordinamento perl6 viene chiamata con un blocco che accetta solo un argomento, gli elementi della lista vengono ordinati secondo by($a) cmp by($b). In questo caso, il blocco è !*, cioè una negazione dell'operatore qualunque .

L'ho notato:

• L'esempio nella domanda è una classe che fornisce un metodo, esclusa la piastra di caldaia richiesta per la lettura
• La descrizione dell'attività non richiede la stampa e, tranne per il fatto che l'esempio stampa, implica che un array potrebbe essere restituito

TeX (formato normale), 160 byte

Rendi 0attivo il personaggio (ovvero, fallo interpretare dall'interprete come comando), quindi definisci quel comando per saltare il carattere e incrementare un contatore. Alla fine della stringa, stampa tutti gli zeri quanti sono stati contati.

Salvalo come zero.texe dai l'input dalla riga di comando con questo 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

(Newline aggiunto per chiarezza)

J, 4 byte

/:0=

Spiegazione:

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

La funzione di ordinamento in J è garantita come stabile dalle specifiche.

Soluzione alternativa, 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)

Paglia , 30 29 byte

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

Utilizzare la codifica CP437

Spiegazione

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

Provalo online! (Il codice aggiunto è testare tutti i casi di test)

JavaScript ES6, 16 byte

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

Funziona su Firefox

Rubino , 25 byte

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

Provalo online!

05AB1E , 15 14 byte

Codice:

ED0¢r0KR`rFZ}|

Spiegazione:

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

Utilizza la codifica CP-1252. Prende un array come questo:

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