कंप्यूटर की मेमोरी में संख्याएँ कैसे रखी जाती हैं

कंप्यूटर हर संख्या को बिट्स की एक पंक्ति में रखता है। n बिट्स में बिना चिह्न की संख्या 0 से 2^n − 1 तक होती है। ऋणात्मक संख्याएँ 2 के पूरक (two's complement) में रखी जाती हैं, जहाँ सबसे बाएँ बिट का भार ऋणात्मक होता है (8 बिट में −128)। परिणाम न समाए तो वह घूम जाता है: ओवरफ़्लो। बिटवाइज़ क्रियाएँ (AND, OR, XOR, NOT) और शिफ्ट अलग-अलग बिट पर काम करते हैं; एक बिट बाएँ शिफ्ट करने पर संख्या दुगुनी होती है। दशमलव फ्लोटिंग पॉइंट में रखे जाते हैं: चिह्न, घातांक और मंटिसा, इसलिए कई भिन्न केवल लगभग सही रखी जाती हैं।

🎬 कदम-दर-कदम कहानी

एक बाइट में 8 स्विच होते हैं, जिन्हें बिट कहते हैं। हर स्विच का भार है: 1, 2, 4, 8 से 128 तक। जो स्विच ON हैं उनके भार जोड़ो। 00000101 यानी 4 + 1 = 5।
−5 कैसे रखें? सबसे बाएँ स्विच का भार −128 कर देते हैं। अब 11111011 = −128 + 64 + 32 + 16 + 8 + 2 + 1 = −5। इसे 2 का पूरक कहते हैं।
127 से शुरू करो, यह सबसे बड़ी चिह्न वाली बाइट-संख्या है। इसमें 1 जोड़ो। सबसे बाएँ स्विच ON हो गया और संख्या −128 पर कूद गई। जगह खत्म हुई तो संख्या घूम गई। इसे ओवरफ़्लो कहते हैं।
सारे बिट एक जगह बाएँ खिसकाओ। 00000101 बन गया 00001010। संख्या दुगुनी हो गई: 5 से 10। दाएँ शिफ्ट से आधी होती है। AND, OR, XOR, NOT हर बिट पर अलग-अलग काम करते हैं।
दशमलव के लिए तीन हिस्से चाहिए: चिह्न (लाल), घातांक (नीला) और मंटिसा (हरा)। 0 100 1000 यानी 1.5 × 2 = 3। इसे फ्लोटिंग पॉइंट कहते हैं। यह कुछ ही भिन्नों के लिए एकदम सही होता है।
अब तुम्हारी बारी। बिट पर टैप करो, +1, शिफ्ट और NOT दबाओ। देखो बिना चिह्न और चिह्न वाला मान साथ-साथ कैसे बदलते हैं।

टिप: 3D दृश्य को घुमाने के लिए खींचें। ज़ूम के लिए दो उंगलियाँ इस्तेमाल करें।

🤔 आम शंकाएँ और उनके जवाब

भार 1, 2, 4, 8… ही क्यों?

हर स्थान अपने दाएँ वाले से दुगुना है, जैसे दशमलव में इकाई, दहाई, सैकड़ा, बस यहाँ 10 की जगह 2। ON स्विच के भार जोड़कर संख्या पढ़ लो।

सबसे बाएँ बिट का भार सिर्फ़ ऋण चिह्न नहीं, −128 क्यों है?

अलग चिह्न रखने से दो शून्य (+0 और −0) बनते और जोड़ने के खास नियम लगते। −128 भार रखने से सामान्य जोड़ सब संख्याओं पर चलता है और शून्य सिर्फ़ एक रहता है।

ऋणात्मक संख्याएँ एक ज़्यादा क्यों हैं?

256 में से आधे पैटर्न में सबसे बायाँ बिट 1 है: यानी −128 से −1, कुल 128 संख्याएँ। बाकी आधे 0 से 127 हैं, वे भी 128 पैटर्न हैं, पर उनमें एक शून्य है।

127 + 1 क्यों −128 बन जाता है?

01111111 में 1 जोड़ने पर 10000000 बनता है। सबसे बायाँ बिट ON हो जाता है और उसका भार −128 है। संख्या ओडोमीटर की तरह घूम जाती है।

क्या बायाँ शिफ्ट हमेशा संख्या दुगुनी करता है?

सिर्फ़ तब जब ऊपर से कोई 1 गिरे नहीं। 10000000 को बाएँ खिसकाने पर 1 खो जाता है, इसलिए परिणाम दुगुना नहीं होता। 3D में सबसे बायाँ घन देखो।

0.1 + 0.2 ठीक 0.3 क्यों नहीं होता?

0.1 और 0.2 के बाइनरी रूप कभी खत्म नहीं होते, इसलिए कंप्यूटर सबसे पास का रखा जा सकने वाला मान रखता है। दोनों की छोटी-छोटी गलतियाँ मिलकर हल्का-सा अंतर बना देती हैं।

बिट, बाइट और संख्याओं की सीमा

बिट एक स्विच है: 0 या 1। बाइट यानी 8 बिट। हर स्थान का भार बाईं ओर दुगुना होता जाता है: 1, 2, 4, 8, 16, 32, 64, 128।

n बिट्स से 2ⁿ अलग-अलग पैटर्न बनते हैं। सब पैटर्न धनात्मक संख्याओं के लिए लें (बिना चिह्न / unsigned) तो सीमा 0 से 2ⁿ − 1 होती है। 8 बिट में 0 से 255। 16 बिट में 0 से 65 535।

उदाहरण: 00101101 = 32 + 8 + 4 + 1 = 45।

2 का पूरक (two's complement): ऋणात्मक संख्या रखना

कुछ पैटर्न ऋणात्मक संख्याओं के लिए चाहिए। 2 के पूरक में सबसे बाएँ बिट (MSB) का भार ऋणात्मक होता है। 8 बिट में +128 की जगह −128।

सबसे बायाँ बिट 0 हो तो संख्या 0 से 127।
सबसे बायाँ बिट 1 हो तो संख्या −128 से −1।

इसलिए 8 बिट की चिह्न वाली सीमा −128 से +127 है। n बिट में −2ⁿ⁻¹ से 2ⁿ⁻¹ − 1। ऋणात्मक संख्याएँ एक ज़्यादा हैं और शून्य सिर्फ़ एक है।

−x कैसे लिखें

x को बाइनरी में लिखो।
हर बिट उलट दो (0 को 1, 1 को 0)।
उसमें 1 जोड़ दो।

उदाहरण: −5। 5 = 00000101। उलटा: 11111010। 1 जोड़ा: 11111011। जाँच: −128 + 64 + 32 + 16 + 8 + 2 + 1 = −5।

कंप्यूटर को यह क्यों पसंद है

एक ही जोड़ने वाला सर्किट धन और ऋण दोनों जोड़ देता है। 5 + (−5) = 00000101 + 11111011 = 1 00000000। नौवाँ बिट छूट जाता है और 0 बचता है। घटाना बस ऋणात्मक संख्या जोड़ना बन जाता है।

ओवरफ़्लो: जब उत्तर समाता नहीं

एक बाइट में सिर्फ़ 256 पैटर्न हैं। परिणाम सीमा से बाहर हो तो ऊपर का बिट खो जाता है और संख्या ओडोमीटर की तरह घूम जाती है। इसे ओवरफ़्लो कहते हैं।

चिह्न वाली 8 बिट: 127 + 1 = −128।
बिना चिह्न 8 बिट: 255 + 1 = 0।
बिना चिह्न 8 बिट: 200 + 100 = 300 − 256 = 44।

चिह्न वाला ओवरफ़्लो पहचाना जा सकता है: दो धनात्मक जोड़ने पर ऋणात्मक मिले, या दो ऋणात्मक जोड़ने पर धनात्मक मिले। असली प्रोग्राम ज़्यादा बिट (16, 32, 64) लेकर या पहले जाँच करके इससे बचते हैं।

बिटवाइज़ क्रियाएँ और शिफ्ट

बिटवाइज़ क्रिया संख्या को बिट्स की पंक्ति मानकर हर स्तंभ पर अलग काम करती है।

क्रिया	नियम	उदाहरण
AND (&)	दोनों बिट 1 हों तभी 1	1101 & 1011 = 1001
OR (\|)	कम से कम एक बिट 1 हो तो 1	1101 \| 1011 = 1111
XOR (^)	बिट अलग-अलग हों तो 1	1101 ^ 1011 = 0110
NOT (~)	हर बिट उलट दो	~00000101 = 11111010

शिफ्ट

बायाँ शिफ्ट << k: बिट k स्थान बाएँ खिसकते हैं, खाली जगह में 0। यह 2^k से गुणा करता है (अगर ऊपर से कुछ गिरा नहीं)। 5 << 3 = 40।
दायाँ शिफ्ट >> k: बिट दाएँ खिसकते हैं। यह 2^k से भाग देकर शेषफल छोड़ देता है। ऋणात्मक चिह्न वाली संख्या में सबसे बायाँ बिट वापस भर जाता है (arithmetic shift), इसलिए −5 >> 1 = −3।

उपयोग: मास्क के साथ AND कुछ बिट छाँट लेता है, OR बिट ON करता है, XOR चुने हुए बिट उलटता है, और शिफ्ट 2 की घात से बहुत तेज़ गुणा-भाग करता है।

फ्लोटिंग पॉइंट: दशमलव कैसे रखे जाते हैं

3.14 या 0.000001 जैसी संख्याओं के लिए कंप्यूटर फ्लोटिंग पॉइंट इस्तेमाल करता है, यानी बाइनरी में वैज्ञानिक संकेतन। बिट तीन हिस्सों में बँटते हैं:

चिह्न (1 बिट): 0 धनात्मक, 1 ऋणात्मक।
घातांक (exponent): बिंदु कितना खिसका (2 की घात)। इसे बायस के साथ रखते हैं ताकि वह ऋणात्मक भी हो सके।
मंटिसा (भिन्न): संख्या के अंक, 1.xxxx के रूप में (शुरू का 1 रखा नहीं जाता)।

मान = (−1)^{चिह्न} × 1.मंटिसा × 2^{घातांक − बायस}।

हमारा 3D छोटा 8 बिट वाला रूप दिखाता है: 1 चिह्न, 3 घातांक बिट (बायस 3), 4 मंटिसा बिट। 0 100 1000: घातांक 4 − 3 = 1, मंटिसा 1.5, मान 1.5 × 2 = 3। असली कंप्यूटर 32 बिट (float: 1 + 8 + 23) या 64 बिट (double: 1 + 11 + 52) लेते हैं।

0.1 एकदम सही क्यों नहीं रखा जाता

0.1 का बाइनरी रूप कभी खत्म नहीं होता: 0.000110011… सिर्फ़ तय संख्या में बिट रखे जा सकते हैं, इसलिए रखा हुआ मान बहुत पास का अनुमान है। इसी वजह से 0.1 + 0.2 का उत्तर 0.30000000000000004 आता है। फ्लोटिंग संख्याओं को कभी == से मत जाँचो; देखो कि वे काफ़ी पास हैं या नहीं। बहुत बड़ा घातांक अनंत (infinity) देता है और अमान्य परिणाम NaN (not a number)।

मुख्य सूत्र और परिभाषाएँ

बिना चिह्न n बिट: 0 से 2^n − 1
चिह्न सहित n बिट (2 का पूरक): −2^(n−1) से 2^(n−1) − 1
x का ऋणात्मक: x के सब बिट उलटो, फिर 1 जोड़ो
x << k = x × 2^k; x >> k = floor(x ÷ 2^k)
फ्लोट मान = (−1)^चिह्न × 1.मंटिसा × 2^(घातांक − बायस)
float32 = 1 + 8 + 23 बिट; double = 1 + 11 + 52 बिट

हल किए गए उदाहरण

1. 00101101 का मान बिना चिह्न 8 बिट संख्या के रूप में निकालो।

ON बिट के भार: 32 + 8 + 4 + 1 = 45।

2. −20 को 8 बिट 2 के पूरक में लिखो।

20 = 00010100। उलटा: 11101011। 1 जोड़ा: 11101100। जाँच: −128 + 64 + 32 + 8 + 4 = −20।

3. 11110110 चिह्न वाली 8 बिट संख्या के रूप में क्या है?

सबसे बायाँ बिट 1 है, इसलिए ऋणात्मक: −128 + 64 + 32 + 16 + 4 + 2 = −10।

4. चिह्न वाले 8 बिट वेरिएबल में 120 है। उसमें 10 जोड़ा। क्या जमा होगा?

120 + 10 = 130, जो 127 से ऊपर है। वह घूमता है: 130 − 256 = −126। बिट में: 10000010 = −128 + 2 = −126।

5. 13 XOR 6 और 5 << 3 निकालो।

13 = 1101, 6 = 0110। XOR से 1011 = 11। और 5 << 3 = 5 × 8 = 40 (00101000)।

6. 8 बिट मिनी-फ्लोट (1 चिह्न, 3 घातांक बिट बायस 3 के साथ, 4 मंटिसा बिट) में 0 011 1100 का मान निकालो।

घातांक = 3, तो 3 − 3 = 0। मंटिसा 1100 = 12/16 = 0.75, यानी 1.75। मान = 1.75 × 2^0 = 1.75।

7. चिह्न वाली 8 बिट संख्या पर −5 >> 1 क्या होगा?

−5 = 11111011। arithmetic दायाँ शिफ्ट सबसे बायाँ बिट वापस भरता है: 11111101 = −3 (परिणाम नीचे की ओर, −अनंत की तरफ़ गोल होता है)।

आम गलतियाँ

चिह्न वाली संख्या में सबसे बाएँ बिट को +128 पढ़ लेना। 2 के पूरक में वह −128 है।
बिट उलटने के बाद 1 जोड़ना भूल जाना। सिर्फ़ उलटने से −x − 1 मिलता है।
सोचना कि ओवरफ़्लो पर त्रुटि संदेश आता है। ज़्यादातर भाषाओं और हार्डवेयर में संख्या चुपचाप घूम जाती है।
कोड में दशमलव को == से जाँचना। 0.1 + 0.2 == 0.3 गलत है; छोटी सहनसीमा से तुलना करो।

अभ्यास क्विज़

1. चिह्न वाली 8 बिट संख्या (2 का पूरक) की सीमा: 0 से 255 −127 से 127 −128 से 127 −256 से 255

2. 2 के पूरक में −x पाने के लिए: सिर्फ़ बिट उलटो बिट उलटो और 1 जोड़ो 1 जोड़ो फिर उलटो सिर्फ़ सबसे बायाँ बिट बदलो

3. चिह्न वाली बाइट में 127 है। 1 जोड़ने पर क्या होगा? 128 0 −128 −1

4. 5 << 2 बराबर है: 7 10 20 25

5. फ्लोटिंग पॉइंट में 0.1 एकदम सही क्यों नहीं रखा जाता? कंप्यूटर धीमा है इसका बाइनरी रूप कभी खत्म नहीं होता यह ऋणात्मक है चिह्न बिट नहीं है

अभ्यास: खुद जवाब दो

अपना जवाब लिखो या चुनो, फिर जाँचें दबाओ। अटको तो संकेत देखो; जवाब देने के बाद पूरा हल दिखेगा।

2. 2 के पूरक में हर ऋणात्मक संख्या का सबसे बायाँ बिट 1 होता है।सही। 8 बिट में उसका भार −128 है, इसलिए वहाँ 1 होने से मान शून्य से नीचे चला जाता है।

4. हर क्रिया को उसके काम से मिलाओ।<< 1 दुगुना, >> 1 आधा, NOT सब बिट उलटता है, AND में दोनों बिट 1 चाहिए।

5. परिणाम बिट्स में न समाकर घूम जाए तो उस गड़बड़ी को क्या कहते हैं?ओवरफ़्लो।

7. चिह्न वाले 8 बिट वेरिएबल में कौन-सी संख्याएँ समाती हैं? (सब चुनो)127 और −128 समाती हैं। 128 और −129 सीमा से बाहर हैं।

8. −6 को 8 बिट 2 के पूरक में लिखने के चरण सही क्रम में लगाओ।6 लिखो, सब बिट उलटो, 1 जोड़ो, फिर भार से जाँचो।

12. चिह्न वाले 8 बिट वेरिएबल में 100 है। उसमें 50 जोड़ा। कौन-सा मान जमा होगा?150 − 256 = −106 (बिट 10010110)।

13. अपने शब्दों में समझाओ कि 2 का पूरक कंप्यूटर को धन और ऋण संख्याओं के लिए एक ही जोड़ने वाला सर्किट क्यों इस्तेमाल करने देता है।

14. 8 बिट मिनी-फ्लोट (1 चिह्न, 3 घातांक बिट बायस 3, 4 मंटिसा बिट) में 0 101 0000 क्या है?1.0 × 2^2 = 4।

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

2 का पूरक सरल शब्दों में क्या है?

यह वह तरीका है जिससे कंप्यूटर ऋणात्मक पूर्ण संख्याएँ रखता है। सबसे बाएँ बिट का भार ऋणात्मक होता है, इसलिए 8 बिट में −5 है 11111011। −x पाने के लिए x के बिट उलटो और 1 जोड़ो।

इंटीजर ओवरफ़्लो क्या है?

जब गणना का परिणाम उपलब्ध बिट्स से बड़ा हो, तो ऊपर का बिट खो जाता है और मान घूम जाता है, जैसे चिह्न वाली बाइट में 127 + 1 बनता है −128।

कंप्यूटर फ्लोटिंग पॉइंट क्यों इस्तेमाल करते हैं?

इससे तय बिट्स में बहुत बड़ी और बहुत छोटी दोनों संख्याएँ चिह्न, घातांक और मंटिसा की मदद से रखी जा सकती हैं। कीमत यह है कि कई दशमलव सिर्फ़ पास के होते हैं, एकदम सही नहीं।

पहले यह पढ़ें

संख्या पद्धति और कूटन (Encoding)

इससे जुड़े पाठ

सभी कंप्यूटर विज्ञान पाठ