Fondo

El peso de Hamming de un entero es el número de unos en su representación binaria. Para este desafío, los enteros se representan con 32 bits y no están firmados.

Reto

Dado un número entero entre 0 y 2 ^ 32-1 (no incluido), genera un número entero diferente dentro del mismo rango y también con el mismo peso de Hamming.

Ejemplos

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)

Tanteo

Este es el código de golf , por lo que gana la solución en la menor cantidad de bytes en cada idioma.

Ensamblado x86-64, 5 4 bytes

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

Una función que utiliza la convención de llamada C que gira a nivel de bits su argumento a la izquierda en 1 bit.

Python, 20 bytes

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

Rotación bit a la izquierda por 1 bit.

MATL , 9 bytes

32&B1YSXB

Desplaza circularmente la representación binaria de 32 dígitos un paso hacia la derecha.

Pruébalo en línea!

Jalea , 10 8 bytes

‘&~^^N&$

Intercambia el bit menos definido y menos definido.

Pruébalo en línea!

Cómo funciona

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

Busca la transición del primer bit (0 → 1 o 1 → 0) y la invierte.

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

Manifestación

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

Rotación de bits, 14 bytes.

Mucho más corto pero menos divertido.

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

Manifestación

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 bytes

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

Pruébalo en línea!

Devuelve 2n si n <2 ^ 31, y 2n + 1-2 ^ 32 de lo contrario. Desafortunadamente, debido a que Brain-Flak no tiene una forma rápida de determinar el signo de un número, el programa agota el tiempo de espera en TIO si la entrada difiere de 2 ^ 31 en más de aproximadamente 500000.

Explicación

Primero, empuja -2 ^ 32 en la pila:

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

Luego, calcule la salida deseada:

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

Pruébalo en línea .

Esta es una implementación aritmética de un giro a la derecha de 32 bits:

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

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

+12 bytes cambiando inta long, porque intel tamaño máximo es2³¹-1

100 89 bytes guardados al crear un puerto de la sorprendente respuesta Python de @AndersKaseorg .

Pruébalo aquí

Salidas:

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)

Respuesta anterior ( 117 118 bytes):

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

+1 byte cambiando inta long, porque intel tamaño máximo es2³¹-1

Pruébalo aquí

Salidas:

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 bytes

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

Pruébalo en el sandbox de Wolfram

Rota a la izquierda aritméticamente: primero multiplique por 2, lo que posiblemente desplace el número fuera del rango, luego corte el dígito fuera del rango con Mod[...,2^32]y agréguelo nuevamente a la derecha con +Quotient[...,2^32].

(Mathematica tiene una sola construcción que da el módulo y el cociente de una vez, pero es QuotientRemainder, que es un poco una desventaja para el golf ...)

APL, 12 bytes

(2⊥32⍴1)|2×⊢

¿Cómo?

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

05AB1E , 5 bytes

·žJ<%

Pruébalo en línea!

Explicación

Utiliza el truco para rotar la representación binaria que queda 1 bit de la respuesta de Python de Anders Kaseorg .

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

R, 42 63 bytes

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

Mezcla los bits aleatoriamente, pero se asegura de que no haya devuelto el mismo número por casualidad.

Espacios en blanco , 81 80 bytes

(1 byte guardado gracias a @ Ørjan Johansen que me recuerda que dup es más corto que push 0)

Pruébalo en línea!

Básicamente implementa un desplazamiento de bits a la derecha cíclico utilizando aritmética de enteros. Empujar una constante grande es costoso en espacios en blanco, por lo que ahorramos algunos bytes presionando 2 ^ 8 y cuadrándolo dos veces. (Ahorra 1 byte sobre (2 ^ 16) ^ 2 y 10 bytes sobre empujando 2 ^ 32 directamente.)

Explicación

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 bytes

Programa completo:

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

Pruébalo en línea!

Sugerencias bienvenidas! :)

Pari / GP , 15 bytes

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

Pruébalo en línea!

Japt , 5 bytes

Ñ%3pH

Rotación bit a bit, como la mayoría de las respuestas aquí.

Intentalo

Perl 5 -p , 39 bytes

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

Pruébalo en línea!

Python 3 , 45 bytes

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

Pruébalo en línea!

C ++ (gcc) , 45 39 bytes

-6 bytes gracias al techo

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

Pruébalo en línea!