背景

整数的汉明权重是其二进制表示形式中的1的数量。对于此挑战，整数用32位表示，并且它们是无符号的。

挑战

给定0到2 ^ 32-1之间的整数（不包括在内），请在相同范围内以及汉明权重相同的情况下输出另一个整数。

例子

Input (Decimal) | Input (Binary) | Hamming weight | Possible output (Decimal)
       46       |   0b0010 1110  |       4        |      15
       12       |   0b0000 1100  |       2        |      3
        1       |   0b0000 0001  |       1        |      2
        3       |   0b0000 0011  |       2        |      6
      2^31      |   0b1000....0  |       1        |      1
      2^31+2    |   0b1000...10  |       2        |      3
      2^32-5    |   0b1111..011  |       31       |      2^31-1
      2^32-2    |   0b1111....0  |       31       |      2^31-1
        0       |   0b0000 0000  |       0        | None (This case need not be handled)
      2^32-1    |   0b1111....1  |       32       | None (This case need not be handled)

计分

这是代码高尔夫球，因此每种语言中以最少字节数表示的解决方案将获胜。

x86-64汇编，5 4字节

   0:   97                      xchg   %eax,%edi
   1:   d1 c0                   rol    %eax
   3:   c3                      retq   

使用C调用约定的函数，将其参数按位左移1位。

Python，20个字节

lambda x:x*2%~-2**32

按位旋转左一位。

MATL，9个字节

32&B1YSXB

将32位二进制表示形式向右循环移位一级。

在线尝试！

果冻，10 8字节

‘&~^^N&$

交换最低有效位和未设置位。

在线尝试！

怎么运行的

‘&~^^N&$  Main link. Argument: n

‘         Increment; yield n+1, toggling all trailing set bits and the rightmost
          unset bit.
  ~       Bitwise NOT; yield ~n, toggling ALL bits of n.
 &        Bitwise AND; yield (n+1)&~n, keeping the only bit that differs in n+1 and
          ~n, i.e., the rightmost unset bit.
   ^      Perform bitwise XOR with n, toggling the rightmost unset bit.
       $  Combine the two links to the left into a monadic chain.
     N        Negate; yield -n. Since ~n = -(n+1) in 2's complement, -n = ~n+1.
      &       Take the bitwise AND of n and -n. Since -n = ~n + 1 and n = ~~n, the
              same reasoning that applied for (n+1)&~n applies to -n&n; it yields
              the rightmost unset bit of ~n, i.e., the rightmost set bit of n.
    ^      XOR the result to the left with the result to the right, toggling the
           rightmost set bit of the left one.

JavaScript（ES6），35 31字节

查找第一个位转换（0→1或1→0）并将其反转。

f=(n,k=3)=>(n&k)%k?n^k:f(n,k*2)

演示版

f=(n,k=3)=>(n&k)%k?n^k:f(n,k*2)

;[ 46, 12, 255, 2**32-2 ]
.map(n => {
  r = f(n);
  console.log((n >>> 0), '=', (n >>> 0).toString(2), '-->', (r >>> 0), '=', (r >>> 0).toString(2));
})

位旋转，14个字节

短得多，但乐趣却更少。

n=>n>>>31|n<<1

演示版

let f =

n=>n>>>31|n<<1

;[ 46, 12, 255, 2**32-2 ]
.map(n => {
  r = f(n);
  console.log((n >>> 0), '=', (n >>> 0).toString(2), '-->', (r >>> 0), '=', (r >>> 0).toString(2));
})

Brain-Flak，78个字节

(([()()])[[]()]){((){}<({({})({}())}{})>)}{}([(({}(({}){})())<>)]){({}())<>}{}

在线尝试！

如果n <2 ^ 31，则返回2n，否则返回2n + 1-2 ^ 32。不幸的是，由于Brain-Flak没有任何快速的方法来确定数字的符号，因此如果输入与2 ^ 31的差值超过500000，则该程序将在TIO上超时。

说明

首先，将-2 ^ 32压入堆栈：

(([()()])[[]()])                               push (initial value) -2 and (iterator) -5
                {((){}<                >)}     do 5 times:
                       ({({})({}())}{})        replace the current (negative) value with the negation of its square
                                            {}   pop the (now zero) iterator

然后，计算所需的输出：

      (({}){})                        replace n by 2n on left stack
   ({}        ())                     push 2n+1-2^32 on left stack
  (              <>)                  push again on right stack
([                  ])                push its negation on right stack
                      {({}())<>}      add 1 to the top value of each stack until one of them reaches zero
                                {}    pop this zero, and implicitly print the number below it on the stack

直流10

?2~z31^*+p

在线尝试。

这是32位右转的算术实现：

?           # input
 2~         # divmod by 2 - quotient pushed first, then the remainder
   z        # z pushes the size of the stack which will be 2 (quotient and remainder) ...
    31^     #  ... and take that 2 to the 31st power
       *    # multiply the remainder by 2^31
        +   # add
         p  # output

Java 8，117 17 29字节

n->n*2%~-(long)Math.pow(2,32)

更改int为+12个字节long，因为int的最大大小为2³¹-1

通过创建@AndersKaseorg惊人的Python答案端口可以​​节省100 89字节。

在这里尝试。

输出：

46 (101110):                                     92 (1011100)
12 (1100):                                       24 (11000)
1 (1):                                           2 (10)
3 (11):                                          6 (110)
10000 (10011100010000):                          20000 (100111000100000)
987654 (11110001001000000110):                   1975308 (111100010010000001100)
2147483648 (10000000000000000000000000000000):   1 (1)
4294967294 (11111111111111111111111111111110):   4294967293 (11111111111111111111111111111101)

旧答案（117118字节）：

n->{long r=0;for(;!n.toBinaryString(++r).replace("0","").equals(n.toBinaryString(n).replace("0",""))|r==n;);return r;}

通过更改int为+1字节long，因为int的最大大小为2³¹-1

在这里尝试。

输出：

46 (101110):                                     15 (1111)
12 (1100):                                       3 (11)
1 (1):                                           2 (10)
3 (11):                                          5 (101)
10000 (10011100010000):                          31 (11111)
987654 (11110001001000000110):                   255 (11111111)
2147483648 (10000000000000000000000000000000):   1 (1)

Mathematica，29个字节

Mod@##+Quotient@##&[2#,2^32]&

在Wolfram沙箱中尝试

以算术方式向左旋转：首先乘以2，这可能会使数字超出范围，然后使用切断超出范围的数字，Mod[...,2^32]然后使用将其加回到右侧+Quotient[...,2^32]。

（Mathematica确实有一个内置函数，可以一次性给出模数和商，但它是QuotientRemainder，这有点像高尔夫球的障碍…）

APL，12个字节

(2⊥32⍴1)|2×⊢

怎么样？

           ⊢  ⍝ monadic argument
         2×   ⍝ shift left (×2)
(2⊥32⍴1)|     ⍝ modulo 2^32 - 1

05AB1E，5个字节

·žJ<%

在线尝试！

说明

使用技巧将Anders Kaseorg的python answer的二进制表示形式左移1位。

·       # input * 2
    %   # modulus
 žJ<    # 2^32-1

R，42 63字节

function(x){s=x;while(s==x){sample(binaryLogic::as.binary(x))}}

随机对位进行随机混排，但是请检查以确保它没有偶然返回相同的数字。

空格，81 80字节

（由于@ØrjanJohansen提醒我dup短于push 0，因此节省了1个字节）

在线尝试！

基本上使用整数算法实现循环右移。在Whitespace中推送大常量非常昂贵，因此我们通过推送2 ^ 8并将其平方两次来节省一些字节。（在（2 ^ 16）^ 2上节省1个字节，在直接推送2 ^ 32上节省10个字节。）

说明

sssn  ; push 0
sns   ; dup
tntt  ; getnum from stdio
ttt   ; retrieve n from heap and put it on the stack
sns   ; dup
ssstsn ; push 2
tstt  ; mod - check if divisible by 2 (i.e. even)
ntsn  ; jez "even"
ssstssssssssn ; push 2^8
sns   ; dup
tssn  ; mul - square it to get 2^16
sns   ; dup
tssn  ; mul - square it to get 2^32
tsss  ; add 2^32 so MSB ends up set after the divide
nssn  ; even:
ssstsn ; push 2
tsts  ; divide by 2, aka shift right
tnst  ; putnum - display result

Python 2.7，89个字节

完整程序：

from random import*;a=list(bin(input())[2:].zfill(32));shuffle(a);print int(''.join(a),2)

在线尝试！

建议欢迎！:)

Pari / GP，15字节

n->2*n%(2^32-1)

在线尝试！

Japt，5个字节

Ñ%3pH

像大多数答案一样，按位旋转。

试试吧

Perl -p 5，39个字节

$_=sprintf'0b%b',$_;$_=oct$_.int s/10//

在线尝试！

Python 3，45字节

lambda i:int(f'{i:32b}'[1:]+f'{i:32b}'[:1],2)

在线尝试！

C ++（gcc），45 39字节

-6字节thanx到ceilingcat

auto h(unsigned x){return x%2<<31|x/2;}

在线尝试！