Завдання просте: консолідувати масив ints. Консолідація цього масиву складається з наступного:

• Усі екземпляри 0 потрібно перемістити до кінця масиву.
• Між ненульовими цілими числами не повинно бути 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()займає занадто багато байтів. Я просто використовувати логічне індексування.

Приклади на ideone .

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

co_code(Фактичний біт 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'

Або версія файлу .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,

Пітон, 32 байти

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

Приймає аргумент як будь-який ітерабельний (список, кортеж тощо). Дякую @xnor за те, що навчив мене новій хитрість!

Матлаб: 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масив), вихід у stdout як список, розділений пробілом, новий рядок закінчується)

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

• <<< string: тут-рядок тут передається як stdin до $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)

Математика, 14 байт

Sort[#,#!=0&]&

APL: 8 байт

(⍴a)↑a~0

a ~ 0 видалити нулі з (прочитати "a без 0")
(⍴a) початкової довжини (read "форма a")
↑ pad 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 використовують рядки. Якщо ви хочете відфільтрувати цілий масив, здається, найкраще використовувати цілий масив. Це змінює вхід на місці, зберігаючи два індекси, а потім просто заповнюючи решта слотів нулями.

Лист звичайний, 46 байт

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

Сортуйте масив так, що для кожної пари (a, b) маємо a <b, якщо b дорівнює нулю. Якщо ні a <b, ні b <a , сортування є стабільним: початковий порядок між елементами зберігається.

Я також спробував налаштувати масив та видалити , але це було занадто довго:

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