32 비트 정수의 비트 순서를 바꾸려면 가장 짧은 코드를 작성하십시오.

규칙 :

1. 언어가 숫자 값 (예 : Windows Batch)을 지원하지 않는 경우 입력은 유효한 정수 또는 문자열과 동등한 것으로 간주됩니다.
2. 언어가 숫자 값 (예 : Windows Batch)을 지원하지 않는 경우 출력은 유효한 정수 또는 동등한 문자열이어야합니다.
3. 표준 라이브러리 만.
4. 기능이거나 완전한 프로그램 일 수 있습니다.
5. 입력은 stdin함수 인수 에서 또는 함수 인수 일 수 있습니다.
6. 출력은 stdout리턴 값이거나 리턴 값 이어야합니다 .
7. 언어에 한 단계 (예 : rbitARM 어셈블리)에서 이를 수행하는 내장 또는 표준 라이브러리 함수가 있는 경우 사용할 수 없습니다.

예 :

키:

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 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처음 두 명령어에서로드하는 것입니다. 두 번째 곱셈은 다음과 같습니다.

/ 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 바이트)

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루프 중에 이전 내용이 바뀔 때 명시 적으로 초기화하지 않습니다 .

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

참고 : 두 번째 버전은 설정을 생략 r=0하므로 코드는 a 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및 i0으로 전달되어야 작업 변수입니다.

줄리아 0.2, 33 바이트

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

어떻게 생겼는지.

bits비트 표현 (2의 보수를 존중)을 제공합니다. parseint2의 보수는 신경 쓰지 않지만 32 비트 정수를 반환하므로 2의 보수는 단순히 오버플로로 처리됩니다.

변경 로그에 따르면 parseintJulia 0.3에서 오버플로 감지가 추가 되었으므로 더 이상 작동하지 않을 수 있습니다.

파이썬 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. ";

자바 스크립트 (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}

테스트 에서 파이어 폭스 콘솔, 영업 이익 테스트를 사용하여 숫자와 좀 더 무작위로 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가 0이고 누군가가 신경 쓰면 CF와 ZF가 설정됩니다).

카운터 대신, 처음에 추가 1이 데이터 끝 마커로 입력됩니다.

J ( 17 15 13 바이트)

_32#.@|.@{.#:

다음은 그 기능을 설명하기위한 명시 적 정의입니다.

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

1. #: y는 y필요한만큼 많은 장소를 사용하여 밑이 2 인 숫자를 나타냅니다 .
2. x {. y소요 |x(의 크기 x)에서 항목을 y경우 전면에서, x경우에 후면에서 긍정 x부정. 현재보다 많은 항목을 가져 오면 결과가 0으로 채워집니다. 32 비트까지 _32 {. #: y효과적으로 패딩 #: y합니다.
3. |. y뒤집기 y, i. 의 항목 순서를 반대로 바꿉니다 y.
4. #. yy밑이 2 인 숫자로 해석 됩니다.

Dyalog APL , 10 바이트

2⊥⌽⎕⊤⍨32/2

2⊥ ~의 기초 -2

⌽ 반대로 된

⎕ 숫자 입력

⊤⍨ 숫자 시스템으로 구성된

32/2 32 비트

TryAPL 온라인!

파이썬-89

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

파이썬은 음의 이진수를 간단히 표현 -0b{positive_number}합니다. 따라서이 문제를 해결하려면 음수를 보완 한 다음 XOR을 모두 1로 보완하십시오.

그런 {:032b}다음 숫자의 32 비트 표현을 제공하는 형식 을 기반으로 정수의 문자열 표현을 작성하십시오 . 마지막으로 문자열을 뒤집고 다시 정수로 바꿉니다.

편집하다

2의 보수 문제를 지적한 @Martin Büttner 에게 감사드립니다 . 만약n 2의에 의해 다음 1에서 끝이 보완 반전 된 버전은 음수가 될 것입니다.

운 좋게도 위에서 설명한 것처럼 파이썬은 음의 이진수를 아주 간단한 방식으로 좋아합니다. 운 좋게도 파이썬의 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 : 역 따옴표를 저장하기 위해 반전하기 전에 추가로 이동했습니다.

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-Stanford 비트 트위들 링 핵 사용 과 같은 아이디어 . 골프에서 이길 수는 없지만 그럼에도 불구하고 흥미 롭습니다.

// 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 단계, 마지막은 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);
}

파이썬-37

@isaacg의 솔루션과 유사합니다.

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

C ++, 160

가장 짧은 것은 아니지만 24 개의 작업 만 사용합니다.
해커의 딜라이트 북에서 발췌.

골프 :

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

하스켈, 145-비트 연산 없음

Bit-twiddling은 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.

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

항상 파이썬 답변을 부끄러워하십시오. 그 빌어 먹을 키워드.

루비, 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

펄 5 : 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"))))))

펄 (37 + 1)

기본적으로 Todd Lehman의 C 솔루션 포트

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