按二进制1的计数对数字排序


35

目标

编写函数或程序,将整数数组按其二进制表示形式中存在的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位整数数组。

输出量

按描述排序的相同整数的数组。

计分

这是在一周内要选择的最少字节数的代码高尔夫球。


2
您没有明确提及,但是否需要按降序排列?
尼克T

3
你说得对,我想念那件事。其他人都顺带走了,所以我们会坚持下去。
Hand-E-Food

我认为最终数字(21826)转换错误。根据我的Windows计算器,它是0101 0101 0100 0010,不是0010 1010 1100 0010
Nzall

感谢您的更正。大约21826很奇怪,因为我使用Excel将数字转换为二进制。我想知道其余的。
Hand-E-Food

使用汇编和弹出计数指令的解决方案?
eiennohito 2014年

Answers:


27

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:每行
  • #::二进制表示

5
@ ak82是APL的ASCII版本
John Dvorak

3
@JanDvorak; 进行了很多更改:jsoftware.com/papers/j4apl.htm(请参阅语言部分)。
James Wood

3
\:1#.#:可以节省一些字节。
2016年

17

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为0,则返回x-y(如果x为零,则为负数;如果y为零,则为正数)。否则,它将x&x-1从x和y中删除最低位()并重复。

先前版本(42)

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

这真的很聪明!我仍在努力将其包裹住。
mowwwalker 2014年

不应该~y代替-!y吗?
牙刷

@toothbrush结束条件是x或y为0,在这种情况下表达式!x|-!y变为非零。~并不适合,因为许多输入(包括零)为非零
复制

如果需要二次分类,有人可以帮助我吗?
Manubhargav

15

红宝石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]

2
简单。可以理解的 短。此解决方案的荣誉。
皮埃尔·阿洛德

8

Python 3(44):

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

8

常见的Lisp,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))

7

Python 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


这样,0它将永远是您输出的一部分;那是不对的。
daniero

我在问题中没有看到任何禁止我插入值的内容。
Jetlef

我这样做:“ 按描述的顺序排列相同整数的数组。” ;)此外,为什么不仅仅使用raw_input()和删除一些字符呢?
daniero 2014年

1
@daniero修复了它。切换到Python 3(已经存在Python 2的答案,必须要有创意!)使我可以使用input(),保存两个字符(由于print()需要括号,因此要添加两个字符)。
Jetlef

您可以[]放入内部sorted。同样,该程序的输出是输入中已排序的数字中的1的数量,但是您应该输出输入中接收到的数字,并使用1s 的数量进行排序。像:print(sorted(input().split(), key=lambda x:bin(int(x)).count('1')))会是正确的。
Bakuriu 2014年

7

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]

你能告诉我如何..运作吗?我的理解是,如果x = 5这样eval(x + r)变成eval(5..toString(2).match(/1/g).length)无效,我想那是无效的。谢谢。
Gaurang Tandon

1
@GaurangTandon不是。如您所知,在JS中,除了文字之外的所有东西都是一个对象。和数字。因此,从理论上(和实际上),您可以像通过'string'.length或那样通过点符号获取任何非文字的属性或调用方法[1,2,3].pop()。如果是数字,您可以这样做,但是要记住,在单点之后,解析器将寻找期望浮点值的数字的小数部分(如所示123.45)。如果您使用整数,则应“告诉”解析器小数部分为空,请在处理属性之前设置一个额外的点:123..method()
2014年

1
您可以通过去除零并将其余部分视为十进制数字来节省两个字节。替换match(/1/g).lengthreplace(/0/g,"")
DocMax 2014年

@VisioN谢谢!学到了新东西。
Gaurang Tandon 2014年

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

6

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


6

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

5

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


我很喜欢在高尔夫球代码中使用Tr [](ab?)。
2014年

5

Java 8-87/ 113 81/111 60/80 60/74/48个字符

这不是一个完整的Java程序,它只是一个函数(准确地说是一个方法)。

它假定java.util.Listjava.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年后]或者,如果您愿意,也可以是lambda(感谢@KevinCruijssen的建议),具有48个字节:

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

您为什么不能这样做Integer.bitCount(x)<Integer.bitCount(y)?-1:1;?您需要这种-1,0,1行为吗?
贾斯丁

另外,是否可以<Integer>用空格代替?
贾斯汀

您也可以使用Long,以节省一些空间:)
RobAu 2014年

另外 a.sort((x,y)->Long.bitCount(x)-Long.bitCount(y));
RobAu 2014年

1
@KevinCruijssen谢谢。我非常习惯使用变量实例调用静态方法是一种不好的做法,我曾经忘记编译器会接受它。
Victor Stafusa

4

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

您可以更改sum(int(d)for d in bin(x)[2:])sum(map(int,bin(x)[2:]))
Elisha 2014年

1
甚至:print sorted(input(),key=lambda x:-bin(x).count('1'))
以利沙

4

Matlab,34岁

输入“ a”

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

适用于非负数。


4

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像其他C答案一样在便携式版本中硬编码以保存另外7个字符。我不确定就长度-可用性比率而言,哪一个最有价值。


2
sizeof l保存一个字节。可怕的丑陋#define p-__builtin_popcount(可以帮助拯救另一个。
ugoren 2014年

@ugoren感谢您的提示!预处理器就是这样的hack,我不知道这样的事情是可能的。遗憾的是,它在MSVC上不起作用,但是每个字节都很重要!
2014年

4

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

是工作。它是如何工作的?魔法如何。谈到“基于数组的长度”?
mazzy

“。” 执行其后的脚本块。sort命令根据外部脚本块的输出进行排序。我现在意识到不需要内部脚本块。看到编辑
Rynant

$f={是多余的while-> for-band1-> %2-des-> -d和其他高尔夫技巧。很明显。你能解释一下如何工作$args|sort{@(1,1,...,1)}吗?是工作!排序如何比较没有显式的数组.Count?在哪里阅读?谢谢!
mazzy

1
@mazzy,您是对的,我现在删除了多余的位。这是Sort-Object cmdlet的默认排序。请参阅:help Sort-Object -Parameter property我不知道类型的默认排序属性在哪里定义,但是对于数组,它是Count或Length。
雷纳特

不错的猜测。但是$args|sort{while($_){if($_-band1){$_};$_=$_-shr1}}-des给出了错误的结果。因此,不是Count。非常有趣 再次感谢。
mazzy

3

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]

谢谢,牙刷为您提供了更短的解决方案。


1
我刚刚尝试了您的解决方案,但没有成功。它不会对数字进行排序。
牙刷

@牙刷汪汪。感谢您抓住这一点,现在应该可以工作。
Danny

做得好!我喜欢。
牙刷

1
只有61个字节:(z.sort((a,b)=>{c=d=e=0;while(++c<32)d+=a>>c&1,e+=b>>c&1},e-d)并感谢您的投票)。
牙刷

1
我的解决方案现在与您的尺寸相同!
牙刷

3

R132 96 94 88 84 75 73 53 51字节

-20多亏了J.Doe的实现--2多亏了Giuseppe

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

下降到启我真的想缩短减少,但在我[R叫声,如果我尽量缩短decreasingorder功能,这是必要的,以获得所需的顺序作为order违约增加,然后我想起了rev功能逆转的向量。EUREKA !!!最终解决方案中的最后一个更改是functionpryr::f多保存2个字节

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


1
@ J.Doe的出色高尔夫提高了51个字节
朱塞佩

2

哈斯克尔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)

这是我想解决此问题的第一种方法,但我敢打赌,有更好的方法可以解决此问题。另外,如果有人知道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)

这将有助于使用中缀记号modn`mod`2?它具有与乘法和除法相同的优先级。
约翰·德沃夏克

据我所知,由于打高尔夫球的原因,这并不太有用。我会损失两个空格,但会增加两个反引号,对吗?
danmcardle 2014年

导入Data.List;导入Data.Ord;导入Data.Bits; q = sortBy(比较popCount)-80C-或使用您的方法,导入Data.List;导入Data.Ord; b 0 = 0; bn = {mod n 2)+ b(div n 2); q = sortBy(比较b)
-86C

我试着完全避免进口,通过打高尔夫球的快速排序,我能管理的最好是87C:b 0 = 0; bn = mod n 2 + b(div n 2); q [] = []; q(a:c)= f( (ba>)。b)c ++ a:f((ba <=)。b)c; f =(q。)。filter
bazzargh 2014年

2

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

2

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

2

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
)

好吧,有人 不得不打扰PHP
Einacio 2014年


2

DFSORT(IBM Mainframe分类产品)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降序更改的结果。仅使用整数创建排序文件。


2

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

4
由于这是一场代码高尔夫比赛,因此您应该尝试缩短代码。
Timtech,2014年

2

C#,88 89

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

编辑:降序添加一个字符。


2

Java脚本 84

受其他javascript答案启发,但没有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));

问题是代码打高尔夫球,请尝试“使用”您的代码:删除不必要的空格,并尝试使代码尽可能小。另外,在答案中包含一个字符数。
ProgramFOX

2

Java语言(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})

2

后记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}

后记!我的初恋,我有史以来最喜欢的语言!很高兴见到另一位相信一种真正编程语言的人。
AJMansfield

2

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

2

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

如您所见,这可以通过将转换argsStream<String>,然后转换为来实现Stream<Integer>使用Integer::decode函数引用(比parseInt或短,valueOf),然后按Integer::bitCount,然后将其放入数组中并打印出来来实现。

流使一切变得容易。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.