Напишите кратчайший код, чтобы изменить порядок бит 32-разрядного целого числа.

Правила:

1. Предполагается, что входные данные являются действительными целочисленными или строковыми эквивалентами, если ваш язык не поддерживает числовые значения (например, Windows Batch).
2. Выходные данные должны быть действительными целочисленными или строковыми эквивалентами, если ваш язык не поддерживает числовые значения (например, Windows Batch).
3. Только стандартная библиотека.
4. Это может быть функция или полная программа.
5. Ввод может быть либо из, stdinлибо в качестве аргумента функции.
6. Вывод должен быть либо stdoutв виде возвращаемого значения.
7. Если ваш язык имеет встроенную или стандартную библиотечную функцию, которая делает это за один шаг (например, rbitв сборке ARM), это нельзя использовать.

Примеры:

Ключ:

1. десятичная дробь
   • двоичный
   • (задний ход)
   • перевернутый двоичный
   • десятичный вывод

Примеры:

1. -90 (8-битный пример для демонстрации)

   • 10100110b
   • (задний ход)
   • 01100101b
   • 101

2. 486

   • 00000000000000000000000111100110b
   • (задний ход)
   • 01100111100000000000000000000000b
   • 1736441856

3. -984802906

   • 11000101010011010001100110100110b
   • (задний ход)
   • 01100101100110001011001010100011b
   • 1704506019

Примечание: пропуски бесплатной игры. Если я этого не сказал, и это не одна из стандартных лазеек , то это полностью разрешено.

сборка 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 FA9 байтов.

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Команда выполняет матричное умножение на два 64-битовых величин , используемых в качестве два 8x8 матриц логических значений. В качестве матрицы используется логическое число с цифрами abcdefghklmnopqr ₂ :

/ 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 байт).

Сборка 80386 ( 13 12 байт)

В качестве функции в синтаксисе AT & T с использованием соглашения о вызовах 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

Эта функция собирается в следующую последовательность байтов:

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поскольку его предыдущее содержимое перемещается во время цикла.

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

Примечание. Поскольку во второй версии не задано значение r=0, в коде предполагается, что значение int32 бита. Если это предположение ложно, функция, скорее всего, даст неправильный результат, в зависимости от начального состояния при 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дает вам представление битов (с учетом дополнения до двух). parseintне заботится о дополнении до двух, но возвращает 32-битное целое число, поэтому дополнение до двух просто обрабатывается переполнением.

Согласно журналам изменений, parseintв Julia 0.3 было добавлено обнаружение переполнения , поэтому это может больше не работать.

Python 2, 50

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

Во многом так же, как мое решение Pyth. Возьмите входной мод 2 ** 32, преобразуйте его в 32-разрядный двоичный файл с двоичными данными, переверните, преобразуйте двоичный код обратно в десятичный и напечатайте.

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

Функция, ввод номера и возврат обратного номера. Самый простой алгоритм, вероятно, может быть лучше в гольф с некоторыми хитрыми трюками.

Редактировать рекурсию вместо цикла

Изменить 2 Следуя предложению @bebe k*2вместоk<<1

Edit 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 в сборе, 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. #: yпредставляет yсобой число 2, используя столько мест, сколько необходимо.
2. x {. yпринимает |x(величину x) предметы yс фронта, если xположительный, со спины, если xотрицательный. Если мы возьмем больше предметов, чем присутствует, результат будет дополнен нулями. _32 {. #: yэффективно дополняет #: yдо 32 бит.
3. |. yсальто y, я. меняет порядок элементов в y.
4. #. y интерпретирует yкак число базы-2.

Дьялог АПЛ , 10 байт

2⊥⌽⎕⊤⍨32/2

2⊥ из базы-2 из

⌽ обращенный

⎕ числовой ввод

⊤⍨ в системе счисления, состоящей из

32/2 32 бита

Попробуй APL онлайн!

Python - 89

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

Python представляет отрицательные двоичные числа просто -0b{positive_number}. Таким образом, чтобы справиться с этим, дополнить отрицательные числа, а затем XOR со всеми 1.

После этого создайте строковое представление целого числа на основе формата, {:032b}который обеспечивает 32-битное представление числа. Наконец, переверните строку и превратите ее обратно в целое число.

РЕДАКТИРОВАТЬ

Благодаря @Martin Büttner за то, что он указал на проблему с дополнительным дополнением. Если nзаканчивается на 1, то в дополнение к двум обратная версия будет отрицательной.

К счастью, как объяснялось выше, Python любит отрицательные двоичные числа довольно простым способом. К счастью, intфункция Python позволяет использовать необязательные символы знака в своем первом аргументе.

Так что теперь, добавьте знак минус, если nнечетно, чтобы удовлетворить два дополнения.

Пиф , 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

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

Метод @Florian F в JS имеет длину 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 147 483 647 + 1) = 0, я могу зациклить до 0. Сдвиг бита Слева направо, чтобы переместить бит в первый позиция. Последний бит на месте 32 идет на 31 шаг вправо, второй последний идет на 30 и т. Д. Поэтому, используя оператор AND с 1, я узнаю, равен ли он 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);
}

Python - 37

Похоже на решение @ isaacg.

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

С ++, 160

Это не самый короткий, однако он использует только 24 операции.
Взято из книги Восторг Хакера.

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

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. строит список 0s и 1s, сначала младший значащий бит путем многократного деления на 2 и взятия остатка
3. объединяет бесконечный список 0s до конца этого списка
4. захватывает первые 32 элемента списка (последние два были необходимы, чтобы убедиться, что список на самом деле имеет длину 32 бита.)
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",$_

+1 за флаг p (дайте мне знать, если я считаю это неправильно).

Бежать с:

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

Р, 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'