बाइनरी नंबर में C # पहला 1 (दाएं से बाएं)

Question

मैं एक नंबर के बाइनरी प्रतिनिधित्व में पहले 1 (बाएं से दाएं) के सूचकांक को खोजने के लिए C # का उपयोग करने की कोशिश कर रहा हूं। उदाहरण के लिए, बाइनरी में 100 है:

0b1100100

पहला 1 दाईं ओर से तीसरे स्थान पर है, इसलिए इसे 3 उपज चाहिए।

२३४ में २ उपज चाहिए, ० उपज चाहिए ०, आदि।

यहाँ मेरा वर्तमान समाधान है:

k < 1 ? 0 :(int)Math.Log(k & -k, 2) + 1;

किसी भी तरीके से मैं इसे छोटा कर सकता हूं?

Comments

स्पष्ट टिप अपने बाहर के व्हाट्सएप को हटाने के लिए है। मैं 10 रिक्त स्थान देखता हूं जिन्हें आप आसानी से हटा सकते हैं।

— जेम्स

Convert.ToString(k,2).IndexOf("1")हालांकि, आप चाहते हैं या कुछ इसी तरह की गलत साइट है।

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

@ करीबी मतदाता - करीबी वोट क्यों? मुझे लगता है कि यह एक ऑन-टॉपिक टिप्स सवाल है। या इस संबंध में मैंने कोई नियम परिवर्तन किए हैं?

— डिजिटल ट्रामा

Answer 1

यदि केवल C # समर्थित मशीन-विशिष्ट इंट्रिनिक्स ... एक निर्देश है जो x86 असेंबली भाषा में ऐसा कर सकता है, और अधिकांश अन्य प्रोसेसर आर्किटेक्चर पर भी। तब आपके पास न केवल सबसे छोटा कोड होगा, बल्कि सबसे तेज़ होने की संभावना होगी।

वास्तव में, इस कोड को तेज़ बनाने की तुलना में इस कोड को कम करना एक बेहद उबाऊ समस्या है । वास्तव में साफ, कुशल, बिट-ट्विडलिंग समाधान के सभी प्रकार हैं, और आप एक लुक-अप तालिका का उपयोग करने पर भी विचार कर सकते हैं।

हालांकि गोल्फिंग के लिए यह कोई मायने नहीं रखता। यह मुझे लगता है कि आपका वर्तमान समाधान सबसे अच्छा है जो आप कर सकते हैं। बेशक, आप शानदार व्हाट्सएप को हटा सकते हैं:

k<1?0:(int)Math.Log(k&-k,2)+1

मैं इसे व्यक्तिगत रूप से लिखूंगा:

k>0?(int)Math.Log(k&-k,2)+1:0

क्योंकि मुझे लगता है कि इस तरह सशर्त परीक्षण की दिशा के साथ-साथ शून्य के खिलाफ तुलना करना थोड़ा स्पष्ट है, लेकिन मुझे लगता है कि यह छह तरह से है, आधा दर्जन अन्य।

C # , C और C ++ intको boolपसंद करने से निहित रूपांतरण का समर्थन नहीं करता है, इसलिए आप सशर्त परीक्षण को और कम नहीं कर सकते।

आप सी (# के रूप में doubleमेरे लौटाए गए Math.Log) से स्पष्ट कास्ट के साथ फंस गए हैं int, क्योंकि C # इसे अंतर्निहित रूप से नहीं होने देगा। बेशक, कि आम तौर पर एक अच्छी बात है, क्योंकि यह कहना है कि आप एक है बड़ा प्रदर्शन समस्या यहाँ: एक को बढ़ावा देने के intएक करने के लिए double, एक की लॉग कंप्यूटिंग double, और फिर परिवर्तित doubleएक के लिए परिणाम वापस intहो जाएगा बड़े पैमाने पर धीमी गति से, तो यह सामान्य रूप से कुछ आप बचना चाहते हैं। लेकिन ये उन प्रकार की विकृतियाँ हैं जो आपको कोड गोल्फ खेलने के दौरान उठानी पड़ती हैं।

---

मैं शुरू में साथ आया था

k > 0
      ? ((k & -k) >> 1) + 1
      : 0

(स्पष्टता के लिए अपुष्ट, निश्चित रूप से), जो लघुगणक लेने से बचता है और इसलिए कोड आकार और गति में सुधार है। दुर्भाग्य से, यह हमेशा सही उत्तर नहीं मिलता है, और मुझे लगता है कि यह एक अनम्य आवश्यकता है। :-) विशेष रूप से, यह विफल रहता है यदि इनपुट मान ( k) 8 का एक कारक है। यह ठीक करने योग्य है, लेकिन Math.Logसंस्करण से अधिक समय तक कोड बनाए बिना नहीं ।

Comments

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

— द लीथलकोडर

आपका मतलब गलत उत्पादन करने वाला है? @ वह

— कोडी ग्रे

वैसे आपने कहा था कि यह ठीक है, लेकिन यह इसे लंबा कर देगा। यदि ओपी संस्करण में शामिल होने की तुलना में फिक्स कम है System.तो इसे छोटा और सही होना चाहिए।

— TheLethalCoder