골

함수 또는 프로그램을 작성하여 2 진 표현에있는 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 비트 정수의 배열입니다.

산출

설명에 따라 정렬 된 동일한 정수 배열.

채점

1 주일에 최소 바이트 수를 선택하는 코드 골프입니다.

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: 각 행
• #:: 이진 표현

자바 스크립트, 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가 0이면 반환합니다 x-y(x가 0이면 음수, y가 0이면 양수). 그렇지 않으면 x&x-1x와 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

key = lambda x… 제안에 대한 @Bakuriu 에게 감사드립니다 . ;디

자바 스크립트 [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 년 후] 또는 원하는 경우 48 바이트의 람다 (@KevinCruijssen 덕분에 제안) 일 수 있습니다.

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

배쉬 / 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

'a'로 입력

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

음수가 아닌 숫자에 적용됩니다.

C-85 바이트 (108 106 바이트)

__builtin_popcount사용 가능한 모든 GCC / Clang / Portable 버전 (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다른 C 답변과 마찬가지로 휴대용 버전으로 하드 코드를 작성하여 다른 7자를 저장할 수 있습니다. 길이 사용률 측면에서 어느 것이 가장 가치가 있는지 잘 모르겠습니다.

PowerShell v3, 61 58 53

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

Sort-Objectcmdlet 의 ScriptBlock 은 숫자의 이진 표현으로 각 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 바이트

J.Doe의 구현 덕분에 -20 Giuseppe 덕분에 -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)]

Sum Method에colSums 의해 생성 된 이진 행렬로 열을 추가하는 대신 "완료" sapply전에 열의 요소를 추가했습니다 sapply.

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

레브로 감소 정말 감소 단축 싶었지만, 나 한테 R의 울음 소리가 나는 단축하려고하면 decreasing에 order순서대로 원하는 얻을 필요했다 기능, order증가 기본값은 다음 내가 기억 rev하는 벡터를 반전하는 기능. 유레카!!! 최종 솔루션의 마지막 변경은 2 바이트를 더 절약하는 것이 었 function습니다pryr::f

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

하스켈, 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)

이것이 내가 이것을 해결하려고 생각한 첫 번째 방법이지만 더 좋은 방법이 있다고 확신합니다. 또한 하스켈 수입품을 골프로 파는 방법을 알고 있다면 그 소식을 듣고 싶습니다.

예

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

Ungolfed 버전 (설명 포함)

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)

커피 스크립트 (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 / 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 메인 프레임 정렬 제품) 288 (각 소스 행은 72 자이며 위치 1에 공백이 있어야 함)

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

편집 : 내림차순으로 문자를 추가합니다.

자바 스크립트 84

다른 자바 스크립트 답변에서 영감을 얻었지만 eval과 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));

자바 스크립트 (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에 일치하는 값을 선택하여 쉽게 수행 할 수 있습니다. (O (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}

하지만 그 , 포스트 스크립트와는 달리, 쉽게 golfed 할 수 있습니다 :

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>로 변환 한 다음 함수 참조 ( 또는 보다 짧은)를 Stream<Integer>사용하여 a 로 변환 한 다음 정렬 하여 배열에 넣고 인쇄하여 작동합니다.Integer::decodeparseIntvalueOfInteger::bitCount

스트림은 모든 것을 더 쉽게 만듭니다.