Escriba el código más corto para invertir el orden de bits de un entero de 32 bits.

Reglas:

1. Se supone que la entrada es un entero válido o equivalente de cadena si su idioma no admite valores numéricos (por ejemplo, Windows Batch).
2. La salida debe ser un entero válido o una cadena equivalente si su idioma no admite valores numéricos (por ejemplo, Windows Batch).
3. Biblioteca estándar solamente.
4. Puede ser una función o un programa completo.
5. La entrada puede ser desde stdino como un argumento de función.
6. La salida debe ser stdouto como un valor devuelto.
7. Si su idioma tiene una función de biblioteca integrada o estándar que hace esto en un solo paso (por ejemplo, rbiten el ensamblaje ARM), eso no se puede usar.

Ejemplos:

Llave:

1. decimal
   • binario
   • (marcha atrás)
   • binario invertido
   • salida decimal

Ejemplos:

1. -90 (Ejemplo de 8 bits para demostración)

   • 10100110b
   • (marcha atrás)
   • 01100101b
   • 101

2. 486

   • 00000000000000000000000111100110b
   • (marcha atrás)
   • 01100111100000000000000000000000b
   • 1736441856

3. -984802906

   • 11000101010011010001100110100110b
   • (marcha atrás)
   • 01100101100110001011001010100011b
   • 1704506019

Nota: Las omisiones son juegos gratis. Si no lo dije, y no es una de las lagunas estándar , entonces está completamente permitido.

Ensamblado x86, 9 bytes

    xor eax, eax
    inc eax
myloop:
    shr ecx, 1
    adc eax, eax
    jnc short myloop

En forma de bytes: 33 C0 40 D1 E9 13 C0 73 FA9 bytes.

Ensamblado MMIX (28 bytes)

Números de 64 bits

rbit:
    SETH $1,#0102 # load matrix in 16-byte steps
    ORMH $1,#0408
    ORML $1,#1020
    ORL  $1,#4080
    MOR  $0,$1,$0 # multiplication 1
    MOR  $0,$0,$1 # multiplication 2
    POP  1,0      # return

Esto se ensambla para:

rbit:
    E0010102 # SETH $1,#0102
    E9010408 # ORMH $1,#0408
    EA011020 # ORML $1,#1020
    EB014080 # ORL  $1,#4080
    DC000100 # MOR  $0,$1,$0
    DC000001 # MOR  $0,$0,$1
    F8010000 # POP  1,0

¿Como funciona?

La MORinstrucción realiza una multiplicación matricial en dos cantidades de 64 bits utilizadas como dos matrices de booleanos 8x8. Un número booleano con dígitos abcdefghklmnopqr ₂ se usa como una matriz como esta:

/ abcd \
| efgh |
| klmn |
\ opqr /

La MORinstrucción multiplica las matrices representadas por sus argumentos donde la multiplicación es andy la suma es or. Es:

/ 0001 \      / abcd \      / opqr \
| 0010 |  \/  | efgh |  --  | klmn |
| 0100 |  /\  | klmn |  --  | efgh |
\ 1000 /      \ opqr /      \ abcd /

y además:

/ opqr \      / 0001 \      / rqpo \
| klmn |  \/  | 0010 |  --  | nmlk |
| efgh |  /\  | 0100 |  --  | hgfe |
\ abcd /      \ 1000 /      \ dcba /

que es el orden inverso de los bits del número original.

Números de 32 bits

Si solo desea el reverso de un número de 32 bits en lugar de un número de 64 bits, puede usar este método modificado:

rbit:
    SETL   $1,#0408 # load first matrix in two steps
    ORML   $1,#0102
    MOR    $1,$1,$0 # apply first matrix
    SLU    $2,$1,32 # compile second matrix
    16ADDU $1,$2,$1
    MOR    $1,$0,$1 # apply second matrix
    POP    1,0      # return

montado:

rbit:
    E3010408 # SETL   $1,#0408
    EA010102 # ORML   $1,#0102
    DC010001 # MOR    $1,$1,$0
    3B020120 # SLU    $2,$1,32
    2E010201 # 16ADDU $1,$2,$1
    DC010001 # MOR    $1,$0,$1
    F8010000 # POP    1,0

La primera multiplicación de matrices básicamente funciona así:

/ 0000 \      / 0000 \      / 0000 \
| 0000 |  \/  | 0000 |  --  | 0000 |
| 0001 |  /\  | abcd |  --  | efgh |
\ 0010 /      \ efgh /      \ abcd /

el octabyte correspondiente es el #0000000001020408que cargamos en las dos primeras instrucciones. La segunda multiplicación se ve así:

/ 0000 \      / 0001 \      / 0000 \
| 0000 |  \/  | 0010 |  --  | 0000 |
| efgh |  /\  | 0100 |  --  | hgfe |
\ abcd /      \ 1000 /      \ dcba /

El octabyte correspondiente es el #0102040810204080que creamos de la primera matriz así:

SLU $2,$1,#32   # $2 = #0102040800000000
16ADDU $1,$2,$1 # $2 = $2 + $1 << 4
                     = $2 + #0000000010204080
                #    = #0102040810204080

La segunda multiplicación es como siempre, el código resultante tiene la misma longitud (28 bytes).

Conjunto 80386 ( 13 12 bytes)

Como una función en la sintaxis de AT&T usando la convención de llamadas cdecl.

    # reverse bits of a 32 bit word
    .text
    .globl rbit
    .type rbit,@function
rbit:
    push $32       # prepare loop counter
    pop %ecx
0:  shrl 4(%esp)   # shift lsb of argument into carry flag
    adc  %eax,%eax # shift carry flag into lsb
    loop 0b        # decrement %ecx and jump until ecx = 0
    ret            # return

Esta función se ensambla a la siguiente secuencia de bytes:

6a 20 59 d1 6c 24 04 11 c0 e2 f8 c3

Desglosado en instrucciones:

6a 20       push $32
59          pop %ecx
d1 6c 24 04 shrl 0x4(%esp)
11 c0       adc  %eax,%eax
e2 f8       loop .-6
c3          ret    

Funciona así: en cada una de las 32 iteraciones del bucle, el argumento, que se encuentra en 4(%esp), se desplaza a la derecha en una posición. El último bit se desplaza implícitamente al indicador de acarreo. La adcinstrucción agrega dos valores y agrega el valor del indicador de acarreo al resultado. Si agrega un valor a sí mismo, es decir %eax, efectivamente lo desplaza a la izquierda en una posición. Esto es adc %eax,%eaxuna manera conveniente de desplazarse hacia la izquierda %eaxen una posición mientras se desplaza el contenido de la bandera de acarreo al bit de orden inferior.

Repito este proceso 32 veces para que 4(%esp)se vierta todo el contenido de %eax. Nunca inicializo explícitamente %eaxya que sus contenidos anteriores se desplazan durante el ciclo.

C,    63    52   48

Versión original:

int r(int n){int r=0,i=32;for(;i--;r=r<<1|n&1,n>>=1);return r;}

Versión actualizada (con cambios sugeridos por Allbeert , es1024 y Dennis ):

r(n){int r,i=32;for(;i--;r=r*2|n&1,n>>=1);return r;}

Nota: Dado que la segunda versión omite la configuración r=0, el código supone que an intes de 32 bits. Si esta suposición es falsa, lo más probable es que la función produzca un resultado incorrecto, dependiendo del estado inicial de la rentrada a la función.

Versión final (con más cambios sugeridos por Dennis y Alchymist ):

r(n,r,i){for(;32-i++;r=r*2|n&1,n>>=1);return r;}

Nota: Esto coloca la declaración de las variables de trabajo ry ien la lista de parámetros. Los parámetros son los siguientes: nes el número que se va a invertir en bits. ry ison variables de trabajo que deben pasarse como 0.

Julia 0.2, 33 bytes

f(n)=parseint(reverse(bits(n)),2)

Hace lo que parece.

bitsle da la representación de bits (respetando el complemento de dos). parseintno le importa el complemento de dos, pero devuelve un entero de 32 bits, por lo que el complemento de dos simplemente se maneja por desbordamiento.

De acuerdo con los registros de cambios, se agregó la detección de desbordamiento parseinten Julia 0.3, por lo que esto podría no funcionar más.

Pitón 2, 50

print int("{:032b}".format(input()%2**32)[::-1],2)

En general, lo mismo que mi solución Pyth. Tome el mod de entrada 2 ** 32, convierta a binario acolchado de 32 bits, invierta, convierta la picadura binaria de nuevo a decimal e imprima.

CJam, 15 bytes

li4H#+2bW%32<2b

Pruébalo en línea.

Se utilizó el comodín "Juego libre": la salida siempre será un entero sin signo.

Casos de prueba

$ cjam reverse32.cjam <<< 486; echo
1736441856
$ cjam reverse32.cjam <<< -984802906; echo
1704506019

Cómo funciona

li   " Read from STDIN and cast to integer. ";
4H#+ " Add 4 ** 17 to avoid special cases. ";
2b   " Convert into array of digits in base 2. ";
W%   " Reverse the order. ";
32<  " Discard the 33th and all following digits. ";
2b   " Convert the array of digits into an integer. ";

JavaScript (E6) 37 39 40 50

Función, entrada de número y devolución de número invertido. Algoritmo más básico, probablemente se puede jugar más golf con algún truco inteligente.

Editar recursión en lugar de bucle

Editar 2 Siguiendo la sugerencia de @bebe en k*2lugar dek<<1

Editar 3 Algo que me había perdido en absoluto: es un bucle completo de 32 bits, no es necesario inicializar k. Gracias @FUZxxl

R=(v,b=32,k)=>b?R(v>>1,b-1,k*2|v&1):k

Era

R=v=>{for(k=b=0;b++<32;)k+=k+(v&1),v>>=1;return k}

Prueba en la consola FireFox, prueba usando números en OP y algunos números más aleatorios de 16 y 32 bits

Bin=x=>('0'.repeat(32)+(x<0?-x-1:x).toString(2)).slice(-32).replace(/./g,d=>x>0?d:1-d),
Dec=x=>(' '.repeat(11)+x).slice(-11),
R16=_=>Math.random()*65536|0,  
R32=_=>(Math.random()*65536<<16)|R16(),  
[-90,486,-984802906,R16(),R16(),R16(),R32(),R32(),R32(),R32()]
 .forEach(n=> console.log(Dec(n)+' '+Bin(n)+' '+Dec(R(n))+' '+Bin(R(n))))

Ejemplo de salida de prueba

        -90 11111111111111111111111110100110  1711276031 01100101111111111111111111111111
        486 00000000000000000000000111100110  1736441856 01100111100000000000000000000000
 -984802906 11000101010011010001100110100110  1704506019 01100101100110001011001010100011
      45877 00000000000000001011001100110101 -1395851264 10101100110011010000000000000000
      39710 00000000000000001001101100011110  2027487232 01111000110110010000000000000000
      56875 00000000000000001101111000101011  -730136576 11010100011110110000000000000000
-1617287331 10011111100110100010011101011101 -1159439879 10111010111001000101100111111001
-1046352169 11000001101000011110111011010111  -344488573 11101011011101111000010110000011
 1405005770 01010011101111101010111111001010  1408597450 01010011111101010111110111001010
  -35860252 11111101110111001101000011100100   655047615 00100111000010110011101110111111

x86 ensamblado, 10 bytes

   f9                      stc    
   d1 d8            1:     rcr    %eax
   74 05                   je     2f
   d1 d2                   rcl    %edx
   f8                      clc    
   eb f7                   jmp    1b
                    2:

Esto supone entrada en eax, salida en edx. (Además, en la salida eax es cero y CF y ZF están configurados, si a alguien le importa).

En lugar de un contador, se introduce un 1 adicional al principio como marcador de fin de datos

J ( 17 15 13 bytes)

_32#.@|.@{.#:

Aquí hay una definición explícita para explicar lo que hace:

3 : '#. |. _32 {. #: y'

1. #: yrepresenta ycomo un número base 2 usando tantos lugares como sea necesario.
2. x {. ytoma |x(magnitud de x) elementos de y, desde el frente si xes positivo, desde la parte posterior si xes negativo. Si tomamos más elementos que los presentes, el resultado se rellena con ceros. _32 {. #: yefectivamente almohadillas #: ya 32 bits.
3. |. yvoltea y, i. invierte el orden de los artículos en y.
4. #. y interpreta ycomo un número de base 2.

Dyalog APL , 10 bytes

2⊥⌽⎕⊤⍨32/2

2⊥ desde-base-2 de

⌽ el reverso

⎕ entrada numérica

⊤⍨ en el sistema numérico que consiste en

32/2 32 bits

TryAPL en línea!

Python - 89

def r(n):
 if n<0:n=~n^0xFFFFFFFF
 print int(['','-'][n%2]+'{:032b}'.format(n)[::-1],2)

Python representa números binarios negativos como simplemente -0b{positive_number}. Entonces, para lidiar con esto, complemente los números negativos y luego XOR con todos los 1.

Después de eso, cree la representación de cadena del número entero basada en el formato {:032b}que proporciona la representación de 32 bits del número. Finalmente, invierta la cadena y vuelva a convertirla en un número entero.

EDITAR

Gracias a @ Martin Büttner por señalar el problema del complemento a dos. Si ntermina en un complemento de 1 por dos, la versión invertida sería negativa.

Afortunadamente, como se explicó anteriormente, a Python le gustan los números binarios negativos de una manera bastante simple. Afortunadamente, la intfunción de Python permite caracteres de signos opcionales en su primer argumento.

Entonces, agregue un signo menos si nes extraño para satisfacer el complemento de dos.

Pyth , 33 32 22

v_%"%032db0"vsc%Q^2 32

Explicación:

                 Q             Evaluated input.
                %Q^2 32        Q mod 2^32. Same 32 bit binary representation as Q.
             vsc%Q^2 32        Convert to binary string, then that to decimal int.
   %"%032db0"vsc%Q^2 32        Pad above number to 32 bits, and append b0.
  _%"%032db0"vsc%Q^2 32        Reverse it.
 v_%"%032db0"vsc%Q^2 32        Eval and print. Due to leading "0b", eval as binary.

Golfs:

33 -> 32: movido agregar a antes de invertir para guardar una cotización final.

32 -> 22: Se utilizó Q mod 2 ^ 32 en lugar de maquinaria complicada. Combinó ambas cuerdas en una.

Casos de prueba:

$ cat rev_bits 
v_%"%032db0"vsc%Q^2 32

$ ./pyth.py rev_bits <<< -984802906
1704506019

$ ./pyth.py rev_bits <<< 486
1736441856

$ ./pyth.py rev_bits <<< 0
0

GNU dc, 27 bytes

0?[2~rssr2*+dlsz34>m]dsmx+p

Salida:

$ dc revbits.dc <<< 15
4026531840
$ dc revbits.dc <<< 255
4278190080
$ dc revbits.dc <<< 65535
4294901760
$ dc revbits.dc <<< 4294901760
65535
$ dc revbits.dc <<< 4278190080
255
$ dc revbits.dc <<< 4026531840
15
$ 

Bash + coreutils, 45 bytes

n=`dc -e2do32^n$1p`
dc -e2i`rev<<<${n: -32}`p

Salida:

$ ./revbits.sh 15
4026531840
$ ./revbits.sh 255
4278190080
$ ./revbits.sh 65535
4294901760
$ ./revbits.sh 4294901760
65535
$ ./revbits.sh 4278190080
255
$ ./revbits.sh 4026531840
15
$ 

Función C, 89 bytes

La misma idea que /codegolf//a/36289/11259 - usando los trucos de Stanford bit twiddling . No va a ganar el golf, pero de todos modos es interesante:

// 89 byte function:
i;r(v){for(i=1;i<32;i*=2)v=v>>i&(1L<<32)/((1<<i)+1)|(v&(1L<<32)/((1<<i)+1))<<i;return v;}

// Test program:
#include <stdio.h>

int main (int argc, char **argv)
{
    printf("r(0x0000000f) = 0x%08x\n", r(0x0000000f));
    printf("r(0x000000ff) = 0x%08x\n", r(0x000000ff));
    printf("r(0x0000ffff) = 0x%08x\n", r(0x0000ffff));
    printf("r(0xffffffff) = 0x%08x\n", r(0xffffffff));
    printf("r(0x0f0f0f0f) = 0x%08x\n", r(0x0f0f0f0f));
    printf("r(0xf0f0f0f0) = 0x%08x\n", r(0xf0f0f0f0));
}

Salida:

$ ./revbits 
r(0x0000000f) = 0xf0000000
r(0x000000ff) = 0xff000000
r(0x0000ffff) = 0xffff0000
r(0xffffffff) = 0xffffffff
r(0x0f0f0f0f) = 0xf0f0f0f0
r(0xf0f0f0f0) = 0x0f0f0f0f
$

Función Java, 64 caracteres.

 int r(int n){int r=0,i=32;for(;i-->0;n>>=1)r=r<<1|n&1;return r;}

También debería funcionar en C.

PHP, 46 bytes

Versiones en linea

for(;$i<32;)$t.=$argn>>$i++&1;echo bindec($t);

o

<?=bindec(strrev(sprintf("%064b",$argn<<32)));

JS 115

Bueno, eso no se ve bien en absoluto: D

n=+prompt();alert(eval('0b'+(Array(33).join(0)+(n<0?n>>>0:n).toString(2)).slice(-32).split('').reverse().join('')))

El método de @Florian F en JS tiene 53 bytes de longitud:

for(n=+prompt(r=0),i=32;i--;n>>=1)r=r<<1|n&1;alert(r)

C # 81 74

int R(int V){int l,r=l=0,i=1;for(;i>0;i*=2)r|=i*(1&V>>(31-l++));return r;}

Operaciones de bit que probablemente se pueden hacer más cortas en todos los lenguajes de programación.

Básicamente, recorre todas las potencias de 2 hasta un máximo entero + 1 (que se convierte en una potencia de dos) y desde (2,147,483,647 + 1) = 0 puedo recorrer a 0. Desplazar bit de izquierda a derecha para mover el bit al primero posición. El último bit en el lugar 32 va 31 pasos a la derecha, el segundo último va a 30 etc. Así que al usar el operador AND con 1 sabré si es 1 o 0. Si es 1, agregaré el valor i actual al resultado y devolverlo.

int R(int V)
{
    int l,r=l=0,i=1;
    for(;i>0;i*=2)
        r|=i*(1&(V>>(31-l++)));
    return r;
 }

C # 142

using System;using System.Linq;int f(int n){return Convert.ToInt32(new string(Convert.ToString(n,2).PadLeft(32,'0').Reverse().ToArray()),2);}

Expandido

int f(int n)
{
    return Convert.ToInt32(
        new string(
            Convert.ToString(n, 2)
            .PadLeft(32, '0')
            .Reverse()
            .ToArray()), 2);
}

Python - 37

Similar a la solución de @ isaacg.

f=lambda n:int(bin(n%2**32)[:1:-1],2)

C ++, 160

Este no es el más corto, sin embargo, solo usa 24 operaciones.
Tomado del libro Hacker's Delight.

Golfizado:

typedef unsigned U;U R(U&x){U a=-1u/3,b=-1u/5,c=-1u/17,d=65280;x=(x&a)*2|(x/2)&a;x=(x&b)*4|(x/4)&b;x=(x&c)<<4|(x>>4)&c;x=(x<<24)|((x&d)<<8)|((x>>8)&d)|(x>>24);}

Sin golf:

unsigned R(unsigned x) {
    x = (x & 0x55555555) <<  1 | (x >>  1) & 0x55555555; 
    x = (x & 0x33333333) <<  2 | (x >>  2) & 0x33333333; 
    x = (x & 0x0F0F0F0F) <<  4 | (x >>  4) & 0x0F0F0F0F; 
    x = (x << 24) | ((x & 0xFF00) << 8) | ((x >> 8) & 0xFF00) | (x >> 24); 
    return x; 
} 

Haskell, 145 - no hay operaciones bit a bit

El giro de bits me parece la antítesis de Haskell, por lo que he evitado el uso de operadores bit a bit. El programa resultante ciertamente no es el concursante más corto, pero pensé que el uso de las matemáticas en lugar de las tonterías era interesante al menos.

import Data.Tuple
import Data.List
f m=foldl1((+).(*2))$take 32$(unfoldr(\n->if n==0 then Nothing else Just$swap$divMod n 2)$mod m$2^32)++[0,0..]

Explicación

f m=foldl1((+).(*2))$take 32$(unfoldr(\n->if n==0 then Nothing else Just$swap$divMod n 2)$mod m$2^32)++[0,0..]
    |------5-------|---4----|--------------------------2---------------------------------|----1-----|---3----|

1. usa el módulo para llevar el resultado al rango de 32 bits
2. construye una lista de 0sy1 , el bit menos significativo primero dividiendo repetidamente entre 2 y tomando el resto
3. concatena una lista infinita de 0 s al final de esta lista
4. toma los primeros 32 elementos de la lista (estos dos últimos fueron necesarios para garantizar que la lista tenga en realidad una longitud de 32 bits).
5. convierte una lista de 0y 1en un entero suponiendo que el bit más significativo es el primero (repetido doble y agregar).

No estoy muy seguro de qué constituye "la biblioteca estándar" en Haskell, así que asumí que Data.Tuple y Data.List estaban bien (son bastante estándar).

Además, la salida es un entero de 32 bits sin signo, ya que cambiar eso me costaría bytes: estoy argumentando esto en "las omisiones son juegos gratis".

PHP, 46 41 bytes

pruébalos en línea

while($i<32)$r=$r*2|$argn>>$i++&1;echo$r;

bit a bit ... más o menos. Corre como tubería conphp -nR '<code>' .

PHP, 46 bytes

while($i<32)$r|=($argn>>$i&1)<<31-$i++;echo$r;

una solución bit a bit pura; correr como tubería con-nR .

PHP, 47 59 bytes

<?=bindec(str_pad(strrev(substr(decbin($argn),-32)),32,0));

otro enfoque incorporado; guardar en archivo y ejecutar como tubería con -F.

Perl - 60

$_=unpack"N",pack"B*",scalar reverse unpack"B32",pack"N",$_

+1 para la bandera p (avíseme si estoy contando esto mal).

Corre con:

echo 486 | perl -pe'$_=unpack"N",pack"B32",scalar reverse unpack"B32",pack"N",$_'

C ++ 69

int r(int n){int e=0,i=0;for(;i<32;i++)e|=((n>>i)&1)<<31-i;return e;}

R, 45

f=function(x)packBits(intToBits(x)[32:1],"i")

Ejemplos:

f(486)
# [1] 1736441856
f(-984802906)
# [1] 1704506019

Siempre justo por debajo de las respuestas de Python. Esa maldita palabra clave de función.

Rubí, 43 41 bytes

def r(n)(0..31).inject(0){|a,b|a*2+n[b]}end

En Ruby, el uso de la notación de índice de paréntesis (foo [i]) devuelve el bit en el enésimo lugar.

--Editar--

Refactorizar la injectfuncionalidad reduce un par de bytes

def r(n)z=0;32.times{|i|z=z*2+n[i]};z;end

Perl5: 46

sub r{for(0..31){$a=$a*2|$_[0]&1;$_[0]>>=1}$a}

Nada sofisticado. Desplaza la salida a la izquierda, copia lsb antes de cambiar la fuente a la derecha.

Clojure, 202 156 142

#(read-string (let [s (clojure.pprint/cl-format nil "~2r" %)](apply str (reverse (apply str (concat (repeat (- 32 (count s)) "0") s "r2"))))))

Perl (37 + 1)

básicamente un puerto de la solución C por Todd Lehman

perl -E '$t=<>;map$r=2*$r|1&$t>>$_,0..31;say$r'