32 bit tamsayının bit sırasını ters çevirmek için en kısa kodu yazın.

Kurallar:

1. Diliniz sayısal değerleri desteklemiyorsa, girişin geçerli bir tamsayı veya dize eşdeğeri olduğu varsayılır (örneğin, Windows Toplu İşi).
2. Diliniz sayısal değerleri desteklemiyorsa çıktı geçerli bir tamsayı veya dizeye eşdeğer olmalıdır (örn. Windows Toplu İş).
3. Sadece standart kütüphane.
4. Bir işlev veya tam bir program olabilir.
5. Giriş, stdinişlev argümanından veya işlev argümanı olabilir.
6. Çıktı ya stdoutdöndürülen bir değer olarak ya da olmalıdır .
7. rbitDilinizde bir adımda (örneğin ARM montajında) bunu yapan yerleşik veya standart bir kütüphane işlevi varsa, kullanılamaz.

Örnekler:

Anahtar:

1. ondalık
   • ikili
   • (ters)
   • ters ikili
   • ondalık çıktı

Örnekler:

1. -90 (Gösteri için 8 bit örnek)

   • 10100110b
   • (ters)
   • 01100101b
   • 101

2. 486

   • 00000000000000000000000111100110b
   • (ters)
   • 01100111100000000000000000000000b
   • 1736441856

3. -984802906

   • 11000101010011010001100110100110b
   • (ters)
   • 01100101100110001011001010100011b
   • 1704506019

Not: Eksiklikler ücretsizdir. Söylememiş olsaydım ve bu standart boşluklardan biri değilse , o zaman tamamen izin verilir.

x86 derleme, 9 bayt

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

Bayt formunda:, 33 C0 40 D1 E9 13 C0 73 FA9 bayt.

MMIX derlemesi (28 Bayt)

64 bit sayılar

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

Bu toplanır:

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

O nasıl çalışır?

MORTalimat Boolean iki 8x8 matris olarak kullanılabilir iki 64-bit miktarlarda bir matris çarpımını yapar. Abcdefghklmnopqr ₂ basamaklı bir boolean sayısı şöyle bir matris olarak kullanılır:

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

MORTalimat çarpar matrisler çarpma olduğunu onların argümanları ile temsil andve ektir or. Bu:

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

ve ayrıca:

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

Bu, orijinal sayının bitlerinin ters sırasıdır.

32 bit sayılar

64 bitlik sayı yerine 32 bitlik bir sayının tersini istiyorsanız, bu değiştirilmiş yöntemi kullanabilirsiniz:

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

birleştirilmiş:

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

İlk matris çarpımı temelde şöyle çalışır:

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

karşılık gelen oktabayt, #0000000001020408ilk iki talimatta yüklediğimizdir. İkinci çarpım şöyle görünür:

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

Karşılık gelen oktabayt, #0102040810204080aşağıdaki gibi birinci matristen yarattığımız şeydir :

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

İkinci çarpım her zamanki gibi işdir, sonuçta ortaya çıkan kod aynı uzunluktadır (28 bayt).

80386 derleme ( 13 12 bayt)

AT&T sözdizimindeki bir işlev olarak cdecl çağrı kuralını kullanarak.

    # 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

Bu işlev aşağıdaki bayt sırasına toplanır:

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

Talimatlara ayrıldı:

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    

Şunun gibi çalışır: Döngünün 32 tekrarının her birinde, bulunan argüman 4(%esp)bir konumla sağa kaydırılır. Son bit, dolaylı olarak taşıma bayrağına kaydırılır. adcTalimat iki değeri ekler ve sonuca taşıma bayrağının değer katar. Kendinize bir değer eklerseniz, yani %eaxetkili bir şekilde tek bir konuma kaydırırsınız. Bu adc %eax,%eaxsola kaydırma için uygun bir yol yapar%eax , taşıma bayrağının içeriğini düşük sıra bitine kaydırırken bir konum .

Bu işlemi 32 defa tekrarlıyorum, böylece içeriğinin tamamı 4(%esp)harcanıyor %eax. %eaxDöngü sırasında önceki içerikleri değiştirildiği için hiçbir zaman açıkça başlatmam .

C,    63    52   48

Orijinal versiyon:

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

Güncelleme sürümü ( Allbeert , es1024 ve Dennis tarafından önerilen değişikliklerle ):

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

Not: İkinci sürüm ayar ihmal r=0ettiğinden, kod bir int32 bit olduğunu varsayar . Bu varsayım yanlış ise, fonksiyona ilk rgiriş durumuna bağlı olarak, işlev büyük olasılıkla yanlış bir sonuç verecektir .

Son versiyon ( Dennis ve Alchymist tarafından önerilen diğer değişikliklerle ):

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

Not: Bu çalışma değişkenlerinin beyanı koyar rve iparametre listesine. Parametreler şu şekildedir: nbit ters çevrilecek sayıdır. rve i0 olarak geçirilmesi gereken iş değişkenleridir.

Julia 0.2, 33 bayt

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

Göründüğü gibi yapar.

bits size bit gösterimini verir (ikinin tamamlayıcısına saygı göstererek). parseintikinin tamamlayıcısı umrunda değil, ama 32 bit bir tamsayı döndürür, bu yüzden ikinin tamamlayıcısı taşma tarafından basitçe ele alınır.

Değişikliklere göre parseint, Julia 0.3'te taşma saptaması eklendi , bu yüzden artık işe yaramayabilir.

Python 2, 50

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

Pyth çözümümle tamamen aynı. Giriş modunu 2 ** 32 alın, 32 bit yastıklı ikiliye dönüştürün, ters çevirin, ikili sokmayı tekrar ondalık basamağa dönüştürün ve yazdırın.

CJam, 15 bayt

li4H#+2bW%32<2b

Çevrimiçi deneyin.

Kullanılan "Ücretsiz oyun" joker: Çıktı her zaman imzasız olacak tamsayı olacaktır.

Test durumları

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

Nasıl çalışır

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

İşlev, sayı girişi ve geri dönen sayı. En basit algoritma, muhtemelen bazı akıllı numaralarla daha fazla golf oynayabilir.

Döngü yerine özyinelemeyi düzenleme

Düzenle 2 Aşağıdaki @bebe önerisini k*2yerinek<<1

Düzenleme 3 Özlediğim bir şey: tam bir 32 bit döngü, k başlatmaya gerek yok. @ FUZxxl Teşekkürler

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

Öyleydi

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

Testi olarak FireFox konsol, OP testi kullanılarak numaralar ve biraz daha rastgele 16 ve 32 bit sayıları

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

Test çıktısı örneği

        -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 montajı, 10 Bayt

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

Bu, eax'ta girdiyi, edx'te çıktı olduğunu varsayar. (Ayrıca, çıkış eax'i sıfırdır ve birinin umurunda olursa CF ve ZF ayarlanır).

Bir sayaç yerine, başlangıçta veri sonu işaretçisi olarak ek bir 1 itilir

J ( 17 15 13 bayt)

_32#.@|.@{.#:

İşte ne yaptığını açıklamak için açık bir tanım:

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

1. #: y Temsil ygerektiği kadar çok yer kullanarak bir temel 2 sayısını .
2. x {. yPozitif ise önden , negatif ise arkadan |x(büyüklükte x) öğe alır . Mevcut olandan daha fazla öğe alırsak, sonuç sıfırlarla doldurulur. etkili pedleryxx_32 {. #: y#: y şekilde 32 bite .
3. |. yçevirir y, ben. içindeki öğelerin sırasını ters çeviriry .
4. #. y yorumlayan ve ybir baz-2 sayısı.

Dyalog APL , 10 bayt

2⊥⌽⎕⊤⍨32/2

2⊥ taban-2’den

⌽ tersine döndü

⎕ sayısal giriş

⊤⍨ oluşan sayı sisteminde

32/2 32 bit

TryAPL çevrimiçi!

Python - 89

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

Python negatif ikili sayıları basitçe gösterir -0b{positive_number} . Bununla başa çıkmak için, negatif sayıları ve ardından tüm 1'lerle XOR'yi tamamlayın.

Bundan sonra, formata dayalı tamsayı dizesi gösterimini oluşturun. {:032b} 32bit gösterimini sağlayan . Son olarak dizgiyi ters çevirin ve tamsayıya geri çevirin.

DÜZENLE

İkilinin tamamlayıcı sorununa dikkat çektiğiniz için @Martin Büttner'e teşekkür ederiz . Eğern iki yıllardan tarafından daha sonra bir 1 uçları tamamlayacak tersine versiyonu negatif olacaktır.

Neyse ki, yukarıda açıklandığı gibi, Python negatif ikili sayıları oldukça basit bir şekilde seviyor. Neyse ki, Python intişlevi isteğe bağlı işaret karakterlerine izin verir ilk argümanında .

Öyleyse, nikisinin tamamlayıcısını tatmin etmek tekse eksi işareti ekleyin .

Pyth , 33 32 22

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

Açıklama:

                 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.

Golf'ün:

33 -> 32: Bir son teklifi kaydetmek için geri çevrilmeden önce eklentiye taşındı.

32 -> 22: Karmaşık makine yerine Q mod 2 ^ 32 kullanıldı. Her iki dizeyi bir arada birleştirdi.

Test durumları:

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

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

Çıktı:

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

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

Çıktı:

$ ./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 işlevi, 89 bayt

Https://codegolf.stackexchange.com/a/36289/11259 ile aynı fikir - Stanford bit çırpma kesenlerini kullanarak . Golfü kazanmayacak, ama yine de ilginç:

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

Çıktı:

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

Java işlevi, 64 karakter.

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

C de çalışmalı

PHP, 46 Bayt

Çevrimiçi Sürümler

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

veya

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

JS 115

Peki bu hiç iyi görünmüyor: D

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

@Florian F'nin JS'deki metodu 53 bayttır:

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

Tüm programlama dillerinde daha kısa sürede yapılabilecek bit işlemleri.

Temel olarak, maksimum + 1 (iki gücüne dönüşür) tamsayıya kadar tüm güçlerden 2'ye kadar döngü ve (2.147.483.647 + 1) = 0'a kadar dönebilir. 0'a dönebilirim. konumu. 32. noktadaki son bit sağa 31 adım, ikinci son 30 vb. Gider. Böylece, 1 ile VE işleci kullanarak 1 ya da 0 olduğunu bilirim. 1 ise, geçerli i değerini sonuca ekleyeceğim iade etmek.

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

Expanded

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

Python - 37

@ İsaacg'nin çözümüne benzer.

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

C ++, 160

Bu en kısa değil, ancak sadece 24 işlem kullanıyor.
Hacker's Delight kitabından alındı.

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 - bitsel işlem yok

Bit-twiddling, Haskell'in antitezi olarak bana saldırıyor, bu yüzden bitsel operatörleri kullanmaktan kaçındım. Sonuçta ortaya çıkan program kesinlikle en kısa yarışmacı değil, ancak bit bükme yerine matematik kullanımının en azından ilginç olduğunu düşündüm.

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

açıklama

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. sonucu 32 bit menzile getirmek için modulo kullanır
2. 0s listesini oluşturur ve1Önce 2'ye bölünerek ve kalanı alarak ilk önce en az anlamlı bit s
3. sonsuz bir listesini birleştirir 0 s listesini bu listenin sonuna kadar
4. Listenin ilk 32 elemanını kaptı (listenin gerçekten 32 bit uzunluğunda olması için bu son ikisine ihtiyaç vardı.)
5. En önemli bitin ilk olduğunu varsayarak bir listeyi 0ve 1bir tamsayıya dönüştürür (tekrarlanan çift ve ekleme).

Haskell'de "standart kütüphaneyi" neyin oluşturduğundan emin değilim, bu yüzden Data.Tuple ve Data.List öğelerinin tamam olduğunu kabul ettim (oldukça standartlar).

Ayrıca, çıktısı imzasız bir 32-bit tamsayıdır, çünkü değişiklik bana baytlara mal olur: Bunu "ihmaller bedava oyun" başlığı altında savunuyorum.

PHP, 46 41 bayt

onları çevrimiçi dene

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

bit yönünde ... az ya da çok. İle boru olarak çalıştırphp -nR '<code>' .

PHP, 46 bayt

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

saf bir bit çözümü; ile boru gibi çalıştırmak-nR .

PHP, 47 59 bayt

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

başka bir yerleşik yaklaşım; dosyaya kaydedin ve ile boru olarak çalıştırın -F.

Perl - 60

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

P bayrağı için +1 (bunu yanlış sayıyorsam bana haber ver).

Çalıştır:

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

Örnekler:

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

Her zaman sadece Python cevaplarına utangaç. Bu lanet işlev anahtar kelimesi.

Yakut, 43 41 bayt

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

Ruby'de, parantez indeksi notasyonunu (foo [i]) kullanmak, nth yerine biti döndürür.

--Düzenle--

Üstlenmeden injectbir çift bayt işlevsellik tıraş

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}

Hiçbir şey fantezi. Çıktıyı sola kaydırır, kaynağı sağa kaydırmadan önce lsb'yi kopyalar.

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)

temelde Todd Lehman'ın C çözümünün limanı

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