Mục tiêu

Viết hàm hoặc chương trình sắp xếp một mảng các số nguyên theo thứ tự giảm dần theo số lượng 1 trong biểu diễn nhị phân của chúng. Không có điều kiện sắp xếp thứ cấp là cần thiết.

Danh sách sắp xếp ví dụ

(sử dụng số nguyên 16 bit)

  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

Đầu vào

Một mảng các số nguyên 32 bit.

Đầu ra

Một mảng các số nguyên giống nhau được sắp xếp như mô tả.

Chấm điểm

Đây là mã golf cho số byte ít nhất được chọn trong một tuần.

J (11)

(\:+/"1@#:)

Đây là một chức năng có một danh sách:

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

Nếu bạn muốn đặt tên cho nó, bạn phải trả thêm một ký tự:

     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

Giải trình:

• \:: sắp xếp xuống
• +/: Tổng của
• "1: mỗi hàng của
• #:: biểu diễn nhị phân

JavaScript, 39

Cập nhật: Bây giờ ngắn hơn 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)

Giải trình:

q là một hàm đệ quy. Nếu x hoặc y bằng 0, nó trả về x-y(số âm nếu x bằng 0 hoặc số dương nếu y bằng 0). Mặt khác, nó loại bỏ bit thấp nhất ( x&x-1) khỏi x và y và lặp lại.

Phiên bản trước (42)

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

Ruby 41

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

Kiểm tra:

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]

Con trăn 3 (44):

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

Lisp thường gặp, 35

logcounttrả về số lượng 'on'-bit trong một số. Đối với một danh sách l, chúng tôi có:

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

Là một hàm độc lập và những gì tôi sẽ dựa vào số byte:

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

Con trăn 3 90 77 72 67 ký tự.

Giải pháp của chúng tôi lấy đầu vào từ dòng lệnh và in số theo thứ tự giảm dần (67 ký tự) hoặc tăng dần (66).

Thứ tự giảm dần

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

Cảm ơn @daniero , vì đã gợi ý sử dụng dấu trừ trong số 1 để đảo ngược nó, thay vì sử dụng một lát cắt để đảo ngược mảng ở cuối! Điều này có hiệu quả lưu 5 ký tự.

Chỉ vì mục đích đăng nó, phiên bản thứ tự tăng dần (là phiên bản đầu tiên chúng tôi thực hiện) sẽ mất ít hơn một ký tự.

Thứ tự tăng dần :

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

Cảm ơn @Bakuriu về gợi ý key = lambda x . ; D

JavaScript [76 byte]

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

trong đó alà một mảng đầu vào của số.

Kiểm tra:

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

Toán học 30

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

Sử dụng:

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 ký tự]

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

ví dụ 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

Ví dụ 2 (tất cả các số là 2 ^ n -1)

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

127 63 31 15 7 3

Toán học 39

IntegerDigits[#,2] chuyển đổi một số cơ sở 10 thành danh sách 1 và 0.

Tr tổng hợp các chữ số.

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

Trường hợp thử nghiệm

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 ký tự

Đây không phải là một chương trình java hoàn chỉnh, nó chỉ là một hàm (một phương thức, chính xác).

Nó giả định rằng java.util.Listvà java.lang.Long.bitCountđược nhập khẩu và có 60 ký tự:

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

Nếu không cho phép nhập trước nội dung, thì đây là 74 ký tự:

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

Thêm 7 ký tự nếu cần static.

[4 năm sau] Hoặc nếu bạn thích, đó có thể là lambda (cảm ơn @KevinCruijssen về đề xuất này), với 48 byte:

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

Python 2.x - 65 ký tự (byte)

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

Đó thực sự là 66 ký tự, 65 nếu chúng ta biến nó thành một hàm (sau đó bạn cần một cái gì đó để gọi nó là trình bày rõ hơn).

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

Bản trình diễn trong 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:]))"

Matlab, 34

Nhập vào 'a'

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

Làm việc cho các số không âm.

C - 85 byte (108 106 byte)

Phiên bản di động trên GCC / Clang / bất cứ nơi nào __builtin_popcountcó sẵn (106 byte):

#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);}

Phiên bản MSVC siêu đặc, không di động, hầu như không có chức năng (85 byte):

#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 */

• Dòng mới đầu tiên bao gồm số byte vì #define, những cái khác là không cần thiết.

• Chức năng để gọi là s(array, length)theo thông số kỹ thuật.

• Có thể mã hóa cứng sizeoftrong phiên bản di động để lưu thêm 7 ký tự, giống như một vài câu trả lời C khác đã làm. Tôi không chắc chắn cái nào đáng giá nhất về tỷ lệ sử dụng chiều dài, bạn quyết định.

PowerShell v3, 61 58 53

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

ScriptBlock cho Sort-Objectlệnh ghép ngắn trả về một mảng 1 cho mỗi 1 trong biểu diễn nhị phân của số. Sort-Objectsắp xếp danh sách dựa trên độ dài của mảng được trả về cho mỗi số.

Để thực hiện:

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

Bản thảo 6, 61

Giả sử zlà đầu vào

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

Dữ liệu kiểm tra

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

Cảm ơn, bàn chải đánh răng cho giải pháp ngắn hơn.

R , 132 96 94 88 84 75 73 53 51 byte

-20 cảm ơn việc triển khai của J.Doe -2 cảm ơn Giuseppe

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

Bài viết gốc của tôi:

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

Hãy thử trực tuyến!

Tôi đã thử một vài phương pháp khác nhau trước khi tôi nhận được kết quả này.

Phương pháp ma trận: Tạo một ma trận hai cột, một cột với vectơ đầu vào, một trong tổng của biểu diễn nhị phân, sau đó tôi sắp xếp trên tổng của nhị phân.

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),]}

Phi ma trận: Đã thực hiện Tôi có thể loại bỏ hàm ma trận và thay vào đó tạo ra một vectơ các giá trị nhị phân, tính tổng chúng, sắp xếp chúng, sau đó sử dụng các giá trị được sắp xếp để sắp xếp lại vectơ đầu vào.

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

Thay đổi nhỏ

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

Nhiều thay đổi nhỏ hơn Chuyển đổi toàn bộ điều thành một dòng mã thay vì hai phân tách bằng dấu chấm phẩy.

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

Phương pháp tính tổng Thay vì thêm các cột bằng colSumsma trận nhị phân được tạo bởi sapply, tôi đã thêm các phần tử trong cột trước khi sapply"kết thúc".

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

Giảm đến Rev Tôi thực sự muốn rút ngắn giảm, nhưng tiếng kêu quang quác R với tôi nếu tôi cố gắng rút ngắn decreasingtrong orderchức năng, đó là điều cần thiết để có được thứ tự mong muốn như ordermặc định là ngày càng tăng, sau đó tôi nhớ các revchức năng để đảo ngược một vector. EUREKA !!! Sự thay đổi cuối cùng trong giải pháp cuối cùng là functionđể pryr::ftiết kiệm hơn 2 byte

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

Haskell, 123C

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)

Đây là cách đầu tiên tôi nghĩ đến để giải quyết vấn đề này, nhưng tôi cá rằng có một cách tốt hơn để làm điều đó. Ngoài ra, nếu bất cứ ai biết về cách nhập khẩu golf Haskell, tôi sẽ rất thích nghe nó.

Thí dụ

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

Phiên bản Ungolfed (có giải thích)

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)

Cà phê (94)

Mã có thể đọc được (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]

Tối ưu hóa (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

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

Toán tử ternary quá dài (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))

Quá lâu, ngừng truyền (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)

Chung kết (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 (hoặc có thể 24)

đầu vào trong a; phá hủy sắp xếp trong một:

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

phiên bản chức năng: trả về một mảng được sắp xếp mới:

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

thậm chí còn có một biến thể ngắn hơn (truyền tên hoặc hàm làm đối số) trong 24 ký tự. Nhưng (thở dài) nó sẽ sắp xếp cao nhất cuối cùng. Theo tôi hiểu, điều này không được yêu cầu, vì vậy tôi không coi đó là điểm golf:

a sortBySelector:#bitCount

PHP 5,4+ 131

Tôi thậm chí không biết tại sao tôi bận tâm với PHP, trong trường hợp này:

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

Sử dụng:

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

Scala, 58

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

DFSORT (sản phẩm sắp xếp Mainframe của IBM) 288 (mỗi dòng nguồn là 72 ký tự, phải có khoảng trắng ở vị trí một)

 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)

Chỉ để cho vui, và không có toán học.

Lấy một tệp (có thể được thực thi từ một chương trình sử dụng "mảng") với các số nguyên. Trước khi sắp xếp, nó dịch các số nguyên thành bit (trong trường 16 ký tự). Sau đó thay đổi 0 trong bit thành không có gì. SORT Giảm dần trên kết quả của các bit thay đổi. Tạo tập tin được sắp xếp chỉ với các số nguyên.

C

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();}

Chỉnh sửa: thứ tự giảm dần thêm một ký tự.

Javascript 84

Lấy cảm hứng từ các câu trả lời javascript khác, nhưng không có eval và regex.

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

Bản thảo, 126

Vì danh sách các giá trị mà chúng tôi sắp xếp được biết trước và rất hạn chế (32), nên tác vụ này có thể được thực hiện dễ dàng ngay cả khi không có tích hợp để sắp xếp, bằng cách chọn các giá trị khớp cho 1..32. (Có phải là O (32n)? Có lẽ).

Thủ tục mong đợi mảng trên ngăn xếp và trả về mảng 'được sắp xếp'.

/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

Hoặc, nghi thức tước bỏ khoảng trắng và dễ đọc:

/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

Sau đó, nếu được lưu vào bits.psnó có thể được sử dụng như thế này:

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]

Tôi nghĩ rằng nó có hiệu quả tương tự như Perl này (cũng chưa có Perl ở đây):

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

Mặc dù vậy , không giống như Postcript, có thể dễ dàng đánh gôn:

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

C - 124 111

Được thực hiện như một phương thức và sử dụng thư viện chuẩn để sắp xếp. Một con trỏ tới mảng và kích thước phải được truyền dưới dạng tham số. Điều này sẽ chỉ hoạt động trên các hệ thống có con trỏ 32 bit. Trên các hệ thống 64 bit, một số ký tự phải được sử dụng để xác định các định nghĩa con trỏ.

Ấn định cho dễ đọc

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);}

Cuộc gọi mẫu:

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

Java 8: 144

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

Ở dạng mở rộng:

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

Như bạn có thể thấy, điều này hoạt động bằng cách chuyển đổi argsthành a Stream<String>, sau đó chuyển đổi sang a Stream<Integer>với Integer::decodetham chiếu hàm (ngắn hơn parseInthoặc valueOf), sau đó sắp xếp theo Integer::bitCount, sau đó đặt nó vào một mảng và in ra.

Luồng giúp mọi thứ dễ dàng hơn.