21

32-बिट पूर्णांक के बिट क्रम को उलटने के लिए सबसे छोटा कोड लिखें।

नियम:

यदि आपकी भाषा संख्यात्मक मान (जैसे Windows बैच) का समर्थन नहीं करती है, तो इनपुट को एक मान्य पूर्णांक या स्ट्रिंग समतुल्य माना जाता है।
यदि आपकी भाषा संख्यात्मक मान (जैसे Windows बैच) का समर्थन नहीं करती है तो आउटपुट एक मान्य पूर्णांक या स्ट्रिंग समतुल्य होना चाहिए।
केवल मानक पुस्तकालय।
यह एक समारोह या एक पूरा कार्यक्रम हो सकता है।
इनपुट stdinया तो फ़ंक्शन तर्क के रूप में या से हो सकता है।
आउटपुट stdoutया तो लौटाया हुआ मान होना चाहिए ।
यदि आपकी भाषा में एक अंतर्निहित या मानक लाइब्रेरी फ़ंक्शन है जो इसे एक चरण में (जैसे rbitARM असेंबली में) करता है, जिसका उपयोग नहीं किया जा सकता है।

उदाहरण:

कुंजी:

दशमलव
- बाइनरी
- (रिवर्स)
- उलटा बाइनरी
- दशमलव उत्पादन

उदाहरण:

-90 (प्रदर्शन के लिए 8-बिट उदाहरण)
- 10100110b
- (रिवर्स)
- 01100101b
- 101
486
- 00000000000000000000000111100110b
- (रिवर्स)
- 01100111100000000000000000000000b
- 1736441856
-984802906
- 11000101010011010001100110100110b
- (रिवर्स)
- 01100101100110001011001010100011b
- 1704506019

नोट: ओमीशन मुफ्त गेम हैं। अगर मैंने यह नहीं कहा, और यह मानक खामियों में से एक नहीं है , तो यह पूरी तरह से अनुमति है।

code-golf bitwise

— इसियाह मीडोज
स्रोत

"ऑमिशन" फ्री गेम हैं "चूक" से क्या मतलब है?

— टॉड लेहमन

1

नियमों में स्पष्ट रूप से कुछ भी नहीं कहा गया है।

— इसियाह मीडोज

क्या प्रोग्राम लंबाई के हिस्से के रूप में एक 16 जीबी स्टैटिक टेबल गिना जाएगा?

— हॉट लिक्स

@HotLicks कार्यक्रम की विशिष्ट व्याख्या के अनुसार, हाँ।

— फूजएक्सएक्सएल

वह भाषा जो केवल 8-बिट इनपुट्स का समर्थन करती है, क्या हम इनपुट को चार 8-बिट संख्याओं के रूप में ले सकते हैं?

— 18

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 FA9 बाइट्स।

— Myria
स्रोत

यदि आप (क) वास्तव में cdecl कॉलिंग कन्वेंशन का पालन करते हैं और (b) वास्तव में फ़ंक्शन से वापस आते हैं तो यह मेरे समाधान के समान है।

— फ्युजएक्सएक्सएल

@FZxxl किसी तरह, मैंने आपका संस्करण नहीं देखा। आप पूरी तरह से सही हैं। मैं सोच रहा था __fastcallऔर नहीं था ret।

— मायारिया

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अनुदेश दो 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 बिट संख्या

यदि आप 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 बाइट्स)।

— FUZxxl
स्रोत

1

यह पहली बार है जब मैंने सीपीयू पर मैट्रिक्स गुणन निर्देश के बारे में सुना

— phuclv

@ LưuV LnhPhúc: मैट्रिक्स गुणन नहीं है, लेकिन VAX को एक बहुपद का मूल्यांकन करने का निर्देश था ।

— nnonneo

1

@nneonneo POLYवैक्स का निर्देश मूल रूप से एक निर्मित लूप के साथ गुणा-जोड़ और जोड़ है। आधुनिक वास्तुशिल्प में भी इसी तरह की चीजें मौजूद हैं (जैसे x86), लेकिन उनके पास एक बार में एक पूरे बहुपद का मूल्यांकन करने के लिए एक बेसिन लूप नहीं होता है।

— FUZxxl

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
स्रोत

+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 , और डेनिस द्वारा तैयार किए गए परिवर्तनों के साथ ):

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 के रूप में पारित किया जाना चाहिए।

— टॉड लेहमैन
स्रोत

1

आप intफ़ंक्शन प्रकार को हटा सकते हैं , और return rकुछ को भी बदल सकते हैं जैसे i=rकि अधिकांश सी संकलक रिटर्न ऑपरेशन में अंतिम ऑपरेशन के परिणाम को छोड़ देते हैं। इसने मेरे लिए gcc और cl पर काम किया।

— एलबेर्ट

1

आप का उपयोग करके एक और 4 बाइट बंद दाढ़ी सकता है r(n){...}बजायr(int n){...}

— es1024

2

@FUZxxl आप ड्रॉप नहीं कर सकते intमें int r=0,i=32;जब तक आप उन्हें समारोह शरीर से बाहर चले जाते हैं।

— es1024

1

@FUxxxxl: जब मैं थक गया हूँ तो टिप्पणी नहीं करना चाहिए ... अंकगणितीय बदलाव और विभाजन बराबर नहीं हैं; उत्तरार्द्ध शून्य की ओर घूमता है, जबकि पहला नकारात्मक अनंत की ओर गोल होता है। -1 >> 1है -1के रूप में के लिए और 2**31 - 1जबकि, लोकसभा के लिए -1 / 2है 0।

— डेनिस

1

@Todd: कोई भी कारण जिसे आपने परिभाषित नहीं किया है rऔर iतर्क के रूप में? तीन और बाइट्स बचाएंगे ...

— डेनिस

5

जूलिया 0.2, 33 बाइट्स

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

जैसा दिखता है वैसा करता है।

bits आपको थोड़ा प्रतिनिधित्व देता है (दो के पूरक का सम्मान करते हुए)। parseintदो के पूरक के बारे में परवाह नहीं है, लेकिन एक 32 बिट पूर्णांक लौटाता है, इसलिए दो का पूरक बस अतिप्रवाह द्वारा नियंत्रित किया जाता है।

चैंज के अनुसार, parseintजूलिया 0.3 में अतिप्रवाह का पता लगाया गया था , इसलिए यह अधिक काम नहीं कर सकता है।

— मार्टिन एंडर
स्रोत

5

यह उत्पादन कोड है, न कि गोल्फ कोड! xD मुझे लगता है कि जूलिया सिर्फ महान है।

— cjfaure

4

अजगर 2, 50

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

मोटे तौर पर मेरे पाइथ सॉल्यूशन के समान। इनपुट मॉड 2 ** 32 को लें, 32-बिट गद्देदार बाइनरी में कनवर्ट करें, रिवर्स, बाइनरी स्टिंग को दशमलव और प्रिंट में बदलें।

— isaacg
स्रोत

4

सीजेएम, 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. ";

— डेनिस
स्रोत

4

जावास्क्रिप्ट (E6) 37 39 40 50

फ़ंक्शन, संख्या इनपुट और वापस लौटाने की संख्या। ~~सबसे बुनियादी एल्गोरिथ्म, शायद कुछ स्मार्ट चाल के साथ अधिक गोल्फ हो सकता है।~~

लूप के बजाय रिकर्सन संपादित करें

संपादित करें 2 केk*2 बजाय @bebe सुझाव का पालन करेंk<<1

3 संपादित करें कुछ मुझे याद किया गया था: यह एक पूर्ण 32 बिट लूप है, कश्मीर को आरंभीकृत करने की कोई आवश्यकता नहीं है। धन्यवाद @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

— edc65
स्रोत

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

@bebe :( मैं पुनरावृत्ति का उपयोग करके अपने उत्तर को संशोधित कर रहा था और आपकी टिप्पणी पढ़ने के लिए सभी खो गया ...

— edc65

2

आप 38 बाइट्स पर हैं अगर k<<1बन जाता है k*2और v>>1बन जाता है v/2। यह 486 के लिए काम करता था। मुझे अन्य परीक्षण मामलों के बारे में पता नहीं है

— bebe

1

@bebe v / 2 नकारात्मक संख्या के लिए काम नहीं करेगा। 486/512 == 0.9 ... और 486 >> 9 == 0, यह एक ही है। लेकिन -90/128 == -0.7 ... और -90 >> 7 == - 1

— edc65

4

x86 असमान, 10 बाइट्स

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

यह ईईएक्स में इनपुट मान, एडएक्स में आउटपुट। (इसके अलावा, आउटपुट ईएक्स पर शून्य है और सीएफ और जेडएफ सेट है, अगर किसी को परवाह है)।

काउंटर के बजाय, एक अतिरिक्त 1 को शुरुआत में डेटा मार्कर के अंत में धकेल दिया जाता है

— हेगेन वॉन एटिजन
स्रोत

यह वास्तव में मेरे समाधान के समान आकार है, जो तीन बाइट्स बड़ा है। आप जोड़ देते हैं तो retसमारोह से लौट सकते हैं और cdecl को लागू करने के निर्देश (यानी परिवर्तन rcr %eaxकरने के लिए rcr 4(%esp)और rcl %edxकरने के लिए rcl %eax), तो आप के लिए एक अतिरिक्त बाइट के साथ खत्म हो retऔर स्मृति में संदर्भ के लिए एक और दो बाइट्स। फिर भी, एक अच्छा समाधान।

— फ़ूजएक्सएक्सएल

3

जे ( 17 15 13 बाइट्स)

_32#.@|.@{.#:

यह स्पष्ट करने के लिए कि यह क्या करता है:

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

#: yyआवश्यक के रूप में कई स्थानों का उपयोग करके आधार 2 नंबर के रूप में प्रतिनिधित्व करता है।
x {. yनकारात्मक होने पर, सामने से , सकारात्मक होने पर , से आइटम |xका (परिमाण x) लेता है। यदि हम वर्तमान से अधिक आइटम लेते हैं, तो परिणाम शून्य से गद्देदार होता है। प्रभावी ढंग से 32 बिट्स को पैड ।yxx_32 {. #: y#: y
|. yflips y, i। वस्तुओं के क्रम को उलट देता है y।
#. yyआधार -2 नंबर के रूप में व्याख्या ।

— FUZxxl
स्रोत

3

Dyalog एपीएल , 10 बाइट्स

2⊥⌽⎕⊤⍨32/2

2⊥ के आधार -2 से

⌽ उलटा हुआ

⎕ संख्यात्मक इनपुट

⊤⍨ संख्या प्रणाली से मिलकर

32/2 32 बिट्स

TryAPL ऑनलाइन!

— एडम
स्रोत

2

अजगर - 89

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

पायथन बस के रूप में नकारात्मक द्विआधारी संख्या का प्रतिनिधित्व करता है -0b{positive_number}। तो इससे निपटने के लिए, नकारात्मक संख्याओं को पूरक करें और फिर सभी 1 के साथ XOR।

उसके बाद, पूर्णांक के स्ट्रिंग प्रतिनिधित्व को प्रारूप के आधार पर बनाएं {:032b}जो संख्या का 32 बिट प्रतिनिधित्व प्रदान करता है। अंत में, स्ट्रिंग को उल्टा करें और इसे एक पूर्णांक में वापस करें।

संपादित करें

एक दो के पूरक मुद्दे की ओर इशारा करने के लिए @ मर्टिन ब्यूटनर को धन्यवाद । अगरn 1 में समाप्त होता है तो दो के पूरक द्वारा उलटा संस्करण नकारात्मक होगा।

सौभाग्य से, जैसा कि ऊपर बताया गया है, पायथन को काफी सरल तरीके से नकारात्मक बाइनरी नंबर पसंद हैं। साथ ही सौभाग्य से, पायथन का intकार्य अपने पहले तर्क में वैकल्पिक संकेत पात्रों को अनुमति देता है।

तो अब, nदो के पूरक को संतुष्ट करने के लिए विषम है तो एक ऋण चिह्न जोड़ें ।

— BeetDemGuise
स्रोत

@ मार्टिनबटनर धन्यवाद। मुझे वह संभावना पहली बार में याद आई। नया कोड दो के पूरक को बेहतर ढंग से संभालता है।

— BeetDemGuise

2

आप थोड़ा और अधिक गोल्फ कर सकते हैं: ['','-'][n%2]है '-'*(n%2)।

— जस्टिन

2

पायथ , ३३ ३२ २२

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.

golfs:

33 -> 32: अंत-उद्धरण को बचाने के लिए उलटने से पहले जोड़ा गया।

32 -> 22: जटिल मशीनरी के बजाय क्यू मॉड 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

— isaacg
स्रोत

क्या यह एक बड़ी 32 संख्या के रूप में परिणाम के साथ काम करता है जिसमें 1 पर सबसे कम बिट होता है? इस मामले में यह एक नकारात्मक पूर्णांक का उत्पादन करना चाहिए।

— edc65

@ edc65 मैं एक 32 बिट अहस्ताक्षरित पूर्णांक आउटपुट कर रहा हूं।

— isaacg

2

जीएनयू डीसी, 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
$

बैश + कोरुटिल्स, 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
$

सी फ़ंक्शन, 89 बाइट्स

Https://codegolf.stackexchange.com/a/36289/11259 के रूप में एक ही विचार - स्टैनफोर्ड बिट twiddling हैक का उपयोग कर । गोल्फ जीतने के लिए नहीं जा रहा है, लेकिन फिर भी दिलचस्प है:

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

— डिजिटल आघात
स्रोत

2

जावा फ़ंक्शन, 64 वर्ण।

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

सी। में भी काम करना चाहिए।

— फ्लोरियन एफ
स्रोत

2

PHP, 46 बाइट्स

ऑनलाइन संस्करण

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

या

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

— जार्ग हुल्सरमन
स्रोत

substrअनावश्यक (-12 बाइट्स) है। आपको उन्हें चलाने का उल्लेख करना चाहिए।

— टाइटस

1

@ क्या आपने टेस्टकेस की कोशिश की है -984802906?

— जार्ज ह्यूल्समैन

1

आपका दूसरा संस्करण पहले मैच के लिए सुधारा जा सकता है:<?=bindec(strrev(sprintf("%064b",$argn<<32)));

— क्रिस्टोफ़

@Christoph बहुत अच्छा सुधार धन्यवाद

— Jörg Hülsermann

1

जेएस 115

खैर यह सब अच्छा नहीं लगता: डी

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)

— Bebe
स्रोत

1

it may be a functionशासन का मतलब है कि आपको सूचना या शीघ्र की जरूरत नहीं है

— slebetman

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,147,483,647 + 1) = 0 मैं 0. को शिफ्ट करने के लिए लूप कर सकता हूं। बिट को पहली बार में स्थानांतरित करने के लिए दाएं से बाएं स्थान। अंतिम स्थान पर ३२, ३१ कदम दाईं ओर, दूसरा अंतिम ३० आदि पर जाता है। इसलिए 1 के साथ AND ऑपरेटर का उपयोग करके मुझे पता चलेगा कि क्या यह १ या ० है। यदि यह १ है तो मैं वर्तमान 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
स्रोत

छोटी चीजें, लेकिन iजब आप इसे घोषित करते हैं, तो आप प्रारंभिक कर सकते हैं , और i++लूप के लिए निकालकर एक बाइट को बचा सकते हैं , और 1&...0 के परिणाम की तुलना करने के बजाय , यदि आप कथन को पूरी तरह से हटा सकते हैं और iपरिणाम को r|=i*(1&(V>>(31-l++)));लूप के अंदर देकर गुणा कर सकते हैं

— विज़ुअलाइलॉन

चतुर! मुझे लग रहा था कि मुझे कुछ याद आ रहा है। धन्यवाद!

— वोज़ज़ेक

1

सी # 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);
}

— BenVlodgi
स्रोत

1

अजगर - ३ 37

@ Isaacg के समाधान के समान।

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

— cjfaure
स्रोत

1

सी ++, 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; 
}

— सोमनीम का पता चलता है
स्रोत

1

यह एक कोड गोल्फ प्रश्न है। कृपया अपने समाधान में वर्णों की संख्या कम करने का प्रयास करें, न कि संचालन की संख्या।

— फ़ूजएक्सएक्सएल

1

हास्केल, 145 - कोई बिटवाइज़ ऑपरेशन नहीं

बिट-ट्विगलिंग मुझे हास्केल के विरोधी के रूप में मारता है, इसलिए मैंने बिटवाइज़ ऑपरेटरों के किसी भी उपयोग से बचा है। परिणामस्वरूप कार्यक्रम निश्चित रूप से सबसे कम प्रतियोगी नहीं है, लेकिन मुझे लगा कि बिट-ट्विडलिंग के बजाय गणित का उपयोग कम से कम दिलचस्प था।

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

परिणाम को 32-बिट श्रेणी में लाने के लिए मोडुलो का उपयोग करता है
की सूची 0बनाता है और1बार-बार 2 से भाग देने और शेष लेने से कम से कम पहले महत्वपूर्ण एस बनाता है
की एक अनंत सूची को समेटता है 0इस सूची के अंत में
सूची के पहले 32 तत्वों को पकड़ लेता है (सूची को वास्तव में 32 बिट लंबा है यह सुनिश्चित करने के लिए इन अंतिम दो की आवश्यकता थी।)
सबसे महत्वपूर्ण बिट को पहले (दोहरा दोहरा और जोड़) मानते हुए एक सूची में 0और 1पूर्णांक में परिवर्तित करता है ।

मुझे पूरा यकीन नहीं है कि हास्केल में "मानक पुस्तकालय" का गठन किया गया था इसलिए मैंने Data.Tuple और Data.List को मान लिया (वे बहुत मानक हैं)।

इसके अलावा, आउटपुट एक अहस्ताक्षरित 32-बिट पूर्णांक है जिसे बदलने के बाद मुझे बाइट्स खर्च होंगे: मैं यह तर्क दे रहा हूं कि "चूक स्वतंत्र खेल हैं"।

— ballesta25
स्रोत

मानक पुस्तकालय: भाषा के साथ क्या जहाज। इसमें C के लिए सिस्टम हेडर, जावा में 4000+ कक्षाएं और विधियाँ शामिल हैं (अधिकांश अप्रासंगिक हैं)।

— इसियाह मीडोज

1

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।

— टाइटस
स्रोत

0

पर्ल - 60

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

पी ध्वज के लिए +1 (मुझे बताएं कि क्या मैं यह गलत गिन रहा हूं)।

साथ दौड़ो:

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

— hmatt1
स्रोत

0

सी ++ 69

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

— rdans
स्रोत

@ कबी ये क्या हैं e;i;? प्रकार के बिना घोषणाएँ मान्य C ++ नहीं हैं। चर के लिए तो यह और भी मान्य सी नहीं है

— रुस्लान

@Ruslan मैंने शीर्षक में '++' को नहीं पहचाना, क्षमा करें। (मैं अपने दूसरे कथन से सहमत नहीं होगा)

— Bebe

int r(int n){int e=0,i=0;for(;i<32;)e=e*2|1&n>>i++;return e;}61 बाइट्स :)

— क्रिस्टोफ

0

आर, 45

f=function(x)packBits(intToBits(x)[32:1],"i")

उदाहरण:

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

हमेशा पायथन के जवाबों से शर्माते हैं। उस लानत समारोह कीवर्ड।

— shadowtalker
स्रोत

0

माणिक, 43 41 बाइट्स

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

रूबी में, ब्रैकेट इंडेक्स नोटेशन (फू [i]) का उपयोग करके nth स्थान पर बिट लौटाता है।

--Edit--

पुनर्रचना injectकार्यक्षमता शेव एक जोड़े बाइट्स

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

— Marcus erronius
स्रोत

0

पर्ल 5: 46

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

कुछ भी आकर्षक नहीं। यह उत्पादन दाएं स्थानांतरित करता है, स्रोत सही स्थानांतरण से पहले lsb की प्रतिलिपि बनाता है।

— Sylwester
स्रोत

0

क्लोजर, 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"))))))

— बॉब जार्विस - मोनिका को बहाल करें
स्रोत

0

पर्ल (37 + 1)

मूल रूप से टॉड लेहमैन द्वारा सी समाधान का एक बंदरगाह

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

— चीनी पर्ल गोथ
स्रोत

32-बिट इंटेगर का रिवर्स ऑर्डर

MMIX विधानसभा (28 बाइट्स)

64 बिट संख्या

यह कैसे काम करता है?

32 बिट संख्या

80386 विधानसभा ( 13) 12 बाइट्स)

C, 63 52 48

जूलिया 0.2, 33 बाइट्स

अजगर 2, 50

सीजेएम, 15 बाइट्स

परीक्षण के मामलों

यह काम किस प्रकार करता है

जावास्क्रिप्ट (E6) 37 39 40 50

x86 असमान, 10 बाइट्स

जे ( 17 15 13 बाइट्स)

Dyalog एपीएल , 10 बाइट्स

अजगर - 89

पायथ , ३३ ३२ २२

जीएनयू डीसी, 27 बाइट्स

आउटपुट:

बैश + कोरुटिल्स, 45 बाइट्स

आउटपुट:

सी फ़ंक्शन, 89 बाइट्स

आउटपुट:

जावा फ़ंक्शन, 64 वर्ण।

PHP, 46 बाइट्स

जेएस 115

C # 81 74

सी # 142

अजगर - ३ 37

सी ++, 160

हास्केल, 145 - कोई बिटवाइज़ ऑपरेशन नहीं

व्याख्या

PHP, 46 41 बाइट्स

पर्ल - 60

सी ++ 69

आर, 45

माणिक, 43 41 बाइट्स

--Edit--

पर्ल 5: 46

क्लोजर, 202 156 142

पर्ल (37 + 1)