तो आपको एक POSITIVE आधार 10 (दशमलव) नंबर दिया जाता है। आपका काम बाइनरी अंकों को उल्टा करना है और उस आधार को 10 नंबर पर वापस करना है।

उदाहरण:

1 => 1 (1 => 1)
2 => 1 (10 => 01)
3 => 3 (11 => 11)
4 => 1 (100 => 001)
5 => 5 (101 => 101)
6 => 3 (110 => 011)
7 => 7 (111 => 111)
8 => 1 (1000 => 0001)
9 => 9 (1001 => 1001)
10 => 5 (1010 => 0101)

यह एक कोड-गोल्फ चुनौती है, इसलिए समाधान जो कम से कम बाइट्स जीत का उपयोग करता है।

यह OEIS में A030101 है।

— juniorRubyist
स्रोत

2

क्या "बिट्स रिवर्स" का अर्थ है अपने द्विआधारी अंकों को उल्टा करना? कभी-कभी इसका मतलब हर पल उल्टा भी हो सकता है ।

— 18

हाँ। अस्पष्ट होने के लिए क्षमा करें।

— जूनियर जूनियर

यह और यह एक समान हैं।

— Geobits

OEIS A030101 ।

— orlp

1

"आधार 10" कोई विशेष कारण क्यों?

— कैलक्यूलेटरफ्लेन

20

पायथन , 29 बाइट्स

lambda n:int(bin(n)[:1:-1],2)

इसे ऑनलाइन आज़माएं!

यह एक अनाम, अनाम फ़ंक्शन है जो परिणाम देता है।

सबसे पहले, bin(n)तर्क को एक बाइनरी स्ट्रिंग में कनवर्ट करता है। हम आमतौर पर इसे स्लाइस अंकन के साथ उलट देंगे [::-1]। यह स्ट्रिंग को -1 के कदम के साथ पढ़ता है , अर्थात पीछे की ओर। हालाँकि, पायथन में बाइनरी स्ट्रिंग्स एक के साथ उपसर्ग कर रहे हैं 0b, और इसलिए हम 1 के रूप में स्लाइसिंग का दूसरा तर्क देते हैं , पायथन को इंडेक्स 1 पर पीछे की ओर पढ़ने के लिए कह रहा है , इस प्रकार इंडेक्स 1 और 0 को नहीं पढ़ रहा है ।

अब जब हमारे पास पीछे की तरफ बाइनरी स्ट्रिंग है, तो हम इसे 2 केint(...) रूप में दूसरे तर्क के साथ पास करते हैं । यह स्ट्रिंग को आधार 2 पूर्णांक के रूप में पढ़ता है, जो फिर लंबोदर एक्सप्रेशन द्वारा लौटाया जाता है।

— FlipTack
स्रोत

2

आपको 9 सेकंड से हराया।

— mbomb007

4

@ mbomb007 meta.codegolf.stackexchange.com/a/10812/14215

— Geobits

6

@ mbomb007 तो मेरा जवाब अमान्य है क्योंकि आपने हाथ से 9 सेकंड पहले पोस्ट बटन पर क्लिक किया है? सिर्फ इसलिए कि हम एक ही समय पर एक ही गोल्फ में पहुंचते हैं, इसका मतलब यह नहीं है कि हमें कोई उत्तर हटाना है। कुछ भी हो, 0-प्रयास प्रश्न को दोष दें।

— FlipTack

3

अमान्य नहीं है, लेकिन निश्चित रूप से व्यर्थ है। अगर मैं धीमा था, तो मैं बस मेरा डिलीट कर दूंगा और तेजी से एक टिप्पणी पोस्ट करूंगा कि मैं इसके साथ आया हूं।

— mbomb007

1

@steenbergh कौन परवाह करता है? समान कोड, समान स्कोर।

— mbomb007

17

पायथन, 29 बाइट्स

lambda n:int(bin(n)[:1:-1],2)

इसे ऑनलाइन आज़माएं

— mbomb007
स्रोत

1

यही मैंने किया होगा। ;)

— जूनियर जूनियर

13

जावास्क्रिप्ट (ईएस 6), 30 28 बाइट्स

सहेजे गए 2 बाइट @Arnauld की बदौलत

f=(n,q)=>n?f(n>>1,q*2|n%2):q

यह मूल रूप से एक समय में रिवर्स एक बिट की गणना करता है: हम q = 0 से शुरू करते हैं ; जबकि एन सकारात्मक है, हम गुणा है क्ष 2 से, के बंद पिछले बिट Sever n के साथ n>>1, और के लिए इसे जोड़ने क्ष साथ |n%2। जब n 0 पर पहुंचता है, तो संख्या सफलतापूर्वक उलट गई है, और हम q वापस करते हैं ।

जेएस के लंबे अंतर्निहित नामों के लिए धन्यवाद, इस चुनौती को हल करना आसान तरीका 44 बाइट्स लेता है:

n=>+[...n.toString(2),'0b'].reverse().join``

पुनरावृत्ति और एक स्ट्रिंग का उपयोग करके, आप एक 32 बाइट समाधान प्राप्त कर सकते हैं जो एक ही काम करता है:

f=(n,q='0b')=>n?f(n>>1,q+n%2):+q

— ETHproductions
स्रोत

f=(n,q)=>n?f(n>>1,q*2|n%2):qलगभग काम करता है। लेकिन दुख की बात नहीं है n=0।

— अरनौलड

@Arnauld ओपी ने अभी तक इस बात का जवाब नहीं दिया है कि क्या इनपुट हमेशा सकारात्मक रहेगा, लेकिन यदि ऐसा है, तो 0 को संभालना नहीं है।

— 23

यह देर से अनुवर्ती है, लेकिन इनपुट अब हमेशा सकारात्मक होने के लिए जाना जाता है।

— अरनौलड

@ अरनल्ड धन्यवाद!

— ETHproductions

10

जावा 8, 53 47 46 45 बाइट्स

-4 बाइट्स टाइटस को धन्यवाद
केविन क्रूज़सेन के लिए धन्यवाद

यह एक लैम्ब्डा अभिव्यक्ति है जिसमें ETH के उत्तर के समान सिद्धांत है (हालांकि पुनरावृत्ति जावा में बहुत अधिक क्रिया होगी, इसलिए हम इसके बजाय लूप करते हैं):

x->{int t=0;for(;x>0;x/=2)t+=t+x%2;return t;}

इसे ऑनलाइन आज़माएं!

यह साथ सौंपा जा सकता है IntFunction<Integer> f = ..., और फिर साथ बुलाया जाता है f.apply(num)। विस्तारित, अपुष्ट और टिप्पणी की गई, यह इस तरह दिखता है:

x -> { 
    int t = 0;           // Initialize result holder   
    while (x > 0) {      // While there are bits left in input:
        t <<= 1;         //   Add a 0 bit at the end of result
        t += x%2;        //   Set it to the last bit of x
        x >>= 1;         //   Hack off the last bit of x
    }              
    return t;            // Return the final result
};

— FlipTack
स्रोत

1

t*2इसके बजाय 3 बाइट्स सहेजें (t<<1), लूप हेड से लूप बॉडी में उस गणना को आगे बढ़ाने के साथ एक और। क्या आप शर्त के xबदले इस्तेमाल कर सकते x>0हैं?

— टाइटस

2

@ एक बूलियन के लिए एक स्पष्ट डाली के बिना नहीं, लेकिन अन्य सुझावों के लिए धन्यवाद! यह भी सिर्फ एहसास हुआ कि इसे अपने आप से पूर्णांक विभाजन के रूप में x>>=1प्रतिस्थापित किया x/=2जा सकता है।

— पलटें

45 बाइट्स (बदल दिया t=t*2+करने के लिए t+=t+।)

— केविन Cruijssen

@ केविनक्रूजसेन एक अच्छा!

— FlipTack

9

जे, 6 बाइट्स

|.&.#:

|. उलटा

&. के अंतर्गत

#: आधार २

— एडम
स्रोत

8

जेली , 3 बाइट्स

BUḄ

इसे ऑनलाइन आज़माएं!

B   # convert to binary
 U  # reverse
  Ḅ # convert to decimal

— रिले
स्रोत

7

यह बहुत छोटा है, BUB

— Cyoce

हम्म ... कि वास्तव में 3 बाइट्स है ?

— एरियोबे

1

@aioobe हां। जेली यह स्वयं का कोड पेज का उपयोग करती है जहां इनमें से प्रत्येक वर्ण 1 बाइट है।

— रिले

अच्छा है धन्यवाद! <पैड>

— aioobe

8

मैथेमेटिका, 19 बाइट्स

#~IntegerReverse~2&

— ngenisis
स्रोत

7

भूलभुलैया, 23 बाइट्स

?_";:_2
  :   %
 @/2_"!

खैर, यह अजीब है ... यह उलटा BINARY नंबर लौटाता है ... धन्यवाद @Martin Ender मेरे बग और मेरी ID 10T त्रुटि दोनों को इंगित करने के लिए। तो यह काम नहीं करता है, मैं एक और समाधान खोजने के लिए होगा।

— C एंडरसन
स्रोत

1

PPCG में आपका स्वागत है, और अच्छी पहली पोस्ट! लैबीरिंथ जैसी भाषा में चुनौती को पूरा करना बहुत मुश्किल हो सकता है। # Labyrinth, 89 bytes

— इधर

1

क्या आपने गलती से दूसरी पंक्ति से एक अग्रणी स्थान छोड़ दिया था? जैसा कि यह खड़ा है, कार्यक्रम सिर्फ पहली पंक्ति में आगे और पीछे उछल जाएगा क्योंकि _जंक्शनों पर हैं।

— मार्टिन एंडर

दुर्भाग्य से, मैंने अभी देखा कि यह परवाह किए बिना मान्य नहीं है, क्योंकि चुनौती उलटी संख्या के आधार -10 प्रतिनिधित्व के लिए पूछती है, न कि इसके बाइनरी प्रतिनिधित्व से।

— मार्टिन एंडर

6

सी, 48 44 43 42 बाइट्स

-1 बाइट थैंक्स टू गुरका और -1 बाइट थैंक्स टू अनातोलीग:

r;f(n){for(r=n&1;n/=2;r+=r+n%2);return r;}

पिछले 44 बाइट्स समाधान:

r;f(n){r=n&1;while(n/=2)r=2*r+n%2;return r;}

पिछले 48 बाइट्स समाधान:

r;f(n){r=0;while(n)r=2*(r+n%2),n/=2;return r/2;}

अधूरा और उपयोग:

r;
f(n){
 for(
  r=n&1;
  n/=2;
  r+=r+n%2
 );
 return r;}
}


main() {
#define P(x) printf("%d %d\n",x,f(x))
P(1);
P(2);
P(3);
P(4);
P(5);
P(6);
P(7);
P(8);
P(9);
P(10);
}

— कार्ल नेफ
स्रोत

नहीं है rपहले से ही यहाँ शून्य करने के लिए प्रारंभ r;f(n){r=0;, जैसे r=0;अनावश्यक है? इसके अलावा मामूली टाइपो: "पिछला 48 बाइट्स समाधान"

— सिमोन

1

@gurka फ़ंक्शन पुन: प्रयोज्य होना चाहिए।

— कार्ल नेफ

1

मुझे लगता है कि forलूप हमेशा कम से कम whileछोरों के रूप में होते हैं , और अक्सर छोटे होते हैं।

— अनातोलीग

@anatolyg कुछ इस तरह r;f(n){for(r=n&1;n/=2;r=2*r+n%2);return r;}:? 1 बाइट छोटा है, लेकिन मैं अनिश्चित हूँ अगर यह वैध C (C99) है।

— सिमोन

हाँ; भी, बारी =में +=यह छोटे और अधिक समझ से परे बनाने के लिए

— anatolyg

5

रूबी, 29 28 बाइट्स

->n{("%b"%n).reverse.to_i 2}

"% b"% n एक बाइनरी स्ट्रिंग के रूप में इनपुट n को प्रारूपित करता है, रिवर्स करता है, फिर एक नंबर पर वापस कन्वर्ट करता है

उपयोग / परीक्षण के मामले:

m=->n{("%b"%n).reverse.to_i 2}
m[1] #=> 1
m[2] #=> 1
m[3] #=> 3
m[4] #=> 1
m[5] #=> 5
m[6] #=> 3
m[7] #=> 7
m[8] #=> 1
m[9] #=> 9
m[10] #=> 5

— एलेक्सिस एंडरसन
स्रोत

@ मुझे लगता है कि आप जवाब को गलत समझते हैं। 2वह आधार है जो वह परिवर्तित कर रहा है, और nइनपुट है। ->args{return value}रूबी लैम्ब्डा सिंटेक्स है

— साइओस

क्या आप कोष्ठक को हटा सकते हैं .to_i(2)?

— साइओस

@ निश्चित रूप से पर्याप्त, धन्यवाद।

— एलेक्सिस एंडरसन

4

05AB1E , 3 बाइट्स

bRC

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

4

जावा (ओपनजेडके) , 63 बाइट्स

a->a.valueOf(new StringBuffer(a.toString(a,2)).reverse()+"",2);

इसे ऑनलाइन आज़माएं!

-12 बाइट्स के लिए और -8 बाइट्स के लिए साइको के लिए प्रहार करने के लिए धन्यवाद!

— पावेल
स्रोत

भले ही REPL सबमिशन की अनुमति हो, फिर भी वे इस नियम का पालन करते हैं कि आप यह नहीं मान सकते हैं कि इनपुट पूर्वनिर्धारित चर में है (जैसे aकि इस संदर्भ में)

— FlipTack

@ फीलटैक ऑप्स। यह मूल रूप से एक समारोह था इससे पहले कि मुझे याद है कि उत्तर मौजूद था

— पावेल

1

इसके अलावा, भविष्य में, गोल्फिंग के printबजाय का उपयोग करें println:)

— फ्लिपकार्ट

1

StringBufferएक बाइट बचाता हैStringBuilder

— प्रहार

1

क्या आप इसके +""बजाय कर सकते हैं .toString()?

— साइओस

3

पर्ल 6 , 19 बाइट्स

{:2(.base(2).flip)}

— शॉन
स्रोत

इनपुट कहाँ है?

— टाइटस

यह एक फ़ंक्शन है जो एकल पैरामीटर लेता है $_। यह नाम से उल्लिखित नहीं है, लेकिन इस पर baseविधि को कहा जाता है।

— सीन

2

Perl 6 में @Titus एक ब्लॉक कोड का एक प्रकार है, जो कहना है कि यह एक कॉल करने योग्य वस्तु है। उपरोक्त एक अभिव्यक्ति है जिसे आप किसी अन्य भाषा में फ़ंक्शन या लैम्ब्डा जैसे वेरिएबल में ले और असाइन कर सकते हैं, या सीधे कॉल कर सकते हैं - {:2(.base(2).flip)}(10)REPL में 5. प्रिंट होगा। इसलिए यह एक फ़ंक्शन के लिए मानक कोड-गोल्फ मानदंड को पूरा करता है।

— हॉब्स

3

हास्केल, 36 बाइट्स

0!b=b
a!b=div a 2!(b+b+mod a 2)
(!0)

समान एल्गोरिथ्म (और लंबाई!) ETHproductions ' जावास्क्रिप्ट जवाब के रूप में।

— लिन
स्रोत

3

बैश / यूनिक्स उपयोगिताओं, 24 23 बाइट्स

dc -e2i`dc -e2o?p|rev`p

इसे ऑनलाइन आज़माएं!

— मिशेल स्पेक्टर
स्रोत

बैश पर एक साहसी ले लो! 😉

— juniorRubyist

@juniorRubyist - धन्यवाद!

— मिशेल स्पेक्टर

3

PHP, 33 बाइट्स

<?=bindec(strrev(decbin($argn)));

Base2, रिवर्स स्ट्रिंग में कनवर्ट करें, दशमलव में कनवर्ट करें। फ़ाइल को सहेजें और पाइप के रूप में चलाएं -F।

कोई निर्माण नहीं:

पुनरावृति, 41 बाइट्स

for(;$n=&$argn;$n>>=1)$r+=$r+$n%2;echo$r;

जबकि इनपुट ने बिट्स सेट किया है, इनपुट से थोड़ा पॉप करें और इसे आउटपुट पर पुश करें। साथ पाइप के रूप में चलाएँ -nR।

पुनरावर्ती, 52 बाइट्स

function r($n,$r=0){return$n?r($n>>1,$r*2+$n%2):$r;}

— टाइटस
स्रोत

@ JörgHülsermann 44 बाइट्स हैं $r+=$r। लेकिन मुझे वास्तव में याद नहीं है कि मैंने इसे क्यों सामने रखा।

— टाइटस

2

MATL , 4 बाइट्स

BPXB

इसे ऑनलाइन आज़माएं!

व्याख्या

B     % Input a number implicitly. Convert to binary array
P     % Reverse array
XB    % Convert from binary array to number. Display implicitly

— लुइस मेंडो
स्रोत

2

अजगर, 6 बाइट्स

i_.BQ2

टेस्ट सूट यहाँ उपलब्ध है।

व्याख्या

i_.BQ2
    Q     eval(input())
  .B      convert to binary
 _        reverse
i    2    convert from base 2 to base 10

— माइक बुफ़र्डेकी
स्रोत

2

जाप , 5 बाइट्स

¢w n2

इसे ऑनलाइन आज़माएं!

— ओलिवर
स्रोत

1

अच्छा, बिल्कुल वही जो मेरे पास था। )भी एक जगह हो सकता है :-)

— ETHproductions

2

स्काला, 40 बाइट्स

i=>BigInt(BigInt(i)toString 2 reverse,2)

उपयोग:

val f:(Int=>Any)=i=>BigInt(BigInt(i)toString 2 reverse,2)
f(10) //returns 5

स्पष्टीकरण:

i =>          // create an anonymous function with a parameter i
  BigInt(       //return a BigInt contructed from
    BigInt(i)     //i converted to a BigInt
    toString 2    //converted to a binary string
    reverse       //revered
    ,           
    2             //interpreted as a binary string
  )

— corvus_192
स्रोत

1

गणितज्ञ, 38 बाइट्स

#+##&~Fold~Reverse[#~IntegerDigits~2]&

— जंगवान मिन
स्रोत

1

ग्रूवी, 46 बाइट्स

{0.parseInt(0.toBinaryString(it).reverse(),2)}

— जादू ऑक्टोपस Urn
स्रोत

क्या यह कोई इनपुट लेता है?

— टाइटस

1

@ टिट्स का itतात्पर्य एक खंड IIRC को दिए गए तर्क से है

— साइओस

मैं प्यार करता हूँ कि यह मेरे जावा उत्तर के समान लंबाई कैसे है - जावा और ग्रूवी, एकजुट!

— 23

1

@ फालतू मैं अब रोने वाला हूँ।

— मैजिक ऑक्टोपस Urn

1

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

ri2bW%2b

इसे ऑनलाइन आज़माएं!

व्याख्या

ri          e# Read integer
  2b        e# Convert to binary array
    W%      e# Reverse array
      2b    e# Convert from binary array to number. Implicitly display

— लुइस मेंडो
स्रोत

1

बैच, 62 बाइट्स

@set/an=%1/2,r=%2+%1%%2
@if %n% gtr 0 %0 %n% %r%*2
@echo %r%

स्पष्टीकरण: पहले पास पर, खाली होने पर %1इनपुट पैरामीटर %2होता है। इसलिए हम nआधे के रूप में %1और मोडुलो 2 के rरूप में मूल्यांकन करते हैं +%1( %इसे उद्धृत करने के लिए ऑपरेटर को दोगुना करना होगा)। यदि nशून्य नहीं है, तो हम फिर से अपने आप को पुष्ट रूप से गुजरते हुए पुकारते हैं nऔर एक अभिव्यक्ति जो अगली rबार प्रभावी रूप से दोगुनी हो जाती है।

— नील
स्रोत

1

सी #, 98 बाइट्स

using System.Linq;using b=System.Convert;a=>b.ToInt64(string.Concat(b.ToString(a,2).Reverse()),2);

— होर्वाथ डेविड
स्रोत

1

आर, 55 बाइट्स

sum(2^((length(y<-rev(miscFuncs::bin(scan()))):1)-1)*y)

स्टड से इनपुट पढ़ता है और परिणामस्वरूप दशमलव से बाइनरी वेक्टर में बदलने के binलिए miscFuncsपैकेज से फ़ंक्शन का उपयोग करता है ।

— Billywob
स्रोत

1

pushy , 19 बाइट्स

कोई बेसिन रूपांतरण नहीं!

$&2%v2/;FL:vK2*;OS#

इसे ऑनलाइन आज़माएं!

पुसी के दो ढेर हैं, और यह जवाब इस बड़े पैमाने पर उपयोग करता है।

इस कार्यक्रम के दो भाग हैं। सबसे पहले, $&2%v2/;Fसंख्या को अपने रिवर्स बाइनरी प्रतिनिधित्व में परिवर्तित करता है:

            \ Implicit: Input is an integer on main stack.
$      ;    \ While i != 0:
 &2%v       \   Put i % 2 on auxiliary stack
     2/     \   i = i // 2 (integer division)
        F   \ Swap stacks (so result is on main stack)

उदाहरण 10 को देखते हुए, प्रत्येक पुनरावृत्ति पर निम्नलिखित के रूप में ढेर दिखाई देंगे:

1: [10]
2: []

1: [5]
2: [0]

1: [2]
2: [0, 1]

1: [1]
2: [0, 1, 0]

1: [0]
2: [0, 1, 0, 1]

हम देख सकते हैं कि अंतिम पुनरावृत्ति के बाद, 0, 1, 0, 1दूसरे स्टैक पर बनाया गया है - 10 के रिवर्स बाइनरी अंक।0b1010 ,।

कोड का दूसरा भाग, L:vK2*;OS#मेरे पिछले उत्तर से लिया गया है जो बाइनरी को दशमलव में परिवर्तित करता है । उस उत्तर में बताई और बताई गई विधि का उपयोग करते हुए, यह द्विआधारी अंकों को स्टैक पर एक बेस 10 पूर्णांक में परिवर्तित करता है, और परिणाम को प्रिंट करता है।

— FlipTack
स्रोत

0

के, 18 बाइट्स

{2/:|X@&|\X:0b\:x}

उदाहरण:

k){2/:|X@&|\X:0b\:x}6
3

— skeevey
स्रोत

0

सी #, 167 बाइट्स

 for(int i = 1; i <= 10; i++)
 {
 var bytes= Convert.ToString(i, 2);
 var value= Convert.ToInt32(byteValue.Reverse()); 
 console.WriteLine(value);
}

स्पष्टीकरण:

यहाँ मैं n मानों को पुनरावृत्त करूँगा और हर बार पुनरावृत्त पूर्णांक मान बाइट मान में परिवर्तित होता है, फिर उस बाइट मान को उल्टा और उस बाइट मान को पूर्णांक मान में बदल दिया जाता है।

— दीपक
स्रोत

1

साइट पर आपका स्वागत है! मुझे C # के बारे में ज्यादा जानकारी नहीं है, लेकिन आप निश्चित रूप से अतिरिक्त व्हाट्सएप का एक अच्छा सौदा है जिसे मैं हटाने की सिफारिश करूंगा। यह भी स्पष्ट नहीं है कि I / O को इस सबमिशन में कैसे निपटा जाता है। यह या तो एक फ़ंक्शन लिखने या उपयोग करने के लिए मानक है STDIN(मुझे लगता है कि है, console.Read()लेकिन आप शायद मुझसे बेहतर जानते हैं) और होगा STDOUT। वैसे भी, यदि आप गोल्फ सी # में अधिक अनुभवी सलाह चाहते हैं तो साइट पर आपका स्वागत है। मैं codegolf.stackexchange.com/questions/173/…

— गेहूं जादूगर

मैंने इस उत्तर को अस्वीकार कर दिया है, क्योंकि यह बिल्कुल भी काम नहीं करता है। .Reverse()लौटता है IEnumerable<char>। जैसा कि Convert.ToInt32IEnumerable के लिए एक अधिभार नहीं है यह एक अपवाद फेंकता है। इसके अलावा जवाब कोड गोल्फ के लिए नियमों का पालन नहीं करता है: 1) के रूप में कुछ भी निर्दिष्ट नहीं है सबमिशन एक पूर्ण कार्यक्रम या समारोह होना चाहिए न कि केवल एक स्निपेट। 2) usingबयानों को बाइट काउंट में शामिल किया जाना चाहिए

— raznagul

0

c / c ++ 136 बाइट्स

uint8_t f(uint8_t n){int s=8*sizeof(n)-ceil(log2(n));n=(n&240)>>4|(n&15)<<4;n=(n&204)>>2|(n&51)<<2;n=(n&172)>>1|(n&85)<<1;return(n>>s);}

यह जीतने वाला नहीं है, लेकिन मैं फ़ंक्शन में c / c ++ 120 बाइट्स में एक अलग दृष्टिकोण लेना चाहता था

#include <math.h>
#include <stdio.h>
#include <stdint.h>

uint8_t f(uint8_t n){
    int s=8*sizeof(n)-ceil(log2(n));
    n=(n&240)>>4|(n&15)<<4;
    n=(n&204)>>2|(n&51)<<2;
    n=(n&172)>>1|(n&85)<<1;
    return (n>>s);
}

int main(){
    printf("%u\n",f(6));
    return 0;
}

मैं जो कर रहा हूं, उसके बारे में विस्तार से बताने के लिए, मैंने इनपुट द्वारा उपयोग किए गए बिट्स की संख्या निर्धारित करने के लिए लॉग फ़ंक्शन का उपयोग किया। तीन बिट्स पारियों की एक श्रृंखला को बाएं / दाएं, अंदर / बाहर, यहां तक कि विषम / जो पूरे पूर्णांक को फ़्लिप करता है। अंत में नंबर को दाईं ओर शिफ्ट करने के लिए थोड़ा बदलाव। हेक्स के बजाय बिट शिफ्ट्स के लिए दशमलव का उपयोग करना एक दर्द है लेकिन इसने कुछ बाइट्स को बचाया।

— mreff555
स्रोत

आपको फ़ंक्शन घोषणा को शामिल करने की आवश्यकता है, इसलिए यह वास्तव में 163 बाइट्स है । हालांकि, अगर आप बाहरी रिक्त स्थान निकालना, आप इसे 136. तक छोटा कर सकता है

— DJMcMayhem

रिवर्स (बाइनरी) बिट संख्या क्या है?

उदाहरण:

पायथन , 29 बाइट्स

पायथन, 29 बाइट्स

जावास्क्रिप्ट (ईएस 6), 30 28 बाइट्स

जावा 8, 53 47 46 45 बाइट्स

जे, 6 बाइट्स

जेली , 3 बाइट्स

मैथेमेटिका, 19 बाइट्स

भूलभुलैया, 23 बाइट्स

सी, 48 44 43 42 बाइट्स

रूबी, 29 28 बाइट्स

05AB1E , 3 बाइट्स

जावा (ओपनजेडके) , 63 बाइट्स

पर्ल 6 , 19 बाइट्स

हास्केल, 36 बाइट्स

बैश / यूनिक्स उपयोगिताओं, 24 23 बाइट्स

PHP, 33 बाइट्स

MATL , 4 बाइट्स

व्याख्या

अजगर, 6 बाइट्स

व्याख्या

जाप , 5 बाइट्स

स्काला, 40 बाइट्स

उपयोग:

स्पष्टीकरण:

गणितज्ञ, 38 बाइट्स

ग्रूवी, 46 बाइट्स

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

व्याख्या

बैच, 62 बाइट्स

सी #, 98 बाइट्स

आर, 55 बाइट्स

pushy , 19 बाइट्स

के, 18 बाइट्स

सी #, 167 बाइट्स