बिटवाइज़ कैलकुलेटर

यह कैसे काम करता है

1. दो संख्याएँ दर्ज करें: दशमलव, बाइनरी (0b उपसर्ग) या हेक्साडेसिमल (0x उपसर्ग) में मान दर्ज करें।
2. ऑपरेशन चुनें: AND, OR, XOR, NOT, बायाँ शिफ़्ट (<<) या दायाँ शिफ़्ट (>>) चुनें।
3. परिणाम देखें: आउटपुट परिणाम को दशमलव, बाइनरी और हेक्साडेसिमल में एक साथ प्रदर्शित करता है।

बिटवाइज़ कैलकुलेटर क्यों इस्तेमाल करें?

बिटवाइज़ ऑपरेशन सिस्टम प्रोग्रामिंग, क्रिप्टोग्राफ़ी, गेम डेवलपमेंट, ग्राफ़िक्स, नेटवर्किंग आदि में मौलिक हैं।

विशेषताएँ

• सभी बिटवाइज़ ऑपरेटर: AND (&), OR (|), XOR (^), NOT (~), बायाँ शिफ़्ट (<<) और दायाँ शिफ़्ट (>>)।
• मल्टी-बेस इनपुट: दशमलव, बाइनरी (0b…) या हेक्साडेसिमल (0x…) में संख्याएँ दर्ज करें।
• मल्टी-बेस आउटपुट: परिणाम एक साथ दशमलव, बाइनरी और हेक्साडेसिमल में प्रदर्शित होते हैं।
• बिट विज़ुअलाइज़ेशन: एक दृश्य ग्रिड दिखाता है कि प्रत्येक ऑपरेंड और परिणाम के लिए कौन से बिट सक्रिय हैं।
• साइंड/अनसाइंड मोड: 8, 16, 32 और 64-बिट पूर्णांकों के बीच स्विच करें।

अक्सर पूछे जाने वाले प्रश्न

प्रोग्रामिंग में XOR का उपयोग किस लिए होता है?

XOR (^) बिट्स को फ़्लिप करने, सरल एन्क्रिप्शन/ऑब्फ़्यूसकेशन, बिना अस्थायी चर के वेरिएबल स्वैप करने, समता जाँचने और हैश मिलाने के लिए उपयोग होता है। यह 1 लौटाता है जब बिट्स भिन्न होते हैं और 0 जब वे समान होते हैं।

<< और >> में क्या अंतर है?

बायाँ शिफ़्ट (<<) सभी बिट्स को बाईं ओर ले जाता है, जो 2 के पावर से गुणा करने के बराबर है। दायाँ शिफ़्ट (>>) बिट्स को दाईं ओर ले जाता है, जो 2 के पावर से भाग देने के बराबर है। अंकगणित दायाँ शिफ़्ट चिह्न बिट को संरक्षित करता है; तार्किक दायाँ शिफ़्ट शून्य से भरता है।

मैं एक विशिष्ट बिट को कैसे सक्षम या अक्षम करूँ?

बिट n को सक्षम करने के लिए: value |= (1 << n)। बिट n को अक्षम करने के लिए: value &= ~(1 << n)। बिट n को फ़्लिप करने के लिए: value ^= (1 << n)। यह जाँचने के लिए कि बिट n सक्षम है: (value & (1 << n)) !== 0।

बूलियन बीजगणित से सिलिकॉन तक: बिटवाइज़ ऑपरेशन कैसे सार्वभौमिक बन गए

हर आधुनिक CPU जो बिटवाइज़ ऑपरेशन लागू करता है, वे 80 साल से अधिक के अंतराल में प्रकाशित दो आधारभूत पत्रों से आते हैं। 1854 में, George Boole ने «An Investigation of the Laws of Thought» प्रकाशित किया, जिसमें दो-मूल्यी तर्क के बीजगणित को परिभाषित किया, AND, OR, NOT, और उनकी पहचान। यह एक दार्शनिक कार्य था, इंजीनियरिंग नहीं। फिर 1937 में, MIT के एक 21 वर्षीय स्नातक छात्र Claude Shannon ने अपनी मास्टर्स थीसिस «A Symbolic Analysis of Relay and Switching Circuits» लिखी, यह साबित करते हुए कि बूलियन बीजगणित विद्युत रिले सर्किट का वर्णन कर सकता है और इसलिए कि कोई भी तार्किक संगणना भौतिक रूप से लागू की जा सकती है। इस थीसिस को व्यापक रूप से 20वीं सदी की सबसे महत्वपूर्ण मास्टर्स थीसिस के रूप में उद्धृत किया जाता है और यह सभी डिजिटल इलेक्ट्रॉनिक्स की नींव है। दो का पूरक, हर CPU द्वारा उपयोग की जाने वाली नकारात्मक संख्याओं के लिए बाइनरी प्रतिनिधित्व, 1962 में Burroughs Corporation द्वारा पेटेंट कराया गया था लेकिन IBM 704 (1954) और अन्य प्रारंभिक मशीनों में पहले से ही उपयोग किया गया था। IEEE 754 ने 1985 में फ्लोटिंग-पॉइंट प्रतिनिधित्व को मानकीकृत किया, हर JavaScript Number द्वारा अभी भी उपयोग किए जाने वाले बिट लेआउट को तय किया, binary64 के लिए 1 साइन बिट, 11 घातांक, 52 मंटिसा। आज, C भाषा ऑपरेटर & | ^ ~ << >> लगभग सीधे एकल CPU निर्देशों से मैप होते हैं, यही कारण है कि बिटवाइज़ कोड अंकगणितीय समकक्ष से नाटकीय रूप से तेज़ हो सकता है।

छह ऑपरेटर, बिट स्तर पर वे क्या करते हैं

• AND (&)। परिणाम बिट केवल तभी 1 है जब दोनों इनपुट बिट 1 हों। 0b1100 & 0b1010 = 0b1000। मास्क करने, विशिष्ट बिट्स को अलग करने, या यह जांचने के लिए उपयोग करें कि क्या एक फ़्लैग सेट है: flags & FLAG_READ गैर-शून्य है यदि FLAG_READ चालू है।
• OR (|)। यदि कोई इनपुट बिट 1 है तो परिणाम बिट 1 है। 0b1100 | 0b1010 = 0b1110। बिट सेट करने, फ़्लैग संयोजित करने के लिए उपयोग करें: flags = FLAG_READ | FLAG_WRITE।
• XOR (^)। यदि बिल्कुल एक इनपुट बिट 1 है तो परिणाम बिट 1 है। 0b1100 ^ 0b1010 = 0b0110। बिट टॉगल करने, सरल अस्पष्टीकरण (x ^ x = 0, इसलिए XOR अपना स्वयं का व्युत्क्रम है), समता और हैश मिश्रण के लिए उपयोग करें।
• NOT (~)। हर बिट फ्लिप करें। ~0b0000_1111 = 0b1111_0000 (8 बिट में)। दो के पूरक में, ~x -x − 1 के बराबर है, इसलिए JavaScript में ~5 === -6।
• लेफ्ट शिफ्ट (<<)। सभी बिट्स को n स्थानों से बाएं ले जाएं, दाईं ओर शून्य से भरें। 1 << 3 === 8, 2³ से गुणा करने के समान। बिट मास्क बनाने के लिए उपयोगी: 1 << n «स्थिति n पर बिट» है।
• राइट शिफ्ट (>> अंकगणितीय, >>> तार्किक)। बिट्स को दाईं ओर ले जाएं। अंकगणितीय शिफ्ट (JS, Java, C signed में >>) साइन बिट को संरक्षित करता है; तार्किक शिफ्ट (JS में >>>, C unsigned में >>) शून्य से भरता है। -8 >> 1 === -4 लेकिन JavaScript में -8 >>> 1 === 2147483644 क्योंकि >>> पहले 32-बिट अहस्ताक्षरित int में परिवर्तित करता है।

जहाँ बिटवाइज़ वास्तव में अपना भुगतान कमाता है

• बिट फ़्लैग और फ़ीचर टॉगल। 32 बूलियन विकल्पों को एक एकल पूर्णांक में पैक करें। Linux फ़ाइल अनुमतियाँ (chmod 755), नेटवर्क प्रोटोकॉल हेडर (TCP, IPv4), और OpenGL स्टेट फ़्लैग सभी इस पैटर्न का उपयोग करते हैं। एक & चेक आपको बताता है कि क्या एक फ़ीचर सक्षम है।
• Unix फ़ाइल अनुमतियाँ। rwxr-xr-x है 0b111_101_101 = 0o755 = 493। तीन समूह उपयोगकर्ता/समूह/अन्य हैं, हर तीन बिट्स read/write/execute हैं। chmod कैलकुलेटर प्रतीकात्मक रूप को उस पूर्णांक में बदलता है जो आपका शेल चाहता है।
• IP सबनेट मास्क। एक /24 मास्क है 255.255.255.0 या 0xFFFFFF00। यह जांचने के लिए कि क्या एक IP सबनेट में है: (ip & mask) === (network & mask)। दुनिया में हर राउटर और फ़ायरवॉल द्वारा उपयोग किया जाता है।
• क्रिप्टोग्राफी और हैशिंग। SHA-256, AES, ChaCha20, BLAKE3, हर आधुनिक हैश और सिफर मुख्य रूप से AND, OR, XOR, NOT और रोटेशन से बनाया जाता है। XOR अकेले एक-बार पैड का आधार है, जो साबित रूप से अटूट हैं जब कुंजी वास्तव में यादृच्छिक हो और एक बार उपयोग की जाए।
• रंग हेरफेर। एक 32-बिट RGBA रंग चार 8-बिट चैनलों को पैक करता है: (R << 24) | (G << 16) | (B << 8) | A। लाल चैनल निकालने के लिए: (color >> 24) & 0xFF। HTML canvas, OpenGL, हर छवि प्रारूप द्वारा उपयोग किया जाता है।
• प्रदर्शन तरकीबें। अधिकांश CPU पर x & 1 x % 2 से बहुत तेज है (एक चक्र बनाम ~10)। x >> 1 एक चक्र में 2 से विभाजित करता है। पावर-ऑफ-टू संरेखण, बिट-जनसंख्या गणना, और बिट-ट्विडलिंग हैक प्रदर्शन-महत्वपूर्ण कोड में हर जगह हैं। (एक प्रसिद्ध कैटलॉग के लिए Sean Anderson का «Bit Twiddling Hacks» पृष्ठ देखें।)
• एम्बेडेड सिस्टम। माइक्रोकंट्रोलर हार्डवेयर रजिस्टर्स को मेमोरी में विशिष्ट बिट स्थितियों में मैप करते हैं। UART या GPIO पिन को कॉन्फ़िगर करने के लिए शेष को परेशान किए बिना सही बिट्स को पढ़ने या लिखने के लिए मास्किंग और शिफ्टिंग की आवश्यकता होती है। C का बिटफील्ड सिंटैक्स इन पैटर्न के लिए सुविधाजनक चीनी है।

गलतियाँ जो काटती हैं

• & को && के साथ और | को || के साथ भ्रमित करना। एकल रूप बिटवाइज़ हैं, डबल शॉर्ट-सर्किट तार्किक हैं। 1 & 2 === 0 (कोई साझा बिट नहीं) लेकिन 1 && 2 === 2 (दोनों सत्य, दूसरा लौटाता है)। उन्हें मिलाने से चुपचाप सशर्त तर्क टूट जाता है।
• ऑपरेटर प्राथमिकता आश्चर्य। x & FLAG === 0 का अर्थ है x & (FLAG === 0), न कि (x & FLAG) === 0, क्योंकि === & से अधिक कसकर बांधता है। हमेशा शर्तों में बिटवाइज़ अभिव्यक्तियों को कोष्ठक में डालें।
• हस्ताक्षरित-बनाम-अहस्ताक्षरित शिफ्ट भ्रम। JavaScript में, >> अंकगणितीय है (साइन-विस्तार), >>> तार्किक है (शून्य-भरण)। C चर के प्रकार से अंतर करता है, हस्ताक्षरित प्रकार अंकगणितीय का उपयोग करते हैं, अहस्ताक्षरित तार्किक का उपयोग करते हैं। Java में JavaScript की तरह दोनों >> और >>> हैं। भाषा सम्मेलन से मेल नहीं खाने से चुपचाप अर्थ पलट जाता है।
• JavaScript बिटवाइज़ ऑप्स के लिए 32 बिट तक छोटा करता है। Number 64-बिट फ़्लोट होने के बावजूद, सभी बिटवाइज़ ऑपरेटर पहले ऑपरेंड को int32 में परिवर्तित करते हैं। 0x100000000 & 0xFF === 0, 0 + निम्न बाइट नहीं, क्योंकि ऑपरेंड AND से पहले 32 बिट तक छोटा हो जाता है। 64-बिट बिट हेरफेर के लिए BigInt का उपयोग करें, जिसके अपने बिटवाइज़ ऑपरेटर हैं।
• JavaScript में > 31 से शिफ्ट करना। 1 << 32 === 1, 0 नहीं। शिफ्ट राशि मॉड्यूलो 32 ली जाती है। C और भी खतरनाक है: बिट चौड़ाई से अधिक शिफ्ट करना अपरिभाषित व्यवहार है, इसलिए कंपाइलर कुछ भी कर सकते हैं। रनटाइम मान द्वारा शिफ्ट करने से पहले हमेशा n < bitWidth जांचें।
• बाइट-पैकिंग कोड में एंडियननेस। (r << 24) | (g << 16) | (b << 8) | a 0xRRGGBBAA उत्पन्न करता है। क्या बाइट्स उस क्रम में संग्रहीत हैं या मेमोरी में उलटे हैं प्लेटफ़ॉर्म पर निर्भर करता है। HTML canvas में ImageData x86 पर little-endian है; PNG फ़ाइल प्रारूप big-endian है। बाइनरी प्रारूपों को पढ़ते समय DataView के साथ स्पष्ट रूप से कनवर्ट करें।
• दो के पूरक को भूलना। ~0 === -1, 0xFFFFFFFF नहीं, क्योंकि सभी-वन −1 का दो का पूरक एन्कोडिंग है। JavaScript में अहस्ताक्षरित 32-बिट व्याख्या प्राप्त करने के लिए: (~0) >>> 0 === 4294967295।

क्यों दो का पूरक, और इसका बिट स्तर पर क्या अर्थ है

हर आधुनिक CPU दो के पूरक का उपयोग करके नकारात्मक पूर्णांकों का प्रतिनिधित्व करती है। एक हस्ताक्षरित 8-बिट बाइट में, मान 0 से 127 बाइनरी 0000_0000 से 0111_1111 के रूप में एन्कोड किए जाते हैं। फिर −1 1111_1111 के रूप में एन्कोड किया जाता है, −2 1111_1110 के रूप में, नीचे −128 तक 1000_0000 के रूप में। कारण: इस एन्कोडिंग के साथ, अतिरिक्त समान तरीके से काम करता है चाहे इनपुट हस्ताक्षरित हों या अहस्ताक्षरित, CPU को अलग add-signed और add-unsigned निर्देशों की आवश्यकता नहीं है। असममितता यह है कि नकारात्मक सीमा सकारात्मक से एक बड़ी है (8 बिट में, −128 से +127), यही कारण है कि Math.abs(INT_MIN) स्थिर-चौड़ाई पूर्णांकों वाली हर भाषा में ओवरफ्लो होता है। पहले के साइन-मैग्निट्यूड (साइन के लिए एक बिट, बाकी परिमाण के लिए) और एक के पूरक एन्कोडिंग 1950-60 के दशक में मौजूद थे लेकिन दो के पूरक से हार गए क्योंकि उनके पास शून्य की दो अभ्यावेदन थीं और निषेध के लिए विशेष-मामले हार्डवेयर की आवश्यकता थी।

अधिक अक्सर पूछे जाने वाले प्रश्न

~5 250 के बजाय -6 के बराबर क्यों है?

क्योंकि दो के पूरक (एन्कोडिंग जो हर आधुनिक CPU उपयोग करती है) में, सकारात्मक संख्या के हर बिट को पलटने से आपको -n - 1 मिलता है। तो ~5 === -6 और ~0 === -1। एक अहस्ताक्षरित 8-बिट संदर्भ में, ~5 के समान बिट पैटर्न (बाइनरी 1111_1010) 250 का प्रतिनिधित्व करेगा। JavaScript परिणाम को हस्ताक्षरित 32-बिट के रूप में मानता है, इसलिए आप -6 देखते हैं। अहस्ताक्षरित व्याख्या प्राप्त करने के लिए: 32-बिट में (~5) >>> 0, जो 4294967290 देता है, या ~5 & 0xFF के साथ 8 बिट तक मास्क करें जो 250 देता है।

क्या XOR वास्तव में एक एन्क्रिप्शन है?

XOR हर आधुनिक सममित सिफर का बिल्डिंग ब्लॉक है, लेकिन XOR अकेले सुरक्षित एन्क्रिप्शन नहीं है। एक एक-बार पैड, संदेश जितनी लंबी सच में यादृच्छिक कुंजी के साथ XOR, ठीक एक बार उपयोग किया गया, सूचना-सैद्धांतिक रूप से अटूट है (Shannon, 1949)। कुंजी का पुन: उपयोग करें, या संदेश से छोटी कुंजी का उपयोग करें, और आवृत्ति विश्लेषण इसे तुच्छ रूप से तोड़ देता है। AES जैसे वास्तविक सिफर एक छोटी कुंजी को छद्म यादृच्छिक बाइट्स की धारा में बढ़ाने के लिए XOR प्लस प्रसार और प्रतिस्थापन का उपयोग करते हैं जो कुंजी के बिना किसी को भी एक-बार पैड की तरह दिखता है। तो «XOR के साथ एन्क्रिप्ट करें» केवल तुच्छ अस्पष्टीकरण के लिए ठीक है, वास्तविक रहस्यों के लिए कभी नहीं।

बिट हेरफेर के लिए मुझे Number के बजाय BigInt का उपयोग कब करना चाहिए?

जब भी आपको 32 बिट से अधिक बिटवाइज़ सटीकता की आवश्यकता हो। JavaScript बिटवाइज़ ऑपरेटर गणना से पहले Number ऑपरेंड को 32-बिट हस्ताक्षरित पूर्णांकों में छोटा कर देते हैं। यदि आपको 64-बिट मास्क की आवश्यकता है (उदा। 64-बिट फ़ीचर फ़्लैग सेट में हेरफेर, Linux mmap ऑफ़सेट के साथ काम करना, या SHA-512 लागू करना), BigInt का उपयोग करें: 0xFFFFFFFFFFFFFFFFn & 0xFFn === 255n। BigInt Number से धीमा है, संचालन के आधार पर ~3-10×, इसलिए इसे उन मामलों के लिए आरक्षित करें जहाँ 32 बिट वास्तव में बहुत कम हैं।

मैं एक संख्या में 1 बिट्स की संख्या कैसे गिनता हूँ?

यह जनसंख्या गिनती या हैमिंग वज़न है। अधिकांश आधुनिक CPU में इसके लिए एक एकल निर्देश होता है (x86 पर POPCNT, ARM पर VCNT)। JavaScript में, कोई अंतर्निहित नहीं है, इसलिए बिट-ट्विडलिंग क्लासिक का उपयोग करें: let c = 0; while (x) { c += x & 1; x >>>= 1; }। या Hacker's Delight से समानांतर SWAR ट्रिक: x = x - ((x >> 1) & 0x55555555); x = (x & 0x33333333) + ((x >> 2) & 0x33333333); x = (x + (x >> 4)) & 0x0F0F0F0F; return (x * 0x01010101) >>> 24;, जो 32-बिट पूर्णांक में बिट्स को लगभग एक दर्जन चक्रों में गिनती है।

जब मैं इस कैलकुलेटर का उपयोग करता हूँ तो क्या मेरा डेटा कहीं भेजा जाता है?

नहीं। हर ऑपरेशन आपके ब्राउज़र के JavaScript इंजन में चलता है, गणना के दौरान कोई नेटवर्क कॉल नहीं होती है। DevTools में नेटवर्क टैब खोलें और गणना पर क्लिक करें, आप शून्य आउटबाउंड अनुरोध देखेंगे। संवेदनशील मास्क, कुंजी या मालिकाना बिट-लेआउट कार्य के लिए सुरक्षित।