दशमलव ↔ बाइनरी कनवर्टर
बाइनरी में बदलने के लिए दशमलव संख्या दर्ज करें, या दशमलव में बदलने के लिए बाइनरी संख्या दर्ज करें। परिणाम दूसरे बॉक्स में दिखाई देगा।
बाइनरी एक आधार-2 संख्या प्रणाली है, जिसका अर्थ है कि यह केवल दो अंकों का उपयोग करती है: 0 और 1। बाइनरी संख्या में प्रत्येक स्थिति 2 की शक्ति का प्रतिनिधित्व करती है, दाईं ओर से 2^0 (जो 1 है) से शुरू होकर।
उदाहरण के लिए, बाइनरी संख्या 1101 की गणना इस प्रकार की जाती है:
1 × 2^3 + 1 × 2^2 + 0 × 2^1 + 1 × 2^0 = 8 + 4 + 0 + 1 = 13 (दशमलव में)।
दशमलव ↔ बाइनरी कनवर्टर का उपयोग कैसे करें
- 1
एक संख्या दर्ज करें
Decimal Value बॉक्स में एक डेसिमल संख्या टाइप करें, या Binary Value बॉक्स में एक बाइनरी संख्या।
- 2
कन्वर्ज़न देखें
जैसे-जैसे आप टाइप करते हैं मिलता-जुलता नतीजा तुरंत दूसरे फ़ील्ड में दिखता है, बिना कोई बटन दबाए।
- 3
चरणों की समीक्षा करें
बाइनरी नतीजा बनाने वाली 2-से-भाग प्रक्रिया का पालन करने के लिए Conversion Steps खंड जाँचें।
- 4
नतीजा कॉपी करें
मान लेने के लिए Copy Decimal या Copy Binary का इस्तेमाल करें, या कन्वर्ज़न दिशा उलटने के लिए Swap का।
दशमलव से बाइनरी में बदलना
आधार 10 से आधार 2 तक
दशमलव वह आधार-10 संख्या प्रणाली है जो दस अंकों, 0 से 9 तक, से बनी है और जिसे लोग रोज़ इस्तेमाल करते हैं। बाइनरी वह आधार-2 प्रणाली है जो केवल दो अंकों, 0 और 1, से बनी है और जिसे कंप्यूटर आंतरिक रूप से इस्तेमाल करते हैं क्योंकि उनके परिपथों की दो स्थिर अवस्थाएँ होती हैं। किसी दशमलव संख्या को बाइनरी में बदलना उसी मात्रा को उस रूप में व्यक्त करता है जिस रूप में कोई मशीन उसे संग्रहीत करती है; मान अपरिवर्तित रहता है, केवल नोटेशन भिन्न होता है। दशमलव 13 और बाइनरी 1101 एक ही मात्रा हैं।
इस रूपांतरण को हाथ से करने के दो भरोसेमंद तरीके हैं: दो से बार-बार भाग, जो बाइनरी अंकों को नीचे से ऊपर की ओर बनाता है, और दो की शक्तियों को घटाना, जो उन्हें ऊपर से नीचे की ओर बनाता है। दोनों एक ही जवाब देते हैं। यह टूल भाग की विधि चरण-दर-चरण दिखाता है ताकि आप ठीक-ठीक देख सकें कि नतीजा कैसे बनता है, केवल बिट्स की अंतिम स्ट्रिंग देखने की बजाय।
बार-बार भाग वाली विधि
भाग की विधि इसलिए काम करती है क्योंकि दो से हर भाग एक बाइनरी अंक छील देता है। आप संख्या को दो से भाग देते हैं, शेष लिख लेते हैं (जो हमेशा 0 या 1 होता है), फिर भागफल को दो से भाग देते हैं और उसका शेष दर्ज करते हैं, और तब तक चलते रहते हैं जब तक भागफल शून्य न पहुँच जाए। शेष ही बाइनरी अंक हैं, पर वे सबसे-कम-महत्वपूर्ण पहले निकलते हैं, इसलिए अंतिम चरण है उन्हें उल्टा पढ़ना — आख़िरी शेष से वापस पहले तक।
यह तर्क स्थानीय मानों का दर्पण-प्रतिबिंब है। दो से भाग देना पूछता है कि संख्या में कितने दो समाते हैं, और शेष आपको बताता है कि इकाई बिट सेट है या नहीं; अगला भाग सब कुछ एक बाइनरी स्थान नीचे खिसकाता है और दो वाले बिट के बारे में पूछता है, और इसी तरह आगे। चूँकि हर चरण ठीक एक बिट पैदा करता है, किसी संख्या को उतने ही भागों की ज़रूरत होती है जितने उसके बाइनरी अंक हों।
हल किया हुआ उदाहरण: 13 से बाइनरी
दशमलव 13 को बार-बार भाग से बदलें। 13 को 2 से भाग दें तो भागफल 6 और शेष 1 मिलता है। 6 को 2 से भाग दें तो 3 शेष 0 मिलता है। 3 को 2 से भाग दें तो 1 शेष 1 मिलता है। 1 को 2 से भाग दें तो 0 शेष 1 मिलता है। भागफल अब शून्य है, इसलिए आप रुक जाते हैं।
शेष को उत्पन्न होने के क्रम में इकट्ठा करें — 1, 0, 1, 1 — फिर उन्हें उलट दें ताकि सबसे-महत्वपूर्ण पहले पढ़ा जाए, जिससे 1101 मिलता है। तो दशमलव 13 बाइनरी 1101 है। आप इसे स्थानीय मानों से पुष्ट कर सकते हैं: 1101 है 8 + 4 + 0 + 1, जो ठीक वापस 13 तक जुड़ता है। इस टूल का Conversion Steps पैनल इनमें से हर भाग को आपके लिए बिछा देता है।
दो की शक्तियों वाली विधि
दूसरा तरीका जवाब को ऊपर से नीचे की ओर स्थानीय मानों का इस्तेमाल करते हुए बनाता है। दो की उन शक्तियों को सूचीबद्ध करें जो आपकी संख्या से अधिक न हों — 1, 2, 4, 8, 16, 32, 64, 128, और इसी तरह आगे — फिर उनमें से सबसे बड़ी ढूँढ़ें जो समा जाए, उसे घटाएँ, और शेष के साथ दोहराएँ। आप जिस हर शक्ति का इस्तेमाल करते हैं वह उस स्तंभ में 1 रखती है, और जिस हर शक्ति को आप छोड़ते हैं वह 0 रखती है।
13 के लिए, दो की सबसे बड़ी शक्ति जो समाती है वह 8 है, जो 5 छोड़ती है। 5 में जो सबसे बड़ी शक्ति समाती है वह 4 है, जो 1 छोड़ती है। चार उसे और भाग नहीं देती, दो बहुत बड़ी है, और 1 ठीक समाती है, जो 0 छोड़ती है। तो आपने 8, 4 और 1 स्तंभों का इस्तेमाल किया और 2 स्तंभ को छोड़ दिया, जिससे 1101 मिलता है — भाग वाली विधि जैसा ही नतीजा। एक बार दो की शक्तियाँ ज़बानी याद हो जाएँ तो बहुत-से लोगों को यह तरीका ज़्यादा तेज़ लगता है।
पैडिंग, अग्रणी शून्य और बाइट चौड़ाइयाँ
किसी संख्या के नंगे बाइनरी रूप में कोई अग्रणी शून्य नहीं होता, ठीक वैसे ही जैसे दशमलव 13 को 0013 नहीं लिखा जाता। पर कंप्यूटर संख्याओं को तय-चौड़ाई वाले ख़ानों में संग्रहीत करते हैं, इसलिए वही मान अक्सर बाईं ओर एक मानक आकार तक पैड कर दिया जाता है। एक बाइट के रूप में, 13 को 00001101 लिखा जाता है — सार्थक बिट्स 1101 के साथ आठ स्थानों को भरने के लिए चार अग्रणी शून्य। शून्य मान को नहीं बदलते; वे केवल उसे चौड़ाई तक पैड करते हैं।
चौड़ाई चुनना इसलिए मायने रखता है क्योंकि यह उन मानों की सीमा तय करता है जो समाते हैं। आठ बिट 0 से 255 तक रखते हैं, सोलह बिट 0 से 65535 तक रखते हैं, और इसी तरह आगे। जब आप यहाँ बदलते हैं, तो आपको स्वाभाविक बाइनरी निरूपण मिलता है, और आप उसे मन में जितनी चौड़ाई आपके संदर्भ को चाहिए उतनी तक पैड कर सकते हैं। यह टूल इतनी बड़ी संख्याओं के ख़िलाफ़ भी पहरा देता है जो सुरक्षित पूर्णांक परिशुद्धता से आगे निकल जाएँ, उन्हें एक ग़लत नतीजा लौटाने की बजाय अस्वीकार कर देता है।
ऋणात्मक संख्याएँ और भिन्न
यह कन्वर्टर गैर-ऋणात्मक पूर्णांकों के साथ काम करता है, जो वह मामला है जिससे आप सबसे ज़्यादा मिलते हैं। हालाँकि यह जानना उपयोगी है कि दोनों कठिन मामलों को कहीं और कैसे संभाला जाता है। कंप्यूटर कोई शाब्दिक ऋण चिह्न संग्रहीत नहीं करते; इसके बजाय वे ऋणात्मक पूर्णांकों को two's complement नामक एक योजना से निरूपित करते हैं, जिसमें सबसे महत्वपूर्ण बिट चिह्न दर्शाता है और ऋणात्मक मान को एक तय चौड़ाई के भीतर बिट्स को उलटकर और एक जोड़कर एनकोड किया जाता है।
भिन्न फिर एक अलग तंत्र इस्तेमाल करते हैं। बाइनरी बिंदु के बाद वाला हिस्सा दो की ऋणात्मक शक्तियों से बनता है — एक-आधा, एक-चौथाई, एक-आठवाँ, और इसी तरह आगे — और अधिकांश दशमलव भिन्न, जैसे 0.1, बाइनरी में ठीक-ठीक नहीं लिखे जा सकते, जो उन छोटी पूर्णांकन-त्रुटियों की जड़ है जो आप कभी-कभी फ़्लोटिंग-पॉइंट अंकगणित में देखते हैं। रोज़मर्रा के पूर्ण-संख्या रूपांतरण के लिए, ऊपर बताई गई भाग और दो-की-शक्तियों वाली विधियाँ ही आपके लिए पर्याप्त हैं।
यह कहाँ उपयोगी है
दशमलव-से-बाइनरी रूपांतरण कंप्यूटर-विज्ञान शिक्षा में एक मूलभूत कौशल है और एक आम परीक्षा प्रश्न है, क्योंकि यह मानवीय संख्याओं और मशीन भंडारण के बीच के संबंध को ठोस बना देता है। एक बार जब आप 13 को हाथ से 1101 में बदल पाते हैं, तो डेटा आकार, पूर्णांक ओवरफ़्लो, और बिट हेरफेर जैसे विचारों का अनुसरण करना कहीं ज़्यादा आसान हो जाता है।
यह व्यावहारिक भी है। प्रोग्रामर दशमलव मानों को बाइनरी में बदलते हैं ताकि बिट फ़्लैग सेट करें, बिट मास्क बनाएँ, और निम्न-स्तरीय डेटा के बारे में सोच सकें। नेटवर्क इंजीनियर दशमलव IP ऑक्टेट को बाइनरी में बदलते हैं ताकि सबनेट सीमाएँ निकाल सकें। डिजिटल-इलेक्ट्रॉनिक्स और माइक्रोकंट्रोलर का काम लगातार उन दशमलव संख्याओं के बीच आता-जाता है जो लोग निर्दिष्ट करते हैं और उन बाइनरी पैटर्न के बीच जो हार्डवेयर असल में इस्तेमाल करता है, और एक तेज़, चरण-दर-चरण कन्वर्टर उस अनुवाद को सटीक रखता है।
अक्सर पूछे जाने वाले प्रश्न
क्या यह दोनों दिशाओं में कन्वर्ट करता है?
क्या मैं देख सकता हूँ कि कन्वर्ज़न की गणना कैसे होती है?
मान्य बाइनरी इनपुट क्या माना जाता है?
क्या संख्या कितनी बड़ी हो सकती है, इसकी कोई सीमा है?
क्या मेरा डेटा निजी रखा जाता है?
संबंधित टूल्स
इन उपयोगी टूल्स के साथ आगे बढ़ें