दशमलव से बाइनरी कन्वर्टर

17 ÷ 2 = 8 r 1 → 8 ÷ 2 = 4 r 0 → 4 ÷ 2 = 2 r 0 → 2 ÷ 2 = 1 r 0 → 1 ÷ 2 = 0 r 1 ⇒ 17 = 10001 = 16 + 1

17

जिस पूर्ण संख्या को बदलना है, आधार-10 में लिखी हुई। यह पूरी संख्या होनी चाहिए: दशमलव बिंदु और हज़ार का विभाजक दोनों अस्वीकार कर दिए जाते हैं, पूर्णांकित किए नहीं, क्योंकि इस परिवार का हर पेज पूर्ण संख्याओं पर ही चलता है

÷ 2

वह क़दम जो दोहराया जाता है। दो वह आधार है जिसमें जाना है, इसलिए हर चक्कर यह पूछता है कि इसमें कितने दो समाते हैं — और जो बच रहता है वह वही अंक है जो उस स्थान का होता है

भागफल

वह हिस्सा जो अगले चक्कर में चलता है। काम तब रुकता है जब भागफल शून्य हो जाए, और यही इशारा है कि इससे ऊँचा कोई स्थान भरना बाक़ी नहीं है

शेषफल

उस चक्कर से निकला अंक। दो से भाग देने पर 0 या 1 के सिवा कुछ बच ही नहीं सकता, और यही वजह है कि जवाब बाइनरी अंकों में आता है, किसी और चिह्न-समूह में नहीं

⇒ 10001

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

16 + 1

जवाब को बाइनरी के स्थानीय मानों की तरह वापस पढ़ना: 10001 में सोलह और एक के स्थानों पर 1 है, इसलिए इन्हें जोड़ने पर फिर 17 आता है। यही वह जाँच है जो पेज छापता है, और यह इसलिए काम करती है कि बाइनरी संख्या के सारे स्थानीय मानों का जोड़ उस संख्या के बराबर ही होता है

53 बिट

जवाब कितना लंबा हो सकता है: तिरपन बाइनरी अंक, जो दशमलव में 9007199254740991 है। इस चौड़ाई के आगे मशीन पड़ोसी पूर्ण संख्याओं में फ़र्क़ नहीं कर पाती, इसलिए बड़ा इनपुट ऐसा कुछ बनाने के बजाय अस्वीकार कर दिया जाता है जो सिर्फ़ जवाब जैसा दिखे

किसी संख्या को आधार-2 में लिखना तब पड़ता है जब मशीन की अपनी लिखावट हाथ से बनानी हो। कई छोटे मान एक पूर्णांक में पैक करने के लिए यह निकालना पड़ता है कि किस मान को कौन-से बिट मिले हैं, और वह शुरुआत मान को बाइनरी में लिखने से होती है: रंग का एक चैनल, अनुमतियों का झुंड, किसी कॉन्फ़िगरेशन रजिस्टर का बिट-खाना। दस्तावेज़ पढ़ने वाले को यही काम दूसरी तरफ़ से मिलता है, क्योंकि वहाँ जो परिसर और मास्क छपे होते हैं वे हेक्साडेसिमल या बाइनरी में होते हैं और जिस संख्या से वे बने वह दशमलव में। पढ़ाई में तो दिशा सीधे माँगी जाती है — दशमलव से बाइनरी बदलिए और काम दिखाइए — और पेज जो सीढ़ी छापता है वही वह काम है, हर भाग के लिए एक पंक्ति। यही बदलाव ऐसे सवालों का जवाब भी देता है जो बदलाव जैसे लगते ही नहीं: इस आकार के मान को कितने बिट चाहिए, इसके ठीक ऊपर दो की कौन-सी घात है, और आठ बिट का खाना 0 से 256 तक क्यों नहीं, 255 तक क्यों चलता है। जो प्रोग्रामर यह काम मन में करता है वह अक्सर सीढ़ी के बजाय दो की घातों पर हाथ रखता है — जो सबसे बड़ी घात समाती हो उसे घटाइए और बचे हुए से दोहराइए — और इस पेज का आउटपुट उस तरीक़े को भी सँभालता है, क्योंकि हर सफल घटाव उस स्थान पर 1 छोड़ता है और जवाब के साथ छपा जोड़ वही 1 हैं।

1. 17 को बाइनरी में लिखना

   1. 17 ÷ 2 = 8, शेषफल 1 — यह 1 लिख लीजिए
   2. 8 ÷ 2 = 4, शेषफल 0
   3. 4 ÷ 2 = 2, शेषफल 0
   4. 2 ÷ 2 = 1, शेषफल 0
   5. 1 ÷ 2 = 0, शेषफल 1 — भागफल शून्य हो गया, तो यहीं रुकिए
   6. शेषफल नीचे से ऊपर पढ़िए: 1, 0, 0, 0, 1, यानी 10001

   यही डिफ़ॉल्ट है, और यही उलटे क्रम को दिखाता है: सबसे पहले मिला शेषफल जवाब का सबसे आख़िरी अंक है। शेषफलों को उसी क्रम में पढ़ लेना जिसमें वे निकले, उलटा जवाब देता है — यहाँ 10001 का उलटा भी 10001 ही है, पर वह महज़ संयोग है, इसलिए नियम की जाँच अगले उदाहरण पर कीजिए। जाँच: 16 + 1 = 17।

2. पूरी बाइट लिखना, 255

   1. 255 ÷ 2 = 127, शेषफल 1
   2. 127 ÷ 2 = 63, शेषफल 1 — और इसके बाद हर चक्कर में भी 1 ही बचेगा
   3. 63 → 31 → 15 → 7 → 3 → 1, हर बार शेषफल 1
   4. 1 ÷ 2 = 0, शेषफल 1 — कुल आठ चक्कर
   5. आठों शेषफल 1 हैं, नीचे से ऊपर पढ़िए: 11111111

   255 सबसे बड़ा मान है जो आठ बिट का खाना रख सकता है, और वजह यही है: आठ बाइनरी अंक 2⁸ तरह के होते हैं, और उनमें सबसे बड़ा 11111111 है। इसी बात का दूसरा सिरा यह है कि 256 बनता है 100000000 — नौ अंक — यानी वह संख्या जो एक बाइट में नहीं समाती। जोड़ में पूरा पैमाना जुड़ता है, और उसे एक बार पूरा देख लेना लायक़ है।

3. दो की घात, 16

   1. 16 ÷ 2 = 8, शेषफल 0
   2. 8 ÷ 2 = 4, शेषफल 0
   3. 4 ÷ 2 = 2, शेषफल 0
   4. 2 ÷ 2 = 1, शेषफल 0
   5. 1 ÷ 2 = 0, शेषफल 1
   6. नीचे से ऊपर: एक 1 और उसके बाद चार 0, यानी 10000

   दो की घात में ठीक एक बार शेषफल 1 निकलता है और फिर काम ख़त्म, इसलिए स्थानीय मानों का जोड़ सिमटकर एक अकेला पद रह जाता है। यही शक्ल पहचानने लायक़ है: दो की कोई भी घात बाइनरी में एक अकेला 1 और उसके बाद शून्य होती है, और इसीलिए खानों की चौड़ाई, पेज के आकार और बफ़र की क्षमता नापने की सहज इकाई दो की घातें ही हैं।

4. पहले के शून्य मान नहीं बदलते

   1. इनपुट के आगे के शून्य दशमलव संख्या के आगे बैठे हैं और कुछ नहीं जोड़ते
   2. बदलाव 17 पर होता है, ठीक पहले उदाहरण की तरह
   3. दोनों आउटपुट वही निकलते हैं, शब्द-दर-शब्द

   आगे के शून्य इनपुट की तरफ़ इसलिए स्वीकार होते हैं कि दशमलव संख्या अक्सर कहीं से ऐसी कॉपी की जाती है जहाँ उसे भर दिया गया था, और वे कुछ नहीं बदलते: शून्य सैकड़े अब भी शून्य सैकड़े हैं। दूसरी दिशा में भी यही बात है, जहाँ किसी मान को जान-बूझकर तय चौड़ाई तक भरा जाता है — आठ बिट के खाने में 00010001 वही संख्या है जो 10001 है, और पेज दोनों लेता है।

यह पेज सिर्फ़ पूर्ण संख्याएँ बदलता है। दशमलव बिंदु पूर्णांकित किए बिना अस्वीकार कर दिया जाता है, इसलिए 17.5 बदला नहीं जा सकता — भिन्नात्मक पढ़त के लिए यह दूसरा नियम चाहिए होता कि कितने अंक दिखाने हैं और आख़िरी को कैसे पूर्णांकित करना है, और इस परिवार का हर पेज यह लकीर एक ही जगह खींचता है। हज़ार के विभाजक भी अस्वीकार होते हैं, इसलिए 1500 लिखिए, 1,500 नहीं; कॉमा कुछ भाषाओं में दशमलव बिंदु की तरह पढ़ा जाता है, और दो पढ़तों के बीच अंदाज़ा लगाने से पूछ लेना बेहतर है। इनपुट ज़्यादा से ज़्यादा 9007199254740991 हो सकता है, जो तिरपन बाइनरी अंक बनता है; इससे बड़ा मान मशीन ठीक-ठीक नहीं रख सकती, इसलिए जवाब जैसा दिखने वाला कुछ बनाने के बजाय एक संदेश के साथ अस्वीकार कर दिया जाता है। आगे के शून्य और आगे लगा ऋण चिह्न दोनों स्वीकार होते हैं। नीचे की तालिका 17 के लिए वही आधा करने की सीढ़ी छापती है, जो तय है और आपकी टाइप की हुई संख्या के साथ नहीं चलती — पैनल आपकी संख्या का जवाब देता है, तालिका तरीक़ा दिखाती है। उलटी दिशा, यानी बाइनरी संख्या को वापस दशमलव में पढ़ना, अपने अलग पेज पर है, और यह पेज नतीजे पर कोई गणना नहीं करता।

दशमलव संख्या को हाथ से बाइनरी में कैसे बदलें?

दो से भाग दीजिए, शेषफल लिख लीजिए, फिर भागफल को दो से भाग दीजिए और यही तब तक दोहराइए जब तक भागफल शून्य न हो जाए। 17 के लिए इससे शेषफल मिलते हैं 1, 0, 0, 0, 1 — और चूँकि हर चक्कर जवाब का अगला अंक दाईं ओर से बनाता है, 10001 पाने के लिए इन्हें नीचे से ऊपर पढ़ना पड़ता है। दूसरा तरीक़ा, जो बहुतों को तेज़ लगता है, यह है कि जो सबसे बड़ी दो की घात समा जाए उसे घटाइए, उस स्थान पर 1 लगाइए, और बचे हुए से दोहराइए; दोनों तरीक़े वही अंक देते हैं, और इस पेज पर छपा जोड़ दूसरे तरीक़े का बचा हुआ निशान है।

शेषफल नीचे से ऊपर क्यों पढ़ने पड़ते हैं?

क्योंकि पहला भाग सबसे बड़े स्थान का नहीं, सबसे छोटे स्थान का जवाब देता है। 17 को दो से भाग देना यह पूछता है कि इसमें कितने दो हैं और क्या बचा — और जो बचा वह इकाई का अंक है, क्योंकि वही हिस्सा है जिससे एक पूरा दो नहीं बन सका। अगला चक्कर वही सवाल दो के बारे में पूछता है, और उसका बचा हुआ दो के स्थान का अंक है। इसलिए चक्कर सबसे दाहिने अंक से सबसे बाएँ अंक की ओर चलते हैं, और जिस क्रम में उन्हें लिखा गया उसी क्रम में पढ़ लेने पर जवाब उलटा मिलता है।

क्या दशमलव बिंदु वाली संख्या बदल सकता हूँ?

यहाँ नहीं। यह पेज पूर्ण संख्याएँ लेता है, इसलिए 17.5 पूर्णांकित करने के बजाय अस्वीकार कर दिया जाता है। बाइनरी में भिन्न पूरी तरह परिभाषित हैं — बिंदु के दाईं ओर के स्थान आधे, चौथाई, आठवें हिस्से के होते हैं — पर जो पेज उन्हें स्वीकार करता उसे यह तय करना पड़ता कि उनमें से कितने रखने हैं और आख़िरी को कैसे पूर्णांकित करना है, और इस परिवार का हर पेज पूर्ण संख्याएँ ही बदलता है। इससे सीमा हर जगह एक ही रहती है, और ऐसा कभी नहीं होता कि कोई मान एक पेज पर स्वीकार हो और दूसरे पर अस्वीकार।

यहाँ सबसे बड़ी कौन-सी दशमलव संख्या बदल सकता हूँ?

9007199254740991, जिसका बाइनरी रूप तिरपन 1 है। यह हद इस पेज का चुना हुआ नियम नहीं है: इस चौड़ाई पर मशीन पड़ोसी पूर्ण संख्याओं में फ़र्क़ करना छोड़ देती है, इसलिए लंबा जवाब भरोसे के लायक़ नहीं होता और उसे बदलने के बजाय एक संदेश के साथ अस्वीकार कर दिया जाता है। यही हद पढ़ने वाले पेज पर तिरपन अंकों की सीमा बनकर और हेक्साडेसिमल में चौदह अंकों की बनकर आती है, क्योंकि यह एक ही हद है जो तीन आधारों में लिखी गई है।

पेज बाइनरी संख्या के साथ स्थानीय मानों का जोड़ भी क्यों छापता है?

ताकि जवाब को भरोसे पर लेने के बजाय जाँचा जा सके। बाइनरी संख्या वही है जो आपने माँगी, पर 10001 सही है या ग़लत, यह देखकर बताना नामुमकिन है। उसमें जो स्थानीय मान बैठे हैं उन्हें जोड़ देने पर — यहाँ 16 और 1 — वही संख्या वापस आ जाती है जिससे आपने शुरू किया था, यानी बदलाव उलटी दिशा में चल गया। अगर जोड़ आपकी संख्या पर वापस न पहुँचे तो बाइनरी श्रृंखला ग़लत है, और यह आपको दूसरे औज़ार के बिना पता चल जाता है।

बार-बार भाग देने से तेज़ कोई तरीक़ा है?

जो संख्याएँ बार-बार आती हैं उनके लिए हाँ: 1024 तक की दो की घातें याद कर लीजिए और जो सबसे बड़ी समा जाए उसे घटाते जाइए। 17 में 16 समा जाता है और 1 बचता है, तो एक भी भाग लिखने से पहले जवाब 10001 बन जाता है। सीढ़ी तब बेहतर है जब संख्या अनजानी हो, क्योंकि उसमें ऐसा कोई हिसाब नहीं जिसमें चूक हो सके — बार-बार दो से भाग देना यंत्रवत है। दोनों तरीक़े वही अंक देते हैं, और कोई भी दूसरे से ज़्यादा सही नहीं है।

• Binary number — positional notation, place values, and the conversion between base two and base ten — Wolfram MathWorld (United States)
• Number base — why a numeral's value depends on its position and on the base, and how one quantity is written in several bases — Wolfram MathWorld (United States)
• Powers of two — the sequence 1, 2, 4, 8, 16 … that the halving method produces from the bottom up, catalogued as OEIS A000079 — OEIS Foundation Inc. (United States)