32ビット整数のビット順序を逆にするには、最短のコードを記述します。

ルール：

1. ご使用の言語が数値（Windows Batchなど）をサポートしていない場合、入力は有効な整数または文字列に相当すると見なされます。
2. 言語が数値をサポートしていない場合（Windows Batchなど）、出力は有効な整数または文字列に相当する必要があります。
3. 標準ライブラリのみ。
4. 関数または完全なプログラムの場合があります。
5. 入力は、from stdinまたはfunction引数としてのいずれかです。
6. 出力は、stdoutまたは戻り値としてのいずれかでなければなりません。
7. ご使用の言語に1ステップでこれを行う組み込みまたは標準ライブラリ関数がある場合（rbitARMアセンブリなど）、それは使用できません。

例：

キー：

1. 小数
   • バイナリ
   • （逆）
   • 逆バイナリ
   • 10進出力

例：

1. -90 （デモ用の8ビットの例）

   • 10100110b
   • （逆）
   • 01100101b
   • 101

2. 486

   • 00000000000000000000000111100110b
   • （逆）
   • 01100111100000000000000000000000b
   • 1736441856

3. -984802906

   • 11000101010011010001100110100110b
   • （逆）
   • 01100101100110001011001010100011b
   • 1704506019

注：省略は無料ゲームです。私がそれを言わなかった、そしてそれが標準的な抜け穴の 1つではないなら、それは完全に許可されています。

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バイト。

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命令は、ブール値の2つの8x8マトリックスとして使用される2つの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ビット数

64ビット数ではなく32ビット数の反転のみが必要な場合は、この変更された方法を使用できます。

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、最初の2つの命令でロードされます。2番目の乗算は次のようになります。

/ 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

2番目の乗算は通常のビジネスであり、結果のコードは同じ長さ（28バイト）になります。

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)1ポジション右にシフトされます。最後のビットは、キャリーフラグに暗黙的にシフトされます。このadc命令は、2つの値を追加し、結果にキャリーフラグの値を追加します。あなたが自分自身に価値を追加した場合、すなわち%eax、あなたは効果的に左シフト1位で、それを。これによりadc %eax,%eax、左シフトが便利になります%eax、キャリーフラグの内容を下位ビットにしながら、1ポジションされます。

のコンテンツ全体4(%esp)がにダンプされるように、このプロセスを32回繰り返し%eaxます。%eax前の内容がループ中にシフトアウトされるため、明示的に初期化することはありません。

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

注：2番目のバージョンでは設定が省略されるため r=0、コードはan intが32ビットであると想定しています。この仮定が偽の場合、関数rへのエントリ時の初期状態に応じて、関数は誤った結果を生成する可能性が高くなります。

最終バージョン（さらにデニスとアルキミスト含む）：

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

注：これは、作業変数の宣言を置くrと、iパラメータリストに。パラメータは次のとおりですn。ビット反転する数です。rおよびiは、0として渡す必要がある作業変数です。

ジュリア0.2、33バイト

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

それがどのように見えるかを行います。

bitsビット表現を提供します（2の補数を考慮）。parseint2の補数は気にしませんが、32ビット整数を返します。そのため、2の補数は単純にオーバーフローによって処理されます。

変更ログによると、parseintJulia 0.3 ではオーバーフローの検出が追加されたため、これはもう機能しない可能性があります。

Python 2、50

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

私のPythソリューションとほぼ同じです。入力mod 2 ** 32を取得し、32ビットの埋め込みバイナリに変換し、逆に、バイナリ文字列を10進数に変換して出力します。

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

JavaScript（E6）37 39 40 50

関数、数値の入力および反転した数値を返します。最も基本的なアルゴリズムは、おそらくいくつかのスマートトリックを使用してよりゴルフをすることができます。

ループの代わりに再帰を編集

のk*2代わりに@bebeの提案に従って編集2k<<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

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がプッシュされます。

J（17 15 13バイト）

_32#.@|.@{.#:

以下は、それが何をするのかを説明するための明示的な定義です。

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

1. #: yy必要な数の場所を使用して、基数2の数値として表します。
2. x {. yは、から|x（の大きさx）のアイテムを正のy場合xは前から、x負の場合は後ろから取ります。現在よりも多くのアイテムを取得する場合、結果にはゼロが埋め込まれます。_32 {. #: y効果的#: yに32ビットにパディングします。
3. |. yフリップy、i。のアイテムの順序を逆にしyます。
4. #. yy2を底とする数として 解釈さ れます。

Dyalog APL、10 バイト

2⊥⌽⎕⊤⍨32/2

2⊥ from-base-2 of

⌽ 逆に

⎕ 数値入力

⊤⍨ で構成される数体系で

32/2 32ビット

TryAPLオンライン！

パイソン-89

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

Pythonは負の2進数を単にとして表し-0b{positive_number}ます。したがって、これに対処するには、負の数を補完し、すべて1でXORします。

その後、形式に基づいて整数の文字列表現を作成します {:032b}、数値の32ビット表現を提供する。最後に、文字列を逆にして、整数に戻します。

編集

2の補数の問題を指摘してくれた@MartinBüttnerに感謝します。もしn1で終わる、2の補数で反転したバージョンは負になります。

幸いなことに、上記で説明したように、Pythonは非常に簡単な方法で負の2進数を好みます。また、幸運なことに、Pythonのint関数ではオプションの符号文字が使用できますでは、最初の引数にを。

したがって、n2の補数を満たすために奇数の場合はマイナス記号を追加します。

ピス、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：エンドクォートを保存するために反転する前にaddを移動しました。

32-> 22：複雑な機械の代わりにQ mod 2 ^ 32を使用しました。両方の文字列を1つに結合しました。

テストケース：

$ 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バイト

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
$

Java関数、64文字。

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

Cでも動作するはずです。

PHP、46バイト

オンライン版

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

または

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

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)

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ステップ、最後から2番目は30などになります。したがって、1でAND演算子を使用すると、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;
 }

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

拡大

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

パイソン-37

@isaacgのソリューションに似ています。

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

C ++、160

これは最短ではありませんが、24の操作のみを使用します。
ハッカーのDelightの本から引用。

ゴルフ：

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

ゴルフをしていない：

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-ビット演算なし

ビットいじりはHaskellのアンチテーゼとして私を襲うので、ビットごとの演算子の使用を避けました。結果として得られるプログラムは確かに最短の競技者ではありませんが、ビットトゥイドリングの代わりに数学を使用することは少なくとも興味深いと思いました。

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

説明

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. モジュロを使用して結果を32ビットの範囲にします
2. リスト構築0秒と1 sの。2で繰り返し除算し、残りを取得することにより、最下位ビットが最初になります
3. の無限リストを連結します 0sのをこのリストの最後にます
4. リストの最初の32要素を取得します（リストの実際の長さが32ビットであることを確認するには、最後の2つが必要でした）。
5. 変換のリスト0と1仮定整数に最も重要なビットは、最初に（二重繰り返し加算）されます。

Haskellの「標準ライブラリ」を構成するものがよく分からないので、Data.TupleとData.Listは問題ないと思いました（かなり標準的です）。

また、出力は符号なしの 32ビット整数であり、これを変更するとバイトが消費されるため、「省略は無料ゲーム」で議論しています。

PHP、46 41バイト

オンラインで試してみてください

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

ビット単位...多かれ少なかれ。でパイプとして実行しphp -nR '<code>'ます。

PHP、46バイト

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

純粋なビット単位のソリューション。パイプとして実行-nRます。

PHP、47 59バイト

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

別の組み込みアプローチ。ファイルに保存し、でパイプとして実行します-F。

Perl-60

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

pフラグの+1（これを間違えているかどうかを教えてください）。

で実行：

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

例：

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

常にPythonの答えを恥ずかしがります。そのいまいましい機能キーワード。

ルビー、 43 41バイト

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

Rubyでは、ブラケットインデックス表記（foo [i]）を使用すると、n番目のビットが返されます。

-編集-

inject機能をリファクタリングすると、数バイト削減されます

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}

派手なものは何もありません。出力を左にシフトし、ソースを右にシフトする前にlsbをコピーします。

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）

基本的にトッドリーマンによるCソリューションの移植版

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