Задача проста: собрать массив целых. Консолидация этого массива состоит из следующего:

• Все экземпляры 0 должны быть перемещены в конец массива.
• Между ненулевыми целыми числами не должно быть нулей.
• Все ненулевые индексы должны сохранять свой порядок.

Вызов

Консолидация массива в наименьшем количестве байтов.

Вы объединяете массив случайной длины размером до максимума вашего языка со случайными целыми числами. Ввод может быть любым естественным способом для вашего языка.

Примеры

вход

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

Выход

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

вход

-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

Выход

-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

Пример кода (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 байта

!DQ

Объяснение:

  Q    Input
!D     Sort by logical NOT

Попробуй это здесь .

Желе, 3 байта

¬Ụị

Сортирует список по логическому НЕ его значений. Попробуйте онлайн!

Как это работает

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

Октава, 18 байт

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

sort()занимает слишком много байтов. Я просто буду использовать логическую индексацию.

Примеры на идеоне .

R, 29 23 21 байт

Как отмечает MarcoBreitig, мы можем сократить его до 21 байта, если нам не нужно предоставлять его как функцию:

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

Предыдущие версии:

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

Функция принимает вектор в качестве входных данных и упорядочивает их по логическому вектору, который возникает в результате отрицания входных данных.

Оригинальный ответ:

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

Функция принимает вектор в качестве входных данных и сцепляет ( c()) ненулевые значения, а затем нулевые значения.

Сетчатка , 15

Простая повторная подстановка регулярных выражений:

+`\b0 (.*)
$1 0

Попробуйте онлайн.

ES6, 23 байта

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

Раньше sortбыл нестабильный случай, и в этом случае вам нужно было 41 байт:

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

Байт-код Python (2.7.9), 252 байта, 33 кода операции, 0,0228 секунды

Это был построен , когда конкурс был еще самый быстрый код конкурса

Открывает файл в текущем каталоге 'SourceArray'для использования

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(Фактический кодовый бит)

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

Или версия файла .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

Вы можете попробовать скомпилировать мой исходный код самостоятельно, используя мою библиотеку на github. Я только что опубликовал коммит, который позволял комментировать, так что я надеюсь, что он все еще конкурирует, насколько быстрым является код ;)

Примерно эквивалентно

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 байта

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

Принимает аргумент как любой итеративный (список, кортеж и т. Д.). Спасибо @xnor за то, что научили меня новому трюку!

Matlab: 21 байт

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

Сначала печатает ненулевые элементы, затем объединяет с нулевыми элементами

@(a)____ создать анонимную функцию с одним входным аргументом a

[___,___] объединяет горизонтальные векторы внутри скобок, разделенных запятыми

a(a~=0) возвращает вектор со всеми ненулевыми элементами вектора a

a(a==0) возвращает вектор со всеми нулевыми элементами вектора a

Haskell, 26 байтов

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

Возьмите все ненулевые числа, за которыми следуют все нули. Фильтрация констант (здесь: 0) является довольно коротким, используя список понимание: [0|0<-x].

Zsh, 22 байта

(входные данные передаются в качестве аргументов скрипту / функции ( $@или $argvмассиву), вывод на стандартный вывод в виде списка, разделенного пробелами, перевод строки завершается)

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

• <<< string: здесь-строка здесь передается как стандартная $NULLCMDкоманда ( catпо умолчанию).
• ${@:#0} $@ за исключением того, что элементы равны 0.
• ${(M)@:#0} обратное из вышеизложенного

Это предполагает (как и некоторые другие ответы здесь), что все нули на входе выражаются как 0(нет, 00ни, 0x0ни 36#0).

Javascript, 52 54 51 байт

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

Mathematica, 14 байтов

Sort[#,#!=0&]&

APL: 8 байт

(⍴a)↑a~0

~ 0 удалить нули из (читать «без 0»)
(⍴a) исходной длины (читай «shape of»)
↑ дополняет a без нулей до первоначальной длины a

Попробуй это в http://ngn.github.com/apl/web/index.html

Данные испытаний: a ← 1 0 1 2 3 4 0 1 0 0 0 0 1 2 3 4 5

Java 7, 78 байт

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

Я не уверен, почему другие записи Java используют строки. Если вы хотите отфильтровать целочисленный массив, лучше всего использовать целочисленный массив. Это изменяет ввод на месте, сохраняя два индекса, а затем просто заполняя оставшиеся слоты нулями.

Common Lisp, 46 байт

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

Сортируйте массив так, чтобы для каждой пары (a, b) у нас было a <b, если b равно нулю. Когда ни <b, ни b <a , сортировка стабильна: исходный порядок между элементами сохраняется.

Я также попытался с помощью configure-array и remove , но это было слишком долго:

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

PHP, 73 71 70 52 49 48 46 байт - БОЛЬШОЕ благодаря Исмаилу Мигелю

// 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, 23

grep -v ^0 a
grep ^0 a

Предполагается, что ввод - это разделенные новой строкой записи в файле с именем a. Оценка включает +1 для этого имени файла.

Perl 5, 26 байт

23 плюс три за -an( -Eбесплатно)

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

Спасибо Деннису за напоминание о том -a, что он спас два байта.

CJam, 6 байтов

{{!}$}

Анонимная функция. Сортировка с использованием «является ли элемент нулем» в качестве ключа.

MATL , 7 байт

t~FT#S)

Попробуйте онлайн!

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

Серьезно, 12 байт

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

Попробуйте онлайн!

Объяснение:

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

Свифт , 13 байт

a.sort{$1==0}

Perl6, 11 байт

{.sort(!*)}

Создает блок - который можно вызвать в массиве:

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

Хотя было бы более естественно (и короче) написать:

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

Как это работает: если процедура сортировки perl6 вызывается с блоком, который принимает только один аргумент, элементы списка сортируются в соответствии с by($a) cmp by($b). В этом случае блок является !*, т. Е. Отрицанием любого оператора .

Я замечаю, что:

• Примером в вопросе является класс, который предоставляет метод, не включая шаблон, необходимый для чтения в
• Описание задачи не требует печати, и, за исключением того, что пример печатает, подразумевает, что массив может быть возвращен

TeX (простой формат), 160 байт

Сделайте 0символ активным (то есть заставьте интерпретатор обработать его как команду), затем определите эту команду, чтобы пропустить символ и увеличить счетчик. В конце строки выведите столько нулей, сколько было подсчитано.

Сохраните это как zero.texи передайте ввод через командную строку с этой командой:

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

(Новые строки добавлены для ясности)

J, 4 байта

/:0=

Объяснение:

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

Функция сортировки в J гарантированно будет стабильной согласно спецификации.

Альтернативное решение, 6 байтов:

#{.*#+

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

Солома , 30 29 байт

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

Используйте кодировку CP437

объяснение

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

Попробуйте онлайн! (Добавлен код для проверки всех тестовых случаев)

JavaScript ES6, 16 байт

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

Работает на Firefox

Рубин , 25 байт

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

Попробуйте онлайн!

05AB1E , 15 14 байтов

Код:

ED0¢r0KR`rFZ}|

Объяснение:

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

Использует кодировку CP-1252. Принимает массив как это:

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