Мета

Написати функцію або програму сортувати масив цілих чисел у порядку зменшення за кількістю присутніх 1 у їх бінарному поданні. Умови вторинного сортування не потрібні.

Приклад відсортованого списку

(використовуючи 16-бітні цілі числа)

  Dec                Bin        1's
16375   0011111111110111        13
15342   0011101111101110        11
32425   0111111010101001        10
11746   0010110111100010         8
28436   0000110111110100         8
19944   0100110111101000         8
28943   0000011100011111         8
 3944   0000011111101000         7
15752   0011110110001000         7
  825   0000000011111001         6
21826   0101010101000010         6

Вхідні дані

Масив 32-бітних цілих чисел.

Вихідні дані

Масив із тих самих цілих чисел, відсортований, як описано.

Оцінка балів

Це кодовий гольф для вибору найменшої кількості байтів за тиждень.

J (11)

(\:+/"1@#:)

Це функція, яка бере список:

     (\:+/"1@#:) 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

Якщо ви хочете дати йому ім'я, це коштує одного додаткового символу:

     f=:\:+/"1@#:
     f 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
16375 15342 32425 28943 11746 28436 19944 3944 15752 825 21826

Пояснення:

• \:: вниз сортувати на
• +/: сума
• "1: кожен ряд
• #:: бінарне представлення

JavaScript, 39

Оновлення: тепер коротше, ніж Ruby.

x.sort(q=(x,y)=>!x|-!y||q(x&x-1,y&y-1))

40

x.sort(q=(x,y)=>x&&y?q(x&x-1,y&y-1):x-y)

Пояснення:

q - рекурсивна функція. Якщо x або y x-yдорівнює 0, воно повертається (від’ємне число, якщо x дорівнює нулю, або додатне число, якщо y дорівнює нулю). В іншому випадку він видаляє найнижчий біт ( x&x-1) з x і y і повторюється.

Попередня версія (42)

x.sort(q=(x,y)=>x^y&&!x-!y+q(x&x-1,y&y-1))

Рубін 41

f=->a{a.sort_by{|n|-n.to_s(2).count(?1)}}

Тест:

a = [28943, 825, 11746, 16375, 32425, 19944, 21826, 15752, 15342, 3944, 28436];
f[a]
=> [16375, 15342, 32425, 11746, 28436, 28943, 19944, 15752, 3944, 21826, 825]

Пітон 3 (44):

def f(l):l.sort(lambda n:-bin(n).count('1'))

Звичайний Лісп, 35

logcountповертає число 'on' -бітів у числі. Для переліку у lнас є:

(sort l '> :key 'logcount)

CL-USER> (sort (list 16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826) '> :key 'logcount)
;=> (16375 15342 32425 11746 28436 19944 28943 3944 15752 825 21826)

Як окрема функція, і на чому я буду базувати байт:

(lambda(l)(sort l'> :key'logcount))

Пітон 3, 90 77 72 67 символів.

Наше рішення приймає введення з командного рядка і друкує число у порядку зменшення (67 символів) або за зростанням (66).

У порядку зменшення

print(sorted(input().split(),key=lambda x:-bin(int(x)).count("1"))) # 67

Дякуємо @daniero за пропозицію використовувати мінус у рахунку 1, щоб повернути його назад, а не використовувати фрагмент для зворотного перегляду масиву в кінці! Це ефективно зберегло 5 символів.

Тільки заради опублікування, версія висхідного замовлення (яка була першою, яку ми зробили) матиме на один символ менше.

Висхідне замовлення :

print(sorted(input().split(),key=lambda x:bin(int(x)).count("1"))) # 66

Дякуємо @Bakuriu за пропозицію key = lambda x… . ; D

JavaScript [76 байт]

a.sort(function(x,y){r='..toString(2).split(1).length';return eval(y+r+-x+r)})

де aвхідний масив чисел.

Тест:

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(function(x, y) {
    r = '..toString(2).split(1).length';
    return eval(y + r + -x + r);
});

[16375, 15342, 32425, 19944, 11746, 28943, 28436, 15752, 3944, 21826, 825]

Математика 30

SortBy[#,-DigitCount[#,2,1]&]&

Використання:

SortBy[#,-DigitCount[#,2,1]&]&@
                           {19944,11746,15342,21826,825,28943,32425,16375,28436,3944,15752}

{16375, 15342, 32425, 11746, 19944, 28436, 28943, 3944, 15752, 825, 21826}

k [15 символів]

{x@|<+/'0b\:'x}

Приклад 1

{x@|<+/'0b\:'x}19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752

16375 15342 32425 28436 28943 11746 19944 15752 3944 825 21826

Приклад 2 (усі числа 2 ^ n -1)

{x@|<{+/0b\:x}'x}3 7 15 31 63 127

127 63 31 15 7 3

Математика 39

IntegerDigits[#,2] перетворює базове 10 число в список 1-х та 0-х.

Tr підсумовує цифри.

f@n_:=SortBy[n,-Tr@IntegerDigits[#,2]&]

Тестовий випадок

f[{19944, 11746, 15342, 21826, 825, 28943, 32425, 16375, 28436, 3944, 15752}]

{16375, 15342, 32425, 11746, 19944, 28436, 28943, 3944, 15752, 825, 21826}

Java 8 - 87/113 81/111 60/80 60/74/48 символів

Це не повна програма Java, це лише функція (метод, якщо бути точним).

Він передбачає, що java.util.Listі java.lang.Long.bitCountімпортується, і має 60 символів:

void s(List<Long>a){a.sort((x,y)->bitCount(x)-bitCount(y));}

Якщо попередньо імпортовані матеріали не дозволені, тут він містить 74 символи:

void s(java.util.List<Long>a){a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

Додайте ще 7 символів, якщо потрібно, щоб це було static.

[4 роки пізніше] Або якщо ви віддаєте перевагу, це може бути лямбда (спасибі @KevinCruijssen за пропозицію), з 48 байтами:

a->{a.sort((x,y)->x.bitCount(x)-x.bitCount(y));}

Python 2.x - 65 символів (байт)

print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))

Це насправді 66 символів, 65 якщо ми зробимо це функцією (тоді вам потрібно щось назвати, що є ламерним для подання).

f=lambda a:sorted(a,key=lambda x:-sum(int(d)for d in bin(x)[2:]))

Демо в Bash / CMD:

echo [16, 10, 7, 255, 65536, 5] | python -c "print sorted(input(),key=lambda x:-sum(int(d)for d in bin(x)[2:]))"

Матлаб, 34

Введення в "а"

[~,i]=sort(-sum(dec2bin(a)'));a(i)

Працює для негативних чисел.

C - 85 байт (108 106 байт)

Портативна версія на GCC / Clang / там, де __builtin_popcountдоступна (106 байт):

#define p-__builtin_popcount(
c(int*a,int*b){return p*b)-p*a);}
void s(int*n,int l){qsort(n,l,sizeof l,c);}

Ультраконденсована, непереносна, ледь функціональна версія MSVC (85 байт):

#define p __popcnt
c(int*a,int*b){return p(*b)-p(*a);}
s(int*n,int l){qsort(n,l,4,c);}         /* or 8 as needed */

• Перший новий рядок, включений до підрахунку байтів через інші #define, інші не потрібні.

• Функція для виклику s(array, length)відповідає технічним умовам.

• Можна жорсткий код sizeofу портативній версії, щоб зберегти ще 7 символів, як це робило кілька інших відповідей C. Я не впевнений, який з них найбільше вартий з точки зору співвідношення довжини та зручності, ви вирішите.

PowerShell v3, 61 58 53

$args|sort{while($_){if($_-band1){1};$_=$_-shr1}}-des

ScriptBlock для Sort-Objectкомандлета повертає масив 1 на кожен 1 у двійковому поданні числа. Sort-Objectсортує список на основі довжини масиву, що повертається для кожного числа.

Для виконання:

script.ps1 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944

ECMAScript 6, 61

Припускає, що zце вхід

z.sort((a,b)=>{c=d=e=0;while(++c<32)d+=a>>c&1,e+=b>>c&1},e-d)

Дані тесту

[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort(
    (a,b)=>{
        c=d=e=0;
        while(++c<32)
            d+=a>>c&1,e+=b>>c&1
    },e-d
)

[16375, 15342, 32425, 11746, 19944, 28436, 28943, 15752, 3944, 21826, 825]

Дякую, зубна щітка за коротше рішення.

R , 132 96 94 88 84 75 73 53 51 байт

-20 завдяки реалізації J.Doe ще -2 завдяки Джузеппе

function(x)x[order(colSums(sapply(x,intToBits)<1))]

Моя оригінальна публікація:

pryr::f(rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))]))

Спробуйте в Інтернеті!

Я спробував кілька різних методів, перш ніж дійти до цього результату.

Матричний метод: Створено матрицю з двома стовпцями, один стовпець з вхідним вектором, одну з суми двійкового подання, потім я відсортував за сумою двійкового.

function(x){m=matrix(c(x,colSums(sapply(x,function(y){as.integer(intToBits(y))}))),nc=2,nr=length(x));m[order(m[,2],decreasing=T),]}

Нематрична: Усвідомлена Я могла викинути матричну функцію і замість цього створити вектор бінарних значень, підсумувати їх, упорядкувати їх, а потім використати впорядковані значення для зміни порядку введення вектора.

function(x){m=colSums(sapply(x,function(y){as.integer(intToBits(y))}));x[order(m,decreasing=T)]}

Незначні зміни

function(x){m=colSums(sapply(x,function(y)as.double(intToBits(y))));x[order(m,decreasing=T)]}

Більш незначні зміни Перетворення всієї речі в один рядок коду замість двох розділених крапкою з комою.

function(x)x[order(colSums(sapply(x,function(y)as.double(intToBits(y)))),decreasing=T)]

Метод підсумовування Замість того, щоб додавати стовпці із colSumsствореної компанією двійкової матриці sapply, я додав елементи в стовпчик перед sapply"завершеним".

function(x)x[order(sapply(x,function(y)sum(as.double(intToBits(y)))),decreasing=T)]

Зниження до Rev I дуже хотів скоротити зменшується, але R пронизливих у мене , якщо я намагаюся скоротити decreasingв orderфункції, яка необхідна для того, щоб отримати замовлення бажано , як по orderзамовчуванням для збільшення, то я згадав revфункцію зворотного вектора. EUREKA !!! Остання зміна в остаточному рішенні було functionдо , pryr::fщоб зберегти більше 2 байта

function(x)rev(x[order(sapply(x,function(y)sum(as.double(intToBits(y)))))])

Хаскелл, 123С

import Data.List
import Data.Ord
b 0=[]
b n=mod n 2:b(div n 2)
c n=(n,(sum.b)n)
q x=map fst$sortBy(comparing snd)(map c x)

Це перший спосіб, коли я вирішив вирішити це, але я думаю, що є кращий спосіб зробити це. Крім того, якщо хтось знає про спосіб імпорту гольфу в Haskell, мені було б дуже цікаво почути це.

Приклад

*Main> q [4,2,15,5,3]
[4,2,5,3,15]
*Main> q [7,0,2]
[0,2,7]

Негольована версія (з поясненнями)

import Data.List
import Data.Ord

-- Converts an integer into a list of its bits
binary 0 = []
binary n = mod n 2 : binary (div n 2)

-- Creates a tuple where the first element is the number and the second element
-- is the sum of its bits.
createTuple n = (n, (sum.binary) n)

-- 1) Turns the list x into tuples
-- 2) Sorts the list of tuples by its second element (bit sum)
-- 3) Pulls the original number out of each tuple
question x = map fst $ sortBy (comparing snd) (map createTuple x)

CoffeeScript (94)

Читаний код (212):

sort_by_ones_count = (numbers) ->
  numbers.sort (a, b) ->
    a1 = a.toString(2).match(/1/g).length
    b1 = b.toString(2).match(/1/g).length
    if a1 == b1
      0
    else if a1 > b1
      1
    else
      -1

console.log sort_by_ones_count [825, 3944, 11746, 15342, 15752, 16375, 19944, 21826, 28436, 28943, 32425]

Оптимізовано (213):

count_ones = (number) -> number.toString(2).match(/1/g).length
sort_by_ones_count = (numbers) -> numbers.sort (a, b) ->
  a1 = count_ones(a)
  b1 = count_ones(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

Омразнення (147):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  if a1 == b1 then 0 else if a1 > b1 then 1 else -1

Тернальні оператори надмірно довгі (129):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (0+(a1!=b1))*(-1)**(0+(a1>=b1))

Занадто довго, перестаньте лити (121):

c = (n) -> n.toString(2).match(/1/g).length
s = (n) -> n.sort (a, b) ->
  a1 = c(a)
  b1 = c(b)
  (-1)**(a1>=b1)*(a1!=b1)

Фінал (94):

c=(n)->n.toString(2).match(/1/g).length
s=(n)->n.sort((a, b)->(-1)**(c(a)>=c(b))*(c(a)!=c(b)))

Smalltalk (Smalltalk / X), 36 (а може і 24)

введення в а; деструктивно сортує в:

a sort:[:a :b|a bitCount>b bitCount]

функціональна версія: повертає новий відсортований масив:

a sorted:[:a :b|a bitCount>b bitCount]

є навіть більш короткий варіант (передача імені або функції в якості аргументу) в 24 символів. Але (зітхаючи) це буде сортувати останнє. Як я зрозумів, про це не вимагали, тому я не сприймаю це як оцінка гольфу:

a sortBySelector:#bitCount

PHP 5.4+ 131

Я навіть не знаю, чому я морочусь з PHP, в даному випадку:

<?unset($argv[0]);usort($argv,function($a,$b){return strcmp(strtr(decbin($b),[0=>'']),strtr(decbin($a),[0=>'']));});print_r($argv);

Використання:

> php -f sortbybinaryones.php 15342 28943 16375 3944 11746 825 32425 28436 21826 15752 19944
Array
(
    [0] => 16375
    [1] => 15342
    [2] => 32425
    [3] => 28436
    [4] => 19944
    [5] => 11746
    [6] => 28943
    [7] => 3944
    [8] => 15752
    [9] => 825
    [10] => 21826
)

Скала, 58

def c(l:List[Int])=l.sortBy(-_.toBinaryString.count(_>48))

DFSORT (сортування продукту IBM Mainframe) 288 (кожен рядок - 72 символи, повинен бути пробіл у першому положенні)

 INREC IFTHEN=(WHEN=INIT,BUILD=(1,2,1,2,TRAN=BIT)), 
       IFTHEN=(WHEN=INIT,FINDREP=(STARTPOS=3,INOUT=(C'0',C'')))
 SORT FIELDS=(3,16,CH,D) 
 OUTREC BUILD=(1,2)

Просто для розваги, і ніякої математики.

Бере файл (може бути виконаний з програми, яка використовувала "масив") з цілими числами. Перед сортуванням вона переводить цілі числа на біти (у поле з 16 символами). Потім змінює 0 в бітах ні на що. SORT Спад за результатом змінених бітів. Створює відсортований файл із лише цілими числами.

С

void main()
{
 int a[]={7,6,15,16};
 int b,i,n=0;
 for(i=0;i<4;i++)
 {  for(b=0,n=0;b<=sizeof(int);b++)
      (a[i]&(1<<b))?n++:n;   
    a[i]=n;
 }
 for (i = 1; i < 4; i++) 
  {   int tmp = a[i];
      for (n = i; n >= 1 && tmp < a[n-1]; n--)
         a[n] = a[n-1];
      a[n] = tmp;
  }    
}

C #, 88 89

int[] b(int[] a){return a.OrderBy(i=>-Convert.ToString(i,2).Count(c=>c=='1')).ToArray();}

Редагувати: у порядку зменшення додається символ.

Javascript 84

Натхненний іншими відповідями javascript, але без eval і регулярного вираження.

var r=(x)=>(+x).toString(2).split('').reduce((p,c)=>p+ +c)
[28943,825,11746,16375,32425,19944,21826,15752,15342,3944,28436].sort((x,y)=>r(x)-r(y));

Javascript (82)

a.sort(function(b,c){q=0;while(b|c){b%2?c%2?0:q++:c%2?q--:0;b>>=1;c>>=1}return q})

Постскрипт, 126

Оскільки список значень, за якими ми сортуємо, відомий заздалегідь і дуже обмежений (32), це завдання можна легко виконати, навіть якщо для сортування немає вбудованого, вибравши відповідні значення для 1..32. (Це О (32n)? Мабуть).

Процедура очікує масив у стеці та повертає "відсортований" масив.

/sort_by_bit_count {
    [ exch
    32 -1 1 {
        1 index
        {
            dup 2 32 string cvrs
            0 exch
            {48 sub add} forall
            2 index eq 
            {3 1 roll} {pop} ifelse
        } forall
        pop
    } for
    pop ]
} def

Або ритуально позбавлений білого простору та читабельності:

/s{[exch 32 -1 1{1 index{dup 2 32 string cvrs 0 exch{48 sub add}forall 2 index eq{3 1 roll}{pop}ifelse}forall pop}for pop]}def

Потім, якщо збережено до bits.psнього, можна використовувати так:

gs -q -dBATCH bits.ps -c '[(%stdin)(r)file 1000 string readline pop cvx exec] s =='
825 3944 11746 15342 15752 16375 19944 21826 28436 28943 32425
[16375 15342 32425 11746 19944 28436 28943 3944 15752 825 21826]

Я думаю, що це фактично те саме, що і цей Perl (тут ще немає Perl):

sub f{map{$i=$_;grep{$i==(()=(sprintf'%b',$_)=~/1/g)}@_}reverse 1..32}

Хоча це , на відміну від Postscript, можна легко переграти:

sub f{sort{j($b)-j($a)}@_}sub j{$_=sprintf'%b',@_;()=/1/g}

C - 124 111

Реалізовано як метод і використовує стандартну бібліотеку для сортування. Вказівник на масив та розмір повинні бути передані як параметри. Це буде працювати лише в системах з 32-бітовими вказівниками. У 64-бітних системах деякі символи повинні бути витрачені, вказуючи визначення вказівника.

Відступ для читабельності

c(int*a,int*b){
    int d,e,i;
    for(d=e=i=0;i-32;){
        d+=*a>>i&1;e+=*b>>i++&1;
    }
    return d>e?-1:d<e;
}
o(r,s){qsort(r,s,4,c);}

Приклад дзвінка:

main() {
    static int a[] ={1, 2, 3, 4, 5, 6, 7, 8, 9};
    o(a, 9);
}

Ява 8: 144

static void main(String[]a){System.out.print(Stream.of(a).mapToInt(Integer::decode).sorted(Comparable.comparing(Integer::bitCount)).toArray());}

У розгорнутому вигляді:

static void main(String[] args){
    System.out.print(
        Stream.of(args).mapToInt(Integer::decode)
              .sorted(Comparable.comparing(Integer::bitCount))
              .toArray()
        );
}

Як бачимо, це працює, перетворюючи в argsa Stream<String>, потім перетворюючи на a Stream<Integer>з Integer::decodeпосиланням на функцію (коротше parseIntабо valueOf), а потім сортує Integer::bitCount, потім кладе в масив і роздруковує.

Потоки полегшують все.