배경

정수 의 해밍 가중치 는 이진 표현의 정수입니다. 이 문제의 경우 정수는 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)

채점

이것은 code-golf 이므로 각 언어에서 가장 적은 바이트 수의 솔루션이 승리합니다.

x86-64 어셈블리, 5 4 바이트

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

C 호출 규칙을 사용하여 인수를 1 비트 씩 왼쪽으로 회전시키는 함수입니다.

파이썬, 20 바이트

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

1 비트 씩 왼쪽으로 회전합니다.

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.

자바 스크립트 (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

dc, 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

자바 8, 117 17 29 바이트

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

의 최대 크기가 이므로 으로 변경 int하여 +12 바이트longint2³¹-1

100@AndersKaseorg 의 놀라운 파이썬 답변 포트를 생성하여 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)

기존 답변 ( 117 바이트) :

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

변경하여 +1 바이트 int의 최대 크기가 long이므로 하여int2³¹-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)

매스 매 티카, 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 바이트

(@ Ørjan Johansen 덕분에 1 바이트가 절약되어 dup이 푸시 0보다 짧다는 것을 상기시킵니다)

온라인으로 사용해보십시오!

기본적으로 정수 산술을 사용하여 순환 오른쪽 비트 시프트를 구현합니다. 공백에서 큰 상수를 푸는 것은 비싸므로 2 ^ 8을 누르고 두 번 제곱하여 일부 바이트를 절약합니다. (1 ^ 2 바이트 이상 (2 ^ 16) ^ 2 및 10 바이트 바이트를 2 ^ 32를 직접 누르면 저장합니다.)

설명

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

파이썬 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

여기에 대부분의 답변과 같은 비트 회전.

시도 해봐

펄 5 -p , 39 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 45 바이트

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

온라인으로 사용해보십시오!

C ++ (gcc) , 45 39 바이트

ceilingcat에 -6 바이트

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

온라인으로 사용해보십시오!