Orden de bits inverso de enteros de 32 bits

21

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.

Isiah Meadows
fuente
¿Qué se entiende por "omisiones" en "omisiones son juegos gratis"?
Todd Lehman
1
Cualquier cosa que no esté explícitamente establecida en las reglas.
Isiah Meadows
¿Se contaría una tabla estática de 16 gb como parte de la longitud del programa?
Hot Licks
@HotLicks Según la interpretación típica del programa, sí.
FUZxxl
lenguaje que solo admite entradas de 8 bits, ¿podemos tomar la entrada como cuatro números de 8 bits?
Sparr

Respuestas:

0

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.

Myria
fuente
De nuevo, es exactamente el mismo tiempo que mi solución si (a) obedece la convención de llamada cdecl y (b) realmente regresa de la función.
FUZxxl
@FUZxxl De alguna manera, no vi tu versión. Estás completamente en lo correcto. Estaba pensando __fastcally no tenía el ret.
Myria
24

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 2 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).

FUZxxl
fuente
1
es la primera vez que escucho sobre la instrucción de multiplicación de matrices en una CPU
phuclv
@ LưuVĩnhPhúc: No es una multiplicación de matriz, pero VAX tenía una instrucción para evaluar un polinomio .
nneonneo
1
@nneonneo La POLYinstrucción del VAX es básicamente una combinación de multiplicar y agregar con un bucle incorporado. También existen cosas similares en arquitecturas modernas (como x86), pero generalmente no tienen un bucle incorporado para evaluar un polinomio completo a la vez.
FUZxxl
12

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.

FUZxxl
fuente
+1 Gracias por tu última oración, es obvio ahora pero me perdí eso.
edc65
1
Siempre estoy feliz de ver soluciones de ensamblaje aquí :)
user1354557
8

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.

Todd Lehman
fuente
1
Puede eliminar el inttipo de función, y también cambiar return ra algo así i=rcomo la mayoría de los compiladores de C tienden a dejar el resultado de la última operación en el registro de retorno. Funcionó en gcc y cl para mí.
Allbeert
1
Puede r(n){...}r(int n){...}
reducir
2
@FUZxxl no puede soltarlo inta int r=0,i=32;menos que los saque del cuerpo de la función.
es1024
1
@FUZxxl: No debería comentar cuando estoy cansado ... El cambio aritmético y la división no son equivalentes; el último se redondea hacia cero, mientras que el primero se redondea hacia el infinito negativo. -1 >> 1es -1para AS y 2**31 - 1para LS, mientras que -1 / 2es 0.
Dennis
1
@Todd: ¿Alguna razón que no definiste ry icomo argumentos? Ahorraría tres bytes más ...
Dennis
5

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.

Martin Ender
fuente
55
¡Este es un código de producción, no un código de golf! xD Supongo que Julia es genial.
cjfaure
4

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.

isaacg
fuente
4

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. ";
Dennis
fuente
4

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
edc65
fuente
b=k=0,R=v=>b++<32?R(v>>1,k+=k+(v&1)):kpara un solo uso y R=(v,b=0,k=0)=>b<32?R(v>>1,b+1,k+k+(v&1)):kes reutilizable
bebe
@bebe :( Estaba revisando mi respuesta usando recursividad y perdí todo por leer tu comentario ...
edc65
2
estás en 38 bytes si se k<<1vuelve k*2y se v>>1vuelve v/2. funcionó durante 486. No sé sobre otros casos de prueba
bebe
1
@bebe v / 2 no funcionará para números negativos. 486/512 == 0.9 ... y 486 >> 9 == 0, trunc es lo mismo. Pero -90/128 == -0.7 ... y -90 >> 7 == - 1
edc65
4

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

Hagen von Eitzen
fuente
Esto tiene realmente el mismo tamaño que mi solución, que es tres bytes más grande. Si se agrega la retinstrucción de retorno de la función e implementar cdecl (es decir, cambio rcr %eaxa rcr 4(%esp)y rcl %edxa rcl %eax), que terminan con un byte adicional para el rety otros dos bytes para la referencia de memoria. Aún así, una buena solución.
FUZxxl
3

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.
FUZxxl
fuente
3

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!

Adán
fuente
2

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.

BeetDemGuise
fuente
@ MartinBüttner Gracias. Perdí esa posibilidad al principio. El nuevo código maneja mejor el complemento de dos.
BeetDemGuise
2
Puedes jugar al golf un poco más: ['','-'][n%2]es '-'*(n%2).
Justin
2

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
isaacg
fuente
¿Funciona con el resultado como un gran número 32 que tiene el bit más a la izquierda en 1? En este caso, debería generar un número entero negativo.
edc65
@ edc65 Estoy generando un entero sin signo de 32 bits.
isaacg
2

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
$
Trauma digital
fuente
2

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.

Florian F
fuente
2

PHP, 46 bytes

Versiones en linea

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

o

<?=bindec(strrev(sprintf("%064b",$argn<<32)));
Jörg Hülsermann
fuente
El substres innecesario (-12 bytes). Deberías mencionar cómo ejecutarlos.
Titus
1
@Titus, ¿has probado el caso de prueba -984802906?
Jörg Hülsermann
1
Su segunda versión se puede mejorar para que coincida con la primera:<?=bindec(strrev(sprintf("%064b",$argn<<32)));
Christoph
@Christoph muy buena mejora Gracias
Jörg Hülsermann
1

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)
bebe
fuente
1
La it may be a functionregla significa que no necesita la alerta o aviso
slebetman
1

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;
 }
WozzeC
fuente
Pequeñas cosas, pero puede inicializar icuando lo declara, y guardar un byte eliminando i++del bucle for, y en lugar de comparar el resultado de 1&...con 0, puede eliminar la instrucción if por completo y multiplicar ipor el resultado que da r|=i*(1&(V>>(31-l++)));dentro del bucle
VisualMelon
¡Inteligente! Tenía la sensación de que me faltaba algo. ¡Gracias!
WozzeC
1

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);
}
BenVlodgi
fuente
1

Python - 37

Similar a la solución de @ isaacg.

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

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; 
} 
Somnium
fuente
1
Esta es una pregunta de código de golf. Intente reducir el número de caracteres en su solución, no el número de operaciones.
FUZxxl
1

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".

ballesta25
fuente
Biblioteca estándar: lo que se envía con el idioma. Esto incluye encabezados del sistema para C, las más de 4000 clases y métodos en Java (la mayoría son irrelevantes).
Isiah Meadows
1

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.

Titus
fuente
0

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",$_'
hmatt1
fuente
0

C ++ 69

int r(int n){int e=0,i=0;for(;i<32;i++)e|=((n>>i)&1)<<31-i;return e;}
rdans
fuente
@bebe, ¿qué son estos e;i;? Las declaraciones sin tipo no son un C ++ válido. Para las variables ni siquiera es válida C.
Ruslan
@Ruslan No reconocí '++' en el título, lo siento. (No estaría de acuerdo con su segunda declaración)
bebe
int r(int n){int e=0,i=0;for(;i<32;)e=e*2|1&n>>i++;return e;}61 bytes :)
Christoph
0

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.

Shadowtalker
fuente
0

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

marcus erronius
fuente
0

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.

Sylwester
fuente
0

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"))))))
Bob Jarvis - Restablece a Monica
fuente
0

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'

perl chino goth
fuente