बाइनरी ↔ दशमलव परिवर्तक
बाइनरी (आधार-2) और दशमलव (आधार-10) संख्या प्रणालियों के बीच परिवर्तित करें। रूपांतरण देखने के लिए किसी भी फ़ील्ड में एक मान दर्ज करें।
बाइनरी संख्याएँ केवल 0 और 1 का उपयोग करती हैं
मानक आधार-10 संख्या प्रणाली (0-9 अंक)
बाइनरी फ़ील्ड में एक मान्य बाइनरी संख्या (0 और 1 से बनी) दर्ज करें, और दशमलव समकक्ष दिखाई देगा। या, दशमलव फ़ील्ड में एक दशमलव संख्या दर्ज करें, और बाइनरी समकक्ष दिखाई देगा।
उदाहरण: बाइनरी '1101' दशमलव '13' है
बाइनरी ↔ दशमलव परिवर्तक का उपयोग कैसे करें
- 1
बाइनरी अंक दर्ज करें
0 और 1 से बनी एक बाइनरी संख्या को इनपुट फ़ील्ड में टाइप करें या पेस्ट करें।
- 2
डेसिमल में बदलें
बाइनरी मान को तुरंत उसके base-10 डेसिमल समतुल्य में बदलने के लिए कन्वर्ज़न चलाएँ।
- 3
नतीजा पढ़ें
डेसिमल संख्या को आउटपुट क्षेत्र में देखें, जो इस्तेमाल करने या जाँचने के लिए तैयार है।
- 4
जवाब कॉपी करें
कोड, होमवर्क, या दस्तावेज़ों में इस्तेमाल के लिए डेसिमल नतीजे को अपने क्लिपबोर्ड पर कॉपी करें।
बाइनरी को दशमलव में बदलना
दो संख्या प्रणालियाँ, एक ही मान
दशमलव वही आधार-10 प्रणाली है जिसका हम रोज़ इस्तेमाल करते हैं, जो 0 से 9 तक के दस अंकों से बनी है। बाइनरी आधार-2 प्रणाली है जिसे कंप्यूटर अपने अंदर इस्तेमाल करते हैं, जो सिर्फ़ दो अंकों, 0 और 1, से बनी है, और इनमें से हर एक को bit कहते हैं। बाइनरी को दशमलव में बदलने से मात्रा नहीं बदलती; यह सिर्फ़ उसी मान को उस लिखावट में दोबारा लिख देता है जिसे लोग सबसे आसानी से पढ़ पाते हैं। ग्यारह नाम की संख्या बाइनरी में 1011 है और दशमलव में 11, और दोनों एक ही मात्रा को दर्शाते हैं।
ये दोनों प्रणालियाँ साथ-साथ क्यों चलती हैं, इसकी वजह हार्डवेयर है। कंप्यूटर के सर्किट में दो भरोसेमंद अवस्थाएँ होती हैं, on और off, जो साफ़-साफ़ 1 और 0 से मेल खाती हैं, इसलिए मशीनें बाइनरी में काम करती हैं। इंसानों ने, अपनी दस उँगलियों के साथ, आधार 10 को अपनाया। इस तरह का परिवर्तक इन दोनों के बीच का पुल है: यह मशीन के अपने रूप को लेकर इंसानों के लिए आसान समकक्ष बनाता है, और यह उल्टी दिशा में भी काम कर सकता है।
स्थानीय लिखावट और स्थानीय मान
दोनों प्रणालियाँ स्थानीय (positional) हैं, यानी किसी अंक का योगदान इस बात पर निर्भर करता है कि वह कहाँ बैठा है। दशमलव में, दाईं ओर से कॉलम इकाई, दहाई, सैकड़ा, और इसी तरह आगे होते हैं — दस की क्रमिक घातें। बाइनरी भी इसी तरह काम करती है पर दो की घातों के साथ, इसलिए दाईं ओर से कॉलम 1, 2, 4, 8, 16, 32, 64, 128, और ऊपर की ओर होते हैं, जहाँ हर कॉलम अपने दाईं वाले कॉलम का दोगुना होता है।
किसी बाइनरी संख्या को पढ़ने के लिए, आप हर स्थान को देखते हैं, और जहाँ भी 1 हो वहाँ उस कॉलम का स्थानीय मान जोड़ते हैं; जहाँ भी 0 हो वहाँ कुछ नहीं जोड़ते। सबसे दाईं ओर का bit इकाई का स्थान है (दो की घात शून्य), अगला दहाई के बजाय दो का स्थान है (दो की घात एक), फिर चार, आठ, और इसी तरह आगे। 1 वाले bits के स्थानीय मानों को जोड़ने से दशमलव कुल मिलता है। बस यही एक नियम पूरा रूपांतरण है।
हल किया गया उदाहरण: 1011 से दशमलव
बाइनरी संख्या 1011 लीजिए और दाईं ओर से कॉलमों पर निशान लगाइए: सबसे दाईं ओर का bit 1s का स्थान है, फिर 2s, फिर 4s, फिर 8s। इन कॉलमों के सामने bits को पढ़ने पर, आपके पास 8s के स्थान में 1, 4s के स्थान में 0, 2s के स्थान में 1, और 1s के स्थान में 1 है।
अब जहाँ भी 1 दिखे वहाँ स्थानीय मान जोड़िए: 8 + 0 + 2 + 1। इसका योग 11 होता है, इसलिए बाइनरी 1011 दशमलव 11 के बराबर है। अकेला 0 कुछ नहीं जोड़ता, और ठीक इसी काम के लिए वह वहाँ है — 4s कॉलम को खाली रखने के लिए। बाइनरी-से-दशमलव का हर रूपांतरण दो की घातों का यही जोड़ है, चाहे संख्या कितनी भी लंबी क्यों न हो।
एक पूरे byte के साथ दूसरा उदाहरण
आठ-bit वाला मान 11001000 आज़माइए, जो एक पूरा byte है। आठों कॉलम, दाईं ओर से, स्थानीय मान 1, 2, 4, 8, 16, 32, 64, और 128 रखते हैं। जहाँ 1 वाले bits पड़ते हैं वहाँ निशान लगाइए: 128s के स्थान में 1, 64s के स्थान में 1, 8s के स्थान में 1, और बाकी हर जगह 0 है।
इन्हें जोड़िए: 128 + 64 + 8 बराबर 200 होता है, इसलिए 11001000 दशमलव 200 है। तय आठ-bit चौड़ाई के साथ काम करना आम है क्योंकि एक byte 0 (00000000) से 255 (11111111) तक फैलता है। यह जानना कि एक byte का सबसे बाईं ओर का bit 128 के बराबर होता है और मान दाईं ओर 1 तक घटते-घटते दोगुने होते जाते हैं, आपको ज़्यादातर bytes अपने दिमाग में ही तेज़ी से बदलने देता है।
अगुआई करने वाले शून्य और संख्या की लंबाई
अगुआई करने वाले (leading) शून्य कभी किसी बाइनरी मान को नहीं बदलते, ठीक वैसे ही जैसे वे दशमलव में नहीं बदलते। संख्याएँ 1011, 01011, और 00001011 सभी दशमलव 11 के बराबर हैं, क्योंकि किसी ऊँचे कॉलम में रखा 0 योग में बस कुछ नहीं जोड़ता। कंप्यूटर अक्सर बाइनरी को एक तय चौड़ाई तक भरते हैं — एक byte के लिए आठ bit, बड़े टाइप के लिए सोलह या बत्तीस — सिर्फ़ संरेखण (alignment) के लिए, इसलिए नहीं कि अतिरिक्त शून्य कोई अर्थ रखते हैं।
तो जब आप अगुआई करने वाले शून्यों वाली कोई बाइनरी स्ट्रिंग पेस्ट करते हैं, आप उन्हें रख सकते हैं या हटा सकते हैं; दशमलव नतीजा वही रहता है। हालाँकि कुल लंबाई अधिकतम मान ज़रूर तय करती है: n bits के साथ आप शून्य से लेकर दो-की-घात-n घटा एक तक दर्शा सकते हैं। आठ bit अधिकतम 255 तक जाते हैं, सोलह bit 65535 तक। यह टूल लंबी स्ट्रिंग संभालता है, पर बहुत बड़े मान मानक संख्यात्मक परिशुद्धता से आगे निकल सकते हैं, इसलिए रोज़मर्रा के bytes और पूर्णांकों के लिए नतीजा बिल्कुल सटीक होता है।
तेज़ रूपांतरण के लिए दोगुना करने का शॉर्टकट
एक तेज़ मानसिक तरीका है जो स्थानीय मान लिखने से बचाता है। bits को बाएँ से दाएँ पढ़िए, 0 के चलते जोड़ (running total) से शुरू करते हुए। हर bit के लिए, चलते जोड़ को दोगुना कीजिए और फिर मौजूदा bit जोड़ दीजिए। जब आप अंत तक पहुँचते हैं, चलता जोड़ ही दशमलव मान होता है। यह इसलिए काम करता है क्योंकि हर चरण में आपने जो कुछ इकट्ठा किया है, वह एक बाइनरी स्थान बाईं ओर खिसक जाता है।
इसे 1011 पर लगाइए। 0 से शुरू कीजिए। पहला bit 1: 0 का दोगुना 0 है, धन 1 बराबर 1। दूसरा bit 0: 1 का दोगुना 2 है, धन 0 बराबर 2। तीसरा bit 1: 2 का दोगुना 4 है, धन 1 बराबर 5। चौथा bit 1: 5 का दोगुना 10 है, धन 1 बराबर 11। जवाब 11 है, जो स्थानीय-मान वाले तरीके से मेल खाता है। दोगुना करने की यह तरकीब लंबी संख्याओं के लिए अक्सर ज़्यादा तेज़ होती है क्योंकि आपको कभी यह याद नहीं रखना पड़ता कि कोई कॉलम दो की कौन-सी घात दर्शाता है।
यह क्यों मायने रखता है
बाइनरी-से-दशमलव रूपांतरण यह सीखने के लिए बुनियादी है कि कंप्यूटर कैसे काम करते हैं, और यह कंप्यूटर-साइंस के पाठ्यक्रमों तथा प्रमाणन परीक्षाओं का एक मानक विषय है। यह समझना कि एक byte बस दो की घातों का योग है, डेटा के आकार, मेमोरी, और संख्या-परासों का रहस्य खोल देता है, और यह bitwise operations तथा two's-complement पूर्णांकों जैसे विषयों को समझने की पूर्व-शर्त है।
इसके व्यावहारिक उपयोग भी हैं। नेटवर्क इंजीनियर IP addresses और subnet masks पढ़ने के लिए बाइनरी octets को दशमलव में बदलते हैं। प्रोग्रामर डिबगिंग करते समय बाइनरी literals, register values, और bit flags को पढ़ने लायक संख्याओं में अनुवाद करते हैं। जब भी आपके सामने एक और शून्य की कोई स्ट्रिंग हो और आपको यह जानना हो कि वह कितनी मात्रा दर्शाती है, तो यही रूपांतरण वह औज़ार है, और स्थानीय-मान का विभाजन देखना सिर्फ़ जवाब थमाने के बजाय इस तरीके को पुख्ता करता है।
अक्सर पूछे जाने वाले प्रश्न
बाइनरी-से-डेसिमल कन्वर्ज़न कैसे काम करता है?
इनपुट में कौन-से अक्षर मान्य हैं?
क्या मैं कितनी बड़ी बाइनरी संख्या बदल सकता हूँ, इसकी कोई सीमा है?
क्या मैं यहाँ डेसिमल को वापस बाइनरी में बदल सकता हूँ?
क्या यह टूल मुफ़्त है और क्या यह ब्राउज़र में ऑफ़लाइन काम करता है?
संबंधित टूल्स
इन उपयोगी टूल्स के साथ आगे बढ़ें