21

编写最短的代码以反转32位整数的位顺序。

规则：

如果您的语言不支持数值（例如Windows Batch），则假定输入为有效的整数或等效字符串。
如果您的语言不支持数字值（例如Windows Batch），则输出必须是有效的整数或等效的字符串。
仅标准库。
它可能是一个功能或一个完整的程序。
输入可以是来自stdin或作为函数参数。
输出必须是stdout或作为返回值。
如果您的语言具有内置的或标准的库函数，可以一步完成此任务（例如，rbit在ARM汇编中），则无法使用。

例子：

键：

小数
- 二元
- （相反）
- 反向二进制
- 十进制输出

例子：

-90 （用于演示的8位示例）
- 10100110b
- （相反）
- 01100101b
- 101
486
- 00000000000000000000000111100110b
- （相反）
- 01100111100000000000000000000000b
- 1736441856
-984802906
- 11000101010011010001100110100110b
- （相反）
- 01100101100110001011001010100011b
- 1704506019

注意：遗漏是免费游戏。如果我没有说出来，并且它不是标准漏洞之一，那么它是完全允许的。

code-golf bitwise

— 伊西亚·梅多斯（Isiah Meadows）
source

“遗漏是免费游戏”中的“遗漏”是什么意思？

— 托德·雷曼

1

规则中未明确说明的任何内容。

— 伊西亚·梅多斯

将16GB的静态表计为程序长度的一部分吗？

— 热舔

@HotLicks根据程序的典型解释，可以。

— 2014年

仅支持8位输入的语言，我们可以将输入视为四个8位数字吗？

— Sparr

0

x86汇编，9字节

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

字节形式：33 C0 40 D1 E9 13 C0 73 FA，9个字节。

— 米里亚
source

如果您（a）遵守cdecl调用约定，并且（b）实际上从函数返回，那又与我的解决方案一样长。

— FUZxxl

@FUZxxl不知何故，我没有看到您的版本。你是完全正确的。我当时在想__fastcall，却没有ret。

— Myria '17

24

MMIX程序集（28字节）

64位数字

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

组装成：

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

它是如何工作的？

该MOR指令对用作两个8x8布尔矩阵的两个64位量执行矩阵乘法。具有数字abcdefghklmnopqr _2的布尔值用作如下矩阵：

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

该MOR指令将其参数表示的矩阵相乘，其中乘为and，加法为or。它是：

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

还有：

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

这是原始编号的相反顺序。

32位数字

如果只想反转32位而不是64位，则可以使用以下修改的方法：

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

组装：

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

第一个矩阵乘法基本上是这样的：

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

相应的八字节是#0000000001020408我们在前两个指令中加载的。第二个乘法如下所示：

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

相应的八字节是#0102040810204080我们从第一个矩阵创建的，如下所示：

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

第二次乘法是照常进行的，结果代码具有相同的长度（28个字节）。

— FUZxxl
source

1

这是我第一次听说CPU上的矩阵乘法指令

— phuclv 2014年

@LưuVĩnhPhúc：不是矩阵乘法，但是VAX有一条求值多项式的指令。

— nneonneo

1

@nneonneo POLYVAX 的指令基本上是带有内置循环的融合乘法和加法。在现代体系结构（例如x86）中也存在类似的东西，但是它们通常没有内置的循环来一次评估整个多项式。

— 2014年

12

80386汇编（13 12字节）

作为使用cdecl调用约定的AT＆T语法功能。

    # 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

该函数汇编为以下字节序列：

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

分解为说明：

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

它的工作方式如下：在循环的32个迭代中，每个迭代都将位于的参数4(%esp)右移一个位置。最后一位隐式移入进位标志。该adc指令将两个值相加并将进位标志的值添加到结果中。如果向其自身添加一个值，即%eax，则实际上将其左移了一个位置。这adc %eax,%eax是方便的左移方式%eax在将进位标志的内容移入低位时将其一个位置。

我重复此过程32次，以便将的全部内容4(%esp)转储到中%eax。我从来没有明确初始化过，%eax因为其先前的内容在循环过程中被移出了。

— FUZxxl
source

+1感谢您的最后一句话，这很明显，但我错过了。

— edc65

1

我总是很高兴在这里看到装配解决方案：）

— user1354557

8

C， 63 52 48

原始版本：

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

更新版本（由Allbeert，es1024和Dennis提出更改）：

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

注意：由于第二个版本省略了setting r=0，因此代码假定an int为32位。如果此假设为假，则该函数很可能会产生错误的结果，具体取决于r该函数进入时的初始状态。

最终版本（Dennis和Alchymist建议进一步更改）：

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

注：这使工作变量的声明r，并i进入参数列表。参数如下：n是要反转的数字。r并且i是必须作为0传递的工作变量。

— 托德·雷曼
source

1

您可以删除int函数类型，也可以更改return r为类似的内容，i=r因为大多数C编译器倾向于将最后一次操作的结果保留在返回寄存器中。它为我在gcc和cl上工作。

— 2014年

1

您可以使用r(n){...}而不是r(int n){...}

— es1024

2

@FUZxxl int，int r=0,i=32;除非将它们移出函数主体，否则不能插入它们。

— es1024 2014年

1

@FUZxxl：我累了就不应该发表评论……算术移位和除法并不等同；后者朝零取整，而第一轮朝负无穷大。-1 >> 1是-1用于AS和2**31 - 1LS，-1 / 2而是0。

— 丹尼斯

1

@Todd：您没有定义r和i作为参数的任何原因吗？将节省另外三个字节...

— 丹尼斯

5

朱莉娅0.2，33字节

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

看起来像什么。

bits为您提供位表示（尊重二进制补码）。parseint并不关心二进制补码，但返回一个32位整数，因此可以通过溢出简单地处理二进制补码。

根据更改日志，parseintJulia 0.3中已添加了溢出检测功能，因此这可能不再起作用。

— 马丁·恩德
source

5

这是生产代码，而不是高尔夫球代码！xD我想朱莉娅很棒。

— cjfaure

4

python 2，50

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

与我的Pyth解决方案大致相同。将输入mod 2 ** 32转换为32位填充的二进制，取反，将二进制字符串转换回十进制并打印。

— 伊萨格
source

4

CJam，15个字节

li4H#+2bW%32<2b

在线尝试。

使用“免费游戏”小丑：输出将始终是无符号整数。

测试用例

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

怎么运行的

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

— 丹尼斯
source

4

JavaScript（E6）37 39 40 50

功能，编号输入和返回反向编号。~~最基本的算法，可能可以通过一些巧妙的技巧来解决。~~

编辑递归而不是循环

编辑2以下@bebe建议k*2而不是k<<1

编辑3我完全错过的东西：这是一个完整的32位循环，无需初始化k。谢谢@FUZxxl

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

它是

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

测试在FireFox控制台中，使用OP中的数字以及其他一些随机的16位和32位数字进行测试

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

测试输出示例

        -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
source

b=k=0,R=v=>b++<32?R(v>>1,k+=k+(v&1)):k一次性使用且R=(v,b=0,k=0)=>b<32?R(v>>1,b+1,k+k+(v&1)):k可重复使用

— Bebe 2014年

@bebe :(我正在使用递归修改答案，失去了所有内容，无法阅读您的评论...

— edc65

2

如果k<<1变为k*2，v>>1则您的字节数为38个字节v/2。它适用于486。我不了解其他测试用例

— Bebe 2014年

1

@bebe v / 2不适用于负数。486/512 == 0.9 ...和486 >> 9 == 0，截断相同。但是-90/128 == -0.7 ...和-90 >> 7 ==-1

— edc65

4

x86 assemply，10个字节

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

假设输入为eax，输出为edx。（此外，如果有人关心，在输出eax上为零，并且设置CF和ZF）。

代替计数器，在开头添加另外的1作为数据结束标记

— 哈根·冯·埃岑
source

实际上，它的大小与我的解决方案大小相同，即大了三个字节。如果添加了ret从函数返回并实现cdecl 的指令（即，更改rcr %eax为rcr 4(%esp)和rcl %edx，则rcl %eax）将为额外增加一个字节，ret并为内存引用增加另外两个字节。不过，这是一个不错的解决方案。

— 2014年

3

J（17 15 13字节）

_32#.@|.@{.#:

这是一个明确的定义，以解释其作用：

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

#: y表示y以2为底的数字，并根据需要使用尽可能多的位置。
x {. y取|x（幅度x）从项目y，从前面如果x是正的，如果从背面x为负。如果我们接受的物品多于现在的物品，则结果将填充零。_32 {. #: y有效地填充#: y到32位。
|. y 翻转 y，我。反转中的项目顺序y。
#. y 解释 y为以2为底的数字。

— FUZxxl
source

3

Dyalog APL，10 个字节

2⊥⌽⎕⊤⍨32/2

2⊥ 从2开始

⌽ 倒转

⎕ 数字输入

⊤⍨ 在由

32/2 32位

在线尝试APL！

— 亚当
source

2

巨蟒-89

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

Python简单地表示负二进制数-0b{positive_number}。因此，要对此进行处理，请先对负数进行补码，然后对全1进行XOR。

之后，根据{:032b}提供数字32位表示形式的格式创建整数的字符串表示形式。最后，反转字符串并将其返回为整数。

编辑

感谢@MartinBüttner指出二进制补码问题。如果n以1结尾，则以2的补码取反。

幸运的是，如上所述，Python非常简单地喜欢负数二进制数。幸运的是，Python的int函数允许可选的符号字符在其第一个参数中。

因此，现在，如果n为奇数，则加上减号即可满足二进制补码。

— 甜菜
source

@MartinBüttner谢谢。起初我错过了这种可能性。新代码更好地处理了二进制补码。

— BeetDemGuise 2014年

2

您还可以打高尔夫：['','-'][n%2]是'-'*(n%2)。

— 贾斯汀

2

Pyth，33 32 22

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

说明：

                 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.

高尔夫：

33-> 32：在反转之前将添加移至以保存结束引号。

32-> 22：使用Q mod 2 ^ 32代替复杂的机械。将两个字符串合并为一个。

测试用例：

$ 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

— 伊萨格
source

它的结果是否有效，因为32个数字的最左位为1？在这种情况下，它应该输出一个负整数。

— edc65 2014年

@ edc65我正在输出32位无符号整数。

— isaacg 2014年

2

GNU dc，27个字节

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

输出：

$ 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个字节

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

输出：

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

C函数，89个字节

与/codegolf//a/36289/11259相同的想法-使用斯坦福大学的技术来操纵黑客。不会赢得高尔夫，但是有趣的是：

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

输出：

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

— 数字创伤
source

2

Java函数，64个字符。

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

也应该在C中工作。

— 弗洛里安
source

2

PHP，46字节

在线版本

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

要么

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

— 约格·赫尔瑟曼
source

的substr是不必要的（-12字节）。您应该提到如何运行它们。

— 泰特斯

1

@Titus您是否尝试过测试用例-984802906？

— 约尔格Hülsermann

1

您的第二个版本可以改进以匹配第一个版本：<?=bindec(strrev(sprintf("%064b",$argn<<32)));

— Christoph

@Christoph非常不错的改进谢谢

— 约尔格Hülsermann

1

JS 115

好吧，看起来一点也不好：D

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

JS中@Florian F的方法长53个字节：

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

— 贝贝
source

1

该it may be a function规则意味着您不需要警报或提示

— slebetman 2014年

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

在所有编程语言中，最有可能完成较短的位操作。

基本上，将所有2的幂循环到最大整数+1（这将变成2的幂），并且由于（2,147,483,647 + 1）= 0，我可以循环到0。位置。位置32的最后一位向右移动31步，最后一位向30前进，依此类推。因此，通过将AND运算符与1一起使用，i会知道它是1还是0。如果是1，我会将当前i值添加到结果中，把它返还。

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
source

Small things, but you can initialize i when you declare it, and save a byte by removing i++ from the for loop, and instead of comparing the result of 1&... with 0 you can remove the if statement altogether and multiply i by the result giving r|=i*(1&(V>>(31-l++))); inside the loop

— VisualMelon

Clever! I had a feeling I was missing something. Thanks!

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

Expanded

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

— BenVlodgi
source

1

Python - 37

Similar to @isaacg's solution.

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

— cjfaure
source

1

C++, 160

This isn't the shortest one, however it uses only 24 operations.
Taken from Hacker's Delight book.

Golfed:

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

Ungolfed:

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
source

1

This is a code golf question. Please try to reduce the number of characters in your solution, not the number of operations.

— FUZxxl

1

Haskell, 145 - no bitwise operations

Bit-twiddling strikes me as the antithesis of Haskell, so I've avoided any use of bitwise operators. The resulting program is certainly not the shortest contestant, but I thought the use of math instead of bit-twiddling was interesting at least.

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

Explanation

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

uses modulo to bring the result into 32-bit range
constructs a list of 0s and 1s, least significant bit first by repeatedly dividing by 2 and taking the remainder
concatenates an infinite list of 0s to the end of this list
grabs the first 32 elements of the list (These last two were needed to ensure the list is actually 32 bits long.)
converts a list of 0 and 1 into an integer assuming the most significant bit is first (repeated double and add).

I'm not quite sure what constitutes "the standard library" in Haskell so I assumed Data.Tuple and Data.List were OK (they are pretty standard).

Also, the output is an unsigned 32-bit integer since changing that would cost me bytes: I'm arguing this under "omissions are free game".

— ballesta25
source

Standard library: what ships with the language. This includes system headers for C, the 4000+ classes and methods in Java's (most are irrelevant).

— Isiah Meadows

1

PHP, 46 41 bytes

try them online

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

bitwise ... more or less. Run as pipe with php -nR '<code>'.

PHP, 46 bytes

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

a pure bitwise solution; run as pipe with -nR.

PHP, 47 59 bytes

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

another built-in approach; save to file and run as pipe with -F.

— Titus
source

0

Perl - 60

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

+1 for the p flag (let me know if I'm counting this wrong).

Run with:

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

— hmatt1
source

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
source

@bebe what are these e;i;? Declarations without type are not a valid C++. For variables it's not even valid C.

— Ruslan

@Ruslan i didn't recognize '++' in the title, sorry. (i wouldn't agree with your second statement)

— 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")

Examples:

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

Always just shy of the Python answers. That damn function keyword.

— shadowtalker
source

0

Ruby, 43 41 bytes

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

In Ruby, using the bracket index notation (foo[i]) returns the bit at the nth place.

--Edit--

Refactoring the inject functionality shaves a couple bytes

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

— marcus erronius
source

0

Perl5: 46

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

Nothing fancy. It shifts output left, copy lsb before shifting source right.

— Sylwester
source

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 - Reinstate Monica
source

0

Perl (37+1)

basically a port of the C solution by Todd Lehman

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

— chinese perl goth
source

32位整数的反向位顺序

MMIX程序集（28字节）

64位数字

它是如何工作的？

32位数字

80386汇编（13 12字节）

C， 63 52 48

朱莉娅0.2，33字节

python 2，50

CJam，15个字节

测试用例

怎么运行的

JavaScript（E6）37 39 40 50

x86 assemply，10个字节

J（17 15 13字节）

Dyalog APL，10 个字节

巨蟒-89

Pyth，33 32 22

GNU dc，27个字节

输出：

Bash + coreutils，45个字节

输出：

C函数，89个字节

输出：

Java函数，64个字符。

PHP，46字节

JS 115

C＃81 74

C# 142

Python - 37

C++, 160

Haskell, 145 - no bitwise operations

Explanation

PHP, 46 41 bytes

Perl - 60

C++ 69

R, 45

Ruby, 43 41 bytes

--Edit--

Perl5: 46

Clojure, 202 156 142

Perl (37+1)