Zadanie jest proste: skonsoliduj tablicę ints. Konsolidacja tej tablicy składa się z następujących elementów:

• Wszystkie wystąpienia 0 muszą zostać przeniesione na koniec tablicy.
• Pomiędzy niezerowymi liczbami całkowitymi nie powinno być zer.
• Wszystkie niezerowe indeksy powinny zachować swoją kolejność.

Wyzwanie

Skonsoliduj tablicę w najmniejszej ilości bajtów.

Konsolidujesz tablicę o losowej długości z rozmiarem do maksimum twojego języka z losowymi liczbami całkowitymi. Wprowadzanie może być naturalnym sposobem dla twojego języka.

Przykłady

Wkład

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

Wydajność

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

Wkład

-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

Wydajność

-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

Przykładowy kod (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 bajty

!DQ

Wyjaśnienie:

  Q    Input
!D     Sort by logical NOT

Wypróbuj tutaj .

Galaretka, 3 bajty

¬Ụị

Sortuje listę według logicznego NOT jej wartości. Wypróbuj online!

Jak to działa

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

Oktawa, 18 bajtów

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

sort()zajmuje zbyt wiele bajtów. Użyję tylko indeksowania logicznego.

Przykłady dotyczące ideonu .

R, 29 23 21 bajtów

Jak zauważył MarcoBreitig, możemy skrócić go do 21 bajtów, jeśli nie musimy go podawać jako funkcji:

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

Poprzednie wersje:

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

Funkcja przyjmuje wektor jako dane wejściowe i porządkuje według wektora logicznego, który wynika z zanegowania danych wejściowych.

Oryginalna odpowiedź:

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

Funkcja przyjmuje wektor jako dane wejściowe i konkatenuje ( c()) wartości niezerowe, a następnie wartości zerowe.

Retina , 15

Proste powtarzanie podstawienia wyrażenia regularnego:

+`\b0 (.*)
$1 0

Wypróbuj online.

ES6, 23 bajty

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

Kiedyś sytuacja sortbyła niestabilna, w którym to przypadku potrzebujesz 41 bajtów:

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

Kod bajtowy w Pythonie (2.7.9), 252 bajty, 33 kody, 0,0228 sekundy

To był build kiedy konkurs był wciąż najszybciej kod konkurs

Otwiera plik w bieżącym katalogu, 'SourceArray'do którego należy użyć

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

co_code(Rzeczywista nieco codey)

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

Lub wersja pliku .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

Możesz spróbować samodzielnie skompilować mój kod źródłowy za pomocą mojej biblioteki na github. Właśnie opublikowałem zatwierdzenie, które pozwoliło na komentarze, więc mam nadzieję, że nadal konkuruje, jeśli chodzi o najszybszy kod ;)

Z grubsza odpowiada

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 bajty

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

Pobiera argument jak każda iterowalna (lista, krotka itp.). Dzięki @xnor za nauczenie mnie nowej sztuczki!

Matlab: 21 bajtów

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

Drukuje najpierw elementy niezerowe, a następnie konkatenuje z elementami zerowymi

@(a)____ utwórz anonimową funkcję z jednym argumentem wejściowym a

[___,___] łączy wektory poziome w nawiasach kwadratowych, oddzielając je przecinkami

a(a~=0) zwraca wektor ze wszystkimi niezerowymi elementami wektora a

a(a==0) zwraca wektor ze wszystkimi zerowymi elementami wektora a

Haskell, 26 bajtów

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

Weź wszystkie niezerowe liczby, a następnie wszystkie zera. Filtrowanie stałych (tutaj 0) jest dość krótki przy użyciu wyrażeń listowych: [0|0<-x].

Zsh, 22 bajty

(dane wejściowe przekazywane jako argumenty do skryptu / funkcji ( $@inaczej $argvtablica), dane wyjściowe na standardowym wyjściu jako lista oddzielona spacjami, zakończenie nowej linii)

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

• <<< string: ciąg tutaj jest przekazywany jako $NULLCMDkomenda jako standardowe ( catdomyślnie).
• ${@:#0} $@ z wyjątkiem elementów będących 0.
• ${(M)@:#0} odwrotność powyższego

Zakłada to (podobnie jak kilka innych odpowiedzi tutaj), że zera na wejściu są wyrażone jako 0(nie, 00ani 0x0nie 36#0).

JavaScript, 52 54 51 bajtów

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

Mathematica, 14 bajtów

Sort[#,#!=0&]&

APL: 8 bajtów

(⍴a)↑a~0

a ~ 0 usuwa zera z (czytaj „a bez 0”)
(⍴a) oryginalnej długości (czytaj „kształt a”)
↑ pad a bez zer do oryginalnej długości

Wypróbuj w http://ngn.github.com/apl/web/index.html

Dane testowe: a ← 1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7, 78 bajtów

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

Nie jestem pewien, dlaczego inne wpisy Java używają ciągów. Jeśli chcesz filtrować tablicę liczb całkowitych, najlepiej użyć tablicy liczb całkowitych. To modyfikuje dane wejściowe na miejscu, utrzymując dwa wskaźniki, a następnie wypełniając pozostałe szczeliny zerami.

Common Lisp, 46 bajtów

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

Posortuj tablicę tak, aby dla każdej pary (a, b) otrzymaliśmy wartość <b, jeśli b wynosi zero. Gdy ani a <b lub b <a , sortowanie jest stabilne: zachowana jest pierwotna kolejność między elementami.

Próbowałem też z dopasowaniem-tablicą i usunięciem , ale to było za długie:

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

PHP, 73 71 70 52 49 48 46 bajtów - DUŻY dzięki Ismaelowi Miguelowi

// 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;

Narzędzia Bash + GNU, 23

grep -v ^0 a
grep ^0 a

Zakłada, że ​​dane wejściowe to pozycje oddzielone znakiem nowej linii w pliku o nazwie a. Wynik obejmuje +1 dla tej nazwy pliku.

Perl 5, 26 bajtów

23 plus trzy za -an( -Ejest bezpłatny)

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

Dziękuję Dennisowi za przypomnienie mi -a, że zaoszczędziłem dwa bajty.

CJam, 6 bajtów

{{!}$}

Anonimowa funkcja. Sortuj używając „czy element jest zerowy” jako klucza.

MATL , 7 bajtów

t~FT#S)

Wypróbuj 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

Poważnie, 12 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

Szybki , 13 bajtów

a.sort{$1==0}

Perl6, 11 bajtów

{.sort(!*)}

Tworzy blok - który można wywołać w tablicy:

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

Chociaż pisanie byłoby bardziej naturalne (i krótsze):

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

Jak to działa: jeśli procedura sortowania perl6 jest wywoływana z blokiem, który akceptuje tylko jeden argument, elementy listy są sortowane według by($a) cmp by($b). W tym przypadku blok jest !*, tzn. Negacją dowolnego operatora .

Zauważam to:

• Przykładem w tym pytaniu jest klasa, która zapewnia metodę, nie uwzględniając płyty kotłowej wymaganej do wczytania
• Opis zadania nie wymaga drukowania i, z wyjątkiem faktu, że przykład drukuje, sugeruje, że tablica może zostać zwrócona

TeX (format zwykły), 160 bajtów

Uaktywnij 0znak (to znaczy, aby interpreter przetworzył go jako polecenie), a następnie zdefiniuj to polecenie, aby pominąć znak i zwiększyć licznik. Na końcu łańcucha wypisz tyle zer, ile zostało policzonych.

Zapisz to jako zero.texi podaj dane za pomocą wiersza polecenia za pomocą tego polecenia:

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

(Dodano nowe linie dla zachowania przejrzystości)

J, 4 bajty

/:0=

Wyjaśnienie:

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

Dzięki specyfikacji funkcja sortowania w J jest stabilna.

Alternatywne rozwiązanie, 6 bajtów:

#{.*#+

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

Słoma , 30 29 bajtów

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

Użyj kodowania CP437

Wyjaśnienie

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

Wypróbuj online! (Dodany kod służy do testowania wszystkich przypadków testowych)

JavaScript ES6, 16 bajtów

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

Działa na Firefox

Ruby , 25 bajtów

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

Wypróbuj online!

05AB1E , 15 14 bajtów

Kod:

ED0¢r0KR`rFZ}|

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252. Przyjmuje tablicę taką jak ta:

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