Lý lịch

Các Hamming trọng lượng của một số nguyên là số của những người thân trong biểu diễn nhị phân của nó. Đối với thử thách này, số nguyên được biểu diễn với 32 bit và chúng không được ký.

Thử thách

Cho một số nguyên trong khoảng từ 0 đến 2 ^ 32-1 (không bao gồm), xuất ra một số nguyên khác nhau trong cùng phạm vi và cũng có cùng trọng số Hamming.

Ví dụ

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)

Chấm điểm

Đây là môn đánh gôn , vì vậy giải pháp trong số ít byte nhất trong mỗi ngôn ngữ sẽ thắng.

lắp ráp x86-64, 5 4 byte

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

Một hàm sử dụng quy ước gọi C mà bit bit xoay đối số của nó còn lại 1 bit.

Python, 20 byte

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

Xoay bit trái 1 bit.

MATL , 9 byte

32&B1YSXB

Thông thường dịch chuyển biểu diễn nhị phân 32 chữ số một bước sang phải.

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

Thạch , 10 8 byte

‘&~^^N&$

Hoán đổi tập hợp ít quan trọng nhất và bit unset.

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

Làm thế nào nó hoạt động

‘&~^^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 byte

Tìm kiếm quá trình chuyển đổi bit đầu tiên (0 → 1 hoặc 1 → 0) và đảo ngược nó.

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

Bản giới thiệu

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

Xoay bit, 14 byte

Ngắn hơn nhiều nhưng ít vui

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

Bản giới thiệu

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 byte

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

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

Trả về 2n nếu n <2 ^ 31 và 2n + 1-2 ^ 32 nếu không. Thật không may, vì Brain-Flak không có cách nhanh chóng nào để xác định dấu hiệu của một số, chương trình sẽ hết thời gian trên TIO nếu đầu vào khác với 2 ^ 31 hơn khoảng 500000.

Giải trình

Đầu tiên, đẩy -2 ^ 32 lên ngăn xếp:

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

Sau đó, tính toán đầu ra mong muốn:

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

đc, 10

?2~z31^*+p

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

Đây là một triển khai số học của xoay phải 32 bit:

?           # 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 byte

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

+12 byte bằng cách thay đổi intthành long, vì intkích thước tối đa là2³¹-1

100 89 byte được lưu bằng cách tạo một cổng câu trả lời Python tuyệt vời của @AndersKaseorg .

Hãy thử nó ở đây.

Đầu ra:

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)

Câu trả lời cũ ( 117 118 byte):

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

+1 byte bằng cách thay đổi intthành long, bởi vì intkích thước tối đa là2³¹-1

Hãy thử nó ở đây.

Đầu ra:

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)

Toán học, 29 byte

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

Hãy thử nó tại hộp cát Wolfram

Xoay trái một cách hợp lý: đầu tiên nhân với 2, có thể dịch chuyển số ra khỏi phạm vi, sau đó cắt chữ số ngoài phạm vi với Mod[...,2^32]và thêm nó trở lại bên phải với +Quotient[...,2^32].

(Mathematica có một nội trang duy nhất cung cấp mô-đun và thương số trong một lần, nhưng QuotientRemainderđó là một chút của một điểm chấp golf đánh gôn)

APL, 12 byte

(2⊥32⍴1)|2×⊢

Làm sao?

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

05AB1E , 5 byte

·žJ<%

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

Giải trình

Sử dụng mẹo để xoay đại diện nhị phân còn lại 1 bit từ câu trả lời python của Anders Kaseorg .

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

R, 42 63 byte

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

Xáo trộn các bit xung quanh một cách ngẫu nhiên, nhưng kiểm tra để chắc chắn rằng nó không trả về cùng một số một cách tình cờ.

Khoảng trắng , 81 80 byte

(Lưu 1 byte nhờ @ janrjan Johansen nhắc nhở tôi dup là ngắn hơn đẩy 0)

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

Về cơ bản thực hiện một bithift phải tuần hoàn bằng số học số nguyên. Đẩy một hằng số lớn rất tốn kém trong Khoảng trắng, vì vậy chúng tôi tiết kiệm một số byte bằng cách đẩy 2 ^ 8 và bình phương hai lần. (Lưu 1 byte trên (2 ^ 16) ^ 2 và 10 byte khi đẩy trực tiếp 2 ^ 32.)

Giải trình

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 byte

Chương trình đầy đủ:

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

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

Đề nghị chào mừng! :)

Pari / GP , 15 byte

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

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

Japt , 5 byte

Ñ%3pH

Xoay bitwise, giống như hầu hết các câu trả lời ở đây.

Thử nó

Perl 5 -p , 39 byte

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

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

Python 3 , 45 byte

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

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

C ++ (gcc) , 45 39 byte

-6 byte sox đến trần

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

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