Die Aufgabe ist einfach: Konsolidieren Sie ein Array von Ints. Die Konsolidierung dieses Arrays umfasst Folgendes:

• Alle Instanzen von 0 müssen an das Ende des Arrays verschoben werden.
• Zwischen den Ganzzahlen ungleich Null dürfen keine Nullen stehen.
• Alle Nicht-Null-Indizes sollten ihre Reihenfolge beibehalten.

Herausforderung

Konsolidieren Sie ein Array mit der geringsten Anzahl von Bytes.

Sie konsolidieren ein Array von zufälliger Länge mit einer Größe bis zur Maximalgröße Ihrer Sprache mit zufälligen ganzen Zahlen. Die Eingabe kann auf jede natürliche Weise für Ihre Sprache erfolgen.

Beispiele

Eingang

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

Ausgabe

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

Eingang

-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

Ausgabe

-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

Beispielcode (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

Erläuterung:

  Q    Input
!D     Sort by logical NOT

Probieren Sie es hier aus .

Gelee, 3 Bytes

¬Ụị

Sortiert die Liste nach dem logischen NICHT ihrer Werte. Probieren Sie es online!

Wie es funktioniert

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

Oktave, 18 Bytes

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

sort()nimmt zu viele Bytes. Ich werde nur die logische Indizierung verwenden.

Beispiele zu ideone .

R 29 23 21 Bytes

Wie von MarcoBreitig bemerkt, können wir es auf 21 Bytes verkürzen, wenn wir es nicht als Funktion bereitstellen müssen:

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

Vorherige Versionen:

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

Die Funktion nimmt einen Vektor als Eingabe und ordnet ihn nach dem logischen Vektor, der sich aus der Negierung der Eingabe ergibt.

Ursprüngliche Antwort:

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

Die Funktion nimmt einen Vektor als Eingabe und verkettet ( c()) die Nicht-Null-Werte und dann die Null-Werte.

Retina , 15

Einfache wiederholte Regex-Ersetzung:

+`\b0 (.*)
$1 0

Probieren Sie es online aus.

ES6, 23 Bytes

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

Früher sortwar es nicht stabil, in diesem Fall brauchten Sie 41 Bytes:

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

Python-Bytecode (2.7.9), 252 Byte, 33 Opcodes, 0,0228 Sekunden

Dies wurde gebaut, als der Wettbewerb noch ein Wettbewerb mit dem schnellsten Code war

Öffnet eine Datei im aktuellen Verzeichnis, die 'SourceArray'zur Verwendung aufgerufen wird

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

The co_code(Das eigentliche Codey-Bit)

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

Oder eine .pyc-Dateiversion 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

Sie können versuchen, meinen Quellcode mit meiner Bibliothek auf github selbst zu kompilieren. Ich habe gerade ein Commit dazu gepostet, das Kommentare erlaubt, also hoffe ich, dass dies immer noch konkurriert, was den schnellsten Code betrifft;)

In etwa gleichwertig mit

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__)

Nimmt Argumente als iterabel an (Liste, Tupel usw.). Vielen Dank an @xnor, der mir einen neuen Trick beigebracht hat!

Matlab: 21 Bytes

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

Druckt zuerst Elemente ungleich Null und verkettet sie dann mit Elementen ungleich Null

@(a)____ Erstellen Sie eine anonyme Funktion mit einem Eingabeargument a

[___,___] Verkettet horizontale Vektoren in Klammern, die durch Kommas getrennt sind

a(a~=0) Gibt den Vektor mit allen Nicht-Null-Elementen des Vektors zurück a

a(a==0) Gibt den Vektor mit allen Nullelementen des Vektors zurück a

Haskell, 26 Bytes

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

Nehmen Sie alle Zahlen ungleich Null, gefolgt von allen Nullen. Filterung Konstanten (hier: 0) ist ziemlich kurz , wenn eine Liste Verständnis mit: [0|0<-x].

Zsh, 22 Bytes

(Eingabe als Argumente an das Skript / die Funktion übergeben ( $@aka $argvArray), Ausgabe auf stdout als durch Leerzeichen getrennte Liste, Zeilenumbruch beendet)

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

• <<< string: here-string hier als stdin an den $NULLCMDBefehl übergeben ( catstandardmäßig).
• ${@:#0} $@ mit der Ausnahme, dass die Elemente 0 sind.
• ${(M)@:#0} Umkehrung der oben genannten

Dies setzt (wie bei mehreren anderen Antworten hier) voraus, dass Nullen in der Eingabe alle als 0(no 00nor 0x0nor 36#0) ausgedrückt werden .

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 entfernt Nullen von einer (gelesen "a ohne 0")
(⍴a) ursprünglichen Länge von a (gelesen "Form von a")
↑ füllt a ohne Nullen mit der ursprünglichen Länge von a auf

Versuchen Sie es unter http://ngn.github.com/apl/web/index.html

Testdaten: a ← 1 0 1 2 3 4 0 1 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);}

Ich bin nicht sicher, warum die anderen Java-Einträge Zeichenfolgen verwenden. Wenn Sie ein ganzzahliges Array filtern möchten, empfiehlt es sich, ein ganzzahliges Array zu verwenden. Dadurch wird die Eingabe geändert, indem zwei Indizes beibehalten werden und die verbleibenden Slots nur mit Nullen gefüllt werden.

Common Lisp, 46 Bytes

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

Sortieren , so dass die Anordnung , dass für jedes Paar (a, b) , haben wir ein <b , wenn b Null ist. Wenn weder a <b noch b <a , ist die Sortierung stabil: Die ursprüngliche Reihenfolge zwischen den Elementen wird beibehalten.

Ich habe es auch mit adjust-array und remove versucht , aber das war zu lang:

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

PHP, 73 71 70 52 49 48 46 Bytes - GROSS dank 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-Dienstprogramme, 23

grep -v ^0 a
grep ^0 a

Angenommen, es handelt sich bei der Eingabe um durch Zeilenumbrüche getrennte Einträge in einer aufgerufenen Datei a. Die Punktzahl enthält +1 für diesen Dateinamen.

Perl 5, 26 Bytes

23 plus drei für -an( -Eist kostenlos)

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

Vielen Dank an Dennis , der mich daran erinnert hat -a, zwei Bytes gespart zu haben.

CJam, 6 Bytes

{{!}$}

Eine anonyme Funktion. Sortieren Sie mit "ob ein Element Null ist oder nicht" als Schlüssel.

MATL , 7 Bytes

t~FT#S)

Probieren Sie es 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

Im Ernst, 12 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Schnell , 13 Bytes

a.sort{$1==0}

Perl6, 11 Bytes

{.sort(!*)}

Erzeugt einen Block, der in einem Array aufgerufen werden kann:

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

Obwohl es natürlicher (und kürzer) wäre zu schreiben:

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

So funktioniert es: Wird die Sortierroutine perl6 mit einem Block aufgerufen, der nur ein Argument akzeptiert, werden die Listenelemente nach diesem sortiert by($a) cmp by($b). In diesem Fall ist der Block !*also eine Negation des beliebigen Operators .

Ich bemerke das:

• Das Beispiel in der Frage ist eine Klasse, die eine Methode ohne Boilerplate zum Einlesen bereitstellt
• Die Beschreibung der Aufgabe erfordert kein Drucken und impliziert, dass möglicherweise ein Array zurückgegeben wird, mit Ausnahme der Tatsache, dass das Beispiel gedruckt wird

TeX (einfaches Format), 160 Byte

Aktivieren Sie das 0Zeichen (dh, der Interpreter verarbeitet es als Befehl) und definieren Sie diesen Befehl, um das Zeichen zu überspringen und einen Zähler zu erhöhen. Geben Sie am Ende der Zeichenfolge so viele Nullen aus, wie gezählt wurden.

Speichern Sie dies als zero.texund geben Sie die Eingabe über die Befehlszeile mit diesem Befehl ein:

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

(Zeilenumbrüche zur Verdeutlichung hinzugefügt)

J, 4 Bytes

/:0=

Erläuterung:

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

Die Sortierfunktion in J ist durch die Spezifikation garantiert stabil.

Alternative Lösung, 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)

Stroh , 30 29 Bytes

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

Verwenden Sie die CP437-Codierung

Erläuterung

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

Probieren Sie es online! (Der hinzugefügte Code dient zum Testen aller Testfälle.)

JavaScript ES6, 16 Byte

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

Funktioniert mit Firefox

Ruby , 25 Bytes

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

Probieren Sie es online!

05AB1E , 15 14 Bytes

Code:

ED0¢r0KR`rFZ}|

Erläuterung:

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

Verwendet die CP-1252-Codierung. Nimmt ein Array wie folgt an:

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