La tâche est simple: consolider un tableau d'ints. La consolidation de ce tableau comprend les éléments suivants:

• Toutes les occurrences de 0 doivent être déplacées vers la fin du tableau.
• Il ne devrait y avoir aucun 0 entre les entiers non nuls.
• Tous les indices non nuls doivent conserver leur ordre.

Défi

Consolidez un tableau en un minimum d'octets.

Vous consolidez un tableau de longueur aléatoire avec une taille pouvant aller jusqu'au maximum de votre langue avec des entiers aléatoires. La saisie peut être une manière naturelle pour votre langue.

Exemples

Contribution

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

Sortie

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

Contribution

-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

Sortie

-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

Exemple de code (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 octets

!DQ

Explication:

  Q    Input
!D     Sort by logical NOT

Essayez ici .

Gelée, 3 octets

¬Ụị

Trie la liste par le NON logique de ses valeurs. Essayez-le en ligne!

Comment ça marche

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

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

sort()prend trop d'octets. Je vais juste utiliser l'indexation logique.

Exemples sur ideone .

R, 29 23 21 octets

Comme l'a noté MarcoBreitig, nous pouvons le réduire à 21 octets si nous n'avons pas besoin de le fournir en tant que fonction:

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

Versions précédentes:

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

La fonction prend un vecteur en entrée et ordonne par le vecteur logique résultant de la négation de l'entrée.

Réponse originale:

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

La fonction prend un vecteur en entrée et concatène ( c()) les valeurs non nulles puis les valeurs nulles.

Rétine , 15

Substitution de regex répétée simple:

+`\b0 (.*)
$1 0

Essayez-le en ligne.

ES6, 23 octets

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

Auparavant, le cas sortn'était pas stable, auquel cas vous aviez besoin de 41 octets:

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

Code d'octet Python (2.7.9), 252 octets, 33 codes d'opération, 0.0228 secondes

C'était construit quand le concours était encore un concours de code le plus rapide

Ouvre un fichier dans le répertoire actuel appelé 'SourceArray'pour utilisation

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

Le co_code(le bit de code réel)

'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 une version de fichier .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

Vous pouvez essayer de compiler mon code source vous-même en utilisant ma bibliothèque sur github. Je viens de poster un engagement qui permettait les commentaires donc j'espère que cela reste en compétition en ce qui concerne le code le plus rapide ;)

À peu près équivalent à

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 octets

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

Prend l'argument comme quelconque (liste, tuple, etc.). Merci à @xnor de m'avoir appris un nouveau tour!

Matlab: 21 octets

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

Affiche d'abord les éléments non nuls, puis les concatène avec zéro

@(a)____ créer une fonction anonyme avec un argument d'entrée a

[___,___] concatène horizontalement les vecteurs entre crochets, séparés par des virgules

a(a~=0) renvoie le vecteur avec tous les éléments non nuls du vecteur a

a(a==0) renvoie le vecteur avec tous les éléments nuls du vecteur a

Haskell, 26 octets

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

Prenez tous les nombres non nuls suivis de tous les zéros. Filtrage des constantes (ici: 0) est assez courte lors de l' utilisation d' une compréhension de la liste: [0|0<-x].

Zsh, 22 octets

(entrée transmise en tant qu'arguments au script / fonction (également $@appelée $argvtableau), sortie sur stdout sous forme de liste séparée par des espaces, nouvelle ligne terminée)

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

• <<< string: here-string ici passée en tant que stdin à la $NULLCMDcommande ( catpar défaut).
• ${@:#0} $@ sauf les éléments étant 0.
• ${(M)@:#0} l'inverse de ce qui précède

Cela suppose (comme plusieurs autres réponses ici) que les zéros dans l’entrée sont tous exprimés par 0(no 00ni 0x0ni 36#0).

Javascript, 52 54 51 octets

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

Mathematica, 14 octets

Sort[#,#!=0&]&

APL: 8 octets

(⍴a)↑a~0

a ~ 0 supprimer les zéros de (lire "a sans 0")
(a) longueur d'origine de a (lire "forme d'un")
↑ pavé a sans zéros à la longueur d'origine de a

Essayez-le sur http://ngn.github.com/apl/web/index.html

Données de test: a ← 1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7, 78 octets

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

Je ne suis pas sûr de savoir pourquoi les autres entrées Java utilisent des chaînes. Si vous souhaitez filtrer un tableau entier, il semble préférable d'utiliser un tableau entier. Cela modifie l'entrée en place en conservant deux index, puis en remplissant simplement les emplacements restants avec des zéros.

Common Lisp, 46 octets

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

Triez le tableau de sorte que pour chaque couple (a, b) , nous avons un <b si b vaut zéro. Lorsque ni a <b ni b <a , le tri est stable: l'ordre d'origine entre les éléments est conservé.

J'ai aussi essayé avec adjust-array et remove , mais c'était trop long:

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

PHP, 73 71 70 52 49 48 46 octets - GRAND merci à 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;

Utilitaires Bash + GNU, 23

grep -v ^0 a
grep ^0 a

Suppose que l'entrée est des entrées séparées par une nouvelle ligne dans un fichier appelé a. Le score inclut +1 pour ce nom de fichier.

Perl 5, 26 octets

23 plus trois pour -an( -Ec'est gratuit)

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

Merci à Dennis de me l'avoir rappelé -a, économisant deux octets.

CJam, 6 octets

{{!}$}

Une fonction anonyme. Triez en utilisant «si un élément est nul ou non» comme clé.

MATL , 7 octets

t~FT#S)

Essayez-le en ligne!

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érieusement, 12 octets

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

Essayez-le en ligne!

Explication:

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

Rapide , 13 octets

a.sort{$1==0}

Perl6, 11 octets

{.sort(!*)}

Produit un bloc - qui peut être appelé sur un tableau:

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

Bien qu'il serait plus naturel (et plus court) d'écrire:

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

Comment ça marche: si la routine de tri perl6 est appelée avec un bloc n'acceptant qu'un seul argument, les éléments de la liste sont triés selon by($a) cmp by($b). Dans ce cas, le bloc est !*, c'est-à-dire une négation de l' opérateur quelconque .

Je remarque que:

• L'exemple dans la question est une classe qui fournit une méthode, n'incluant pas le passe-partout requis pour la lecture
• La description de la tâche ne nécessite pas d’impression et, à part le fait que l’exemple soit imprimé, implique qu’un tableau peut être renvoyé.

TeX (format simple), 160 octets

Activez le 0caractère (c’est-à-dire faites en sorte que l’interprète le traite comme une commande), puis définissez cette commande pour ignorer le caractère et incrémenter un compteur. À la fin de la chaîne, imprimez autant de zéros que comptés.

Enregistrez ceci sous zero.texet donnez l'entrée via la ligne de commande avec cette commande:

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

(Newlines ajouté pour plus de clarté)

J, 4 octets

/:0=

Explication:

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

La fonction de tri dans J est garantie par la spécification.

Solution alternative, 6 octets:

#{.*#+

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

Paille , 30 29 octets

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

Utilisez le codage CP437

Explication

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

Essayez-le en ligne! (Le code ajouté est de tester tous les cas de test)

JavaScript ES6, 16 octets

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

Fonctionne sur firefox

Ruby , 25 octets

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

Essayez-le en ligne!

05AB1E , 15 14 octets

Code:

ED0¢r0KR`rFZ}|

Explication:

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

Utilise le codage CP-1252. Prend un tableau comme ceci:

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