एक kibibyte, एक किलोबाइट और एक किलोबाइट के बीच क्या अंतर है?

Question

यह प्रश्न मुझे आकार मापने के इन तीन तरीकों के बीच के अंतर के बारे में सोच रहा था: एक kibibyte , एक किलोबाइट , और पारंपरिक किलोबाइट ।

मैं समझता हूं कि इन मापों के अलग-अलग उपयोग हैं (डेटा ट्रांसफर दर को बिट्स / सेकंड में मापा जाता है), लेकिन मुझे यकीन नहीं है कि मैं एमबी और एमबी और मिब के बीच अंतर बता सकता हूं।

इस उत्तर ( जोर मेरा ) से लिया गया, नीचे एक पुन: प्रस्तुत टिप्पणी है ।

C64 में 65536 बाइट्स RAM है। कन्वेंशन द्वारा, मेमोरी का आकार किबीबाइट्स में , किलोबाइट्स में डेटा ट्रांसफर रेट्स , और जो कुछ भी- ए -निर्माताओं-थिंक-ऑफ- बाइट्स में बड़े पैमाने पर स्टोरेज में निर्दिष्ट किया गया है । हार्डड्राइव लेबल पर T, G, M और k का उपयोग करते हैं, विंडोज Ti , Gi , Mi और ki में आकार की रिपोर्ट करता है । और वो 1.44MB फ्लॉप? वे न तो 1.44MB और न ही 1.44MiB हैं, वे 1.44 किलोकिबिबाइट हैं। वह 1440kiB या 1'474'560 बाइट्स है। - तीसरा

Comments

आने वाले वर्षों के लिए भ्रम की स्थिति होगी। कंप्यूटिंग के शुरुआती दिनों में, लोगों ने देखा कि कंप्यूटर के लिए 1000 के बजाय 1024 के कारकों के साथ काम करना स्पष्ट रूप से बहुत आसान था। इसलिए, दशकों तक, गैर-मानक 1024 के लिए मानक SI उपसर्ग "किलो" (और अभी भी बहुत बार होता है) का उपयोग किया गया था, और यह कंप्यूटिंग में एक वास्तविक मानक बन गया। सिवाय इसके कि कुछ लोग अभी भी SI 1000 का उपयोग करते हैं। गड़बड़ को सुलझाने के लिए, "किबी" को अब आधिकारिक तौर पर 1024 फैक्टर के रूप में परिभाषित किया गया है - लेकिन यह एक आसान संक्रमण के लिए बहुत देर हो चुकी है। "किलो" नियमित रूप से थोड़ी देर के लिए 1024 कारकों के लिए नियमित रूप से उपयोग / दुरुपयोग किया जाएगा।

— स्टीव 314

यह गोद लेने में मदद करता था अगर वे उपसर्ग नहीं चुनते थे जो कि ध्वनि को बेवकूफ बनाते हैं; यहां तक ​​कि एक आदेश के लिए किसी को "मानसिक रूप से महाप्राण" शब्द की आवश्यकता होती है। मैं बस "kibibyte", आदि का उपयोग नहीं करूंगा

— tgm1024

Answer 1

1 KiB (Kibibyte) = 1,024 B (Bytes) (2^10 Bytes)
1 kb  (Kilobit)  =   125 B (Bytes) (10^3 Bits ÷ (8 bits / byte) = 125 B)
1 kB  (Kilobyte) = 1,000 B (Bytes) (10^3 Bytes)

यह किसी भी एसआई उपसर्ग के साथ उसी तरह है; k(1x10 ³ ), M(1x10 ⁶ ), G(1x10 ⁹ ), इसलिए, विस्तार से:

1 MiB (Mebibyte) = 1,048,576 B (Bytes) (2^20 Bytes)
1 Mb  (Megabit)  =   125,000 B (Bytes) (10^6 Bits ÷ (8 bits / byte) = 125,000 B)
1 MB  (Megabyte) = 1,000,000 B (Bytes) (10^6 Bytes)

केवल वही जो थोड़ा अलग हैं वे आईईसी बाइनरी प्रीफिक्स (किबी / मीबी / गिबी आदि) हैं, क्योंकि वे बेस 2 में हैं, बेस 10 नहीं (उदाहरण के लिए सभी संख्याएं 10 के बजाय ^{कुछ के} बराबर 2 ^हैं )। मैं एसआई उपसर्गों का उपयोग करना पसंद करता हूं क्योंकि मुझे यह बहुत आसान लगता है। इसके अलावा, कनाडा (मेरा देश) मीट्रिक प्रणाली का उपयोग करता है, इसलिए मुझे उदाहरण के लिए 1kg = 1000g(या 1k anything = 1000 base things) उपयोग किया जाता है । इनमें से कोई भी गलत या सही नहीं है; बस सुनिश्चित करें कि आप जानते हैं कि आप किसका उपयोग कर रहे हैं और यह वास्तव में किसके बराबर है।

टिप्पणीकारों को खुश करने के लिए:

1 Byte (B) = 2 nibbles = 8 bits (b)

यही कारण है, अगर आपने कभी हेक्स संपादक में एक नज़र डाली है, तो सब कुछ दो हेक्साडेसिमल वर्णों में विभाजित है; प्रत्येक हेक्स चरित्र एक कुतरना का आकार है, और दो बाइट हैं। उदाहरण के लिए:

198 (decimal) = C6 (hex) = 11000110 (bits)

Comments

+1 उल्लेख करना कि बाइट में 8 बिट्स उपयोगी हो सकते हैं।

— पैराडायरायड

... और यह मत भूलो कि एक नायब चार बिट्स (या आधा बाइट) है!

— Linker3000

यह भी ज्ञात हो सकता है कि लोअरकेस "बी" को कभी-कभी "बाइट्स" को संक्षिप्त करने के लिए गलत तरीके से उपयोग किया जाता है। मैं देख रहा हूं कि मेगाबाइट के लिए एमबी और मेगाबिट के लिए एमबी में एब्रीविएशन में बस "बिट" का उपयोग होता है और "बी" से पूरी तरह से दूर रहें।

— जेम्स

उपसर्ग किलो का संक्षिप्त रूप k है, न कि K

— garyjohn

@Redandwhite नहींं, वे अपने स्टोरेज को मापने के लिए बेस 10 का उपयोग करते हैं, लेकिन हमारे कंप्यूटर बेस 2 का उपयोग करते हैं। यह बॉक्स में क्या छपा है और कंप्यूटर में क्या दिखाता है, के बीच विसंगति है। उदाहरण के लिए, 500GB (box) = 465.7GiB (computer)(और यह है कि वे आपको कैसे प्राप्त करते हैं)।

— '16

Answer 2

कुछ बुनियादी शब्द हैं जो सरल और समझने में आसान हैं:

* A bit      (b)   is the smallest unit of data comprised of just {0,1}
* 1 nibble   (-)   = 4 bits (cutesy term with limited usage; mostly bitfields)
* 1 byte     (B)   = 8 bits (you could also say 2 nibbles, but that’s rare)

बिट्स और बाइट्स के बीच परिवर्तित करने के लिए (किसी भी उपसर्ग के साथ), बस कई या आठ से विभाजित करें; अच्छा और सरल।

अब, चीजें थोड़ी अधिक जटिल हो जाती हैं क्योंकि डेटा के बड़े समूहों को मापने की दो प्रणालियाँ हैं: दशमलव और बाइनरी । वर्षों के लिए, कंप्यूटर प्रोग्रामर और इंजीनियरों ने दोनों के लिए एक ही शब्द का उपयोग किया, लेकिन भ्रम ने अंततः उपसर्गों के समुचित सेट को मानकीकृत करने के कुछ प्रयासों को रोक दिया।

प्रत्येक प्रणाली उपसर्गों के समान सेट का उपयोग करती है जिसे बिट्स या बाइट्स पर लागू किया जा सकता है। प्रत्येक उपसर्ग दोनों प्रणालियों में एक ही शुरू होता है, लेकिन बाइनरी वाले बच्चे की तरह बात करते हैं, उसके बाद।

दशमलव प्रणाली बेस -10 है जिसका उपयोग अधिकांश लोग करते हैं और उपयोग में सहज हैं क्योंकि हमारे पास 10 उंगलियां हैं। बाइनरी सिस्टम बेस -2 है, जिसका उपयोग करने के लिए अधिकांश कंप्यूटर उपयोग किए जाते हैं और आरामदायक होते हैं क्योंकि उनके पास दो वोल्टेज राज्य होते हैं।

दशमलव प्रणाली स्पष्ट है और अधिकांश लोगों के लिए उपयोग करना आसान है (यह हमारे सिर में गुणा करने के लिए काफी सरल है)। प्रत्येक उपसर्ग 1,000 से ऊपर जाता है (इसका कारण एक अलग मामला है)।

अधिकांश गैर-कंप्यूटर लोगों को उपयोग करने के लिए बाइनरी सिस्टम बहुत कठिन है, और यहां तक ​​कि प्रोग्रामर अक्सर अपने सिर में कई मनमाने ढंग से बड़ी संख्या में नहीं कर सकते हैं। फिर भी, यह दो के गुणक होने का एक साधारण मामला है। प्रत्येक उपसर्ग 1,024 तक बढ़ जाता है। एक "के" 1,024 है, क्योंकि यह 1,000 के दशमलव "के" के लिए दो की निकटतम शक्ति है (यह इस बिंदु पर सही हो सकता है, लेकिन प्रत्येक क्रमिक उपसर्ग के साथ अंतर तेजी से बढ़ता है)।

संख्या बिट्स और बाइट्स के लिए समान हैं जिनके पास एक ही उपसर्ग है।

* Decimal:
* 1 kilobyte (kB)  = 1,000 B  = 1,000^1 B           1,000 B
* 1 megabyte (MB)  = 1,000 KB = 1,000^2 B =     1,000,000 B
* 1 gigabyte (GB)  = 1,000 MB = 1,000^3 B = 1,000,000,000 B

* 1 kilobit  (kb)  = 1,000 b  = 1,000^1 b           1,000 b
* 1 megabit  (Mb)  = 1,000 Kb = 1,000^2 b =     1,000,000 b
* 1 gigabit  (Gb)  = 1,000 Mb = 1,000^3 b = 1,000,000,000 b

* …and so on, just like with normal Metric units meters, liters, etc.
* each successive prefix is the previous one multiplied by 1,000



* Binary:
* 1 kibibyte (KiB) = 1,024 B  = 1,024^1 B           1,024 B
* 1 mebibyte (MiB) = 1,024 KB = 1,024^2 B =     1,048,576 B
* 1 gibibyte (GiB) = 1,024 MB = 1,024^3 B = 1,073,741,824 B

* 1 kibibit  (Kib) = 1,024 b  = 1,024^1 b =         1,024 b
* 1 mebibit  (Mib) = 1,024 Kb = 1,024^2 b =     1,048,576 b
* 1 gibibit  (Gib) = 1,024 Mb = 1,024^3 b = 1,073,741,824 b

* …and so on, using similar prefixes as Metric, but with funny, ebi’s and ibi’s
* each successive prefix is the previous one multiplied by 1,024

ध्यान दें कि दशमलव और बाइनरी सिस्टम के बीच का अंतर छोटा शुरू होता है (1K पर, वे केवल 24 बाइट्स या 2.4% अलग हैं), लेकिन प्रत्येक स्तर के साथ बढ़ता है (1G पर, वे> 70MiB, या 6.9% अलग हैं)।

अंगूठे के एक सामान्य नियम के रूप में, हार्डवेयर डिवाइस दशमलव इकाइयों (चाहे बिट्स या बाइट्स) का उपयोग करते हैं, जबकि सॉफ्टवेयर बाइनरी (आमतौर पर बाइट्स) का उपयोग करता है।

यही कारण है कि कुछ निर्माता, विशेष रूप से mfgs ड्राइव करते हैं, जैसे दशमलव इकाइयों का उपयोग करना, क्योंकि यह ड्राइव के आकार को बड़ा बनाता है, फिर भी उपयोगकर्ता निराश हो जाते हैं जब वे पाते हैं कि जब वे विंडोज एट को देखते हैं तो उनकी अपेक्षा से कम होता है। अल। बाइनरी में आकार की रिपोर्ट करें। उदाहरण के लिए, 500GB = 476GiB, इसलिए ड्राइव को 500GB रखने के लिए बनाया गया है और इस तरह लेबल किया गया है, My Computer बाइनरी 476GiB (लेकिन "476GB") को प्रदर्शित करता है, इसलिए उपयोगकर्ता आश्चर्यचकित होते हैं कि अन्य 23GB कहां गया। (ड्राइव निर्माता अक्सर पैकेज में एक फुटनोट जोड़कर बताते हैं कि "स्वरूपित आकार कम है" जो भ्रामक है क्योंकि फाइल सिस्टम ओवरहेड दशमलव और बाइनरी इकाइयों के बीच अंतर की तुलना में कुछ भी नहीं है।)

नेटवर्किंग डिवाइस अक्सर ऐतिहासिक कारणों से बाइट्स के बजाय बिट्स का उपयोग करते हैं, और आईएसपी अक्सर बिट्स का उपयोग करना पसंद करते हैं क्योंकि यह उन कनेक्शनों की गति बनाता है जो वे ध्वनि की बड़ी पेशकश करते हैं: 12Mibps के बजाय केवल 1.5MiBps। वे अक्सर मिश्रण और बिट्स और बाइट्स और दशमलव और बाइनरी को भी मिलाते हैं। उदाहरण के लिए, आप सोच सकते हैं कि ISP "12MBps" लाइन को कॉल करता है, यह सोचकर कि आप 12MiBps प्राप्त कर रहे हैं, लेकिन वास्तव में केवल 1.43MiBps (12,000,000 / 8/1024/1024) प्राप्त करते हैं।

Comments

@endolith, सच नहीं है। सबसे पहले, वास्तव में हैं, या कम से कम अतीत में थे, कुछ ड्राइव निर्माता जो बाइनरी यूनिट का उपयोग करते हैं। दूसरा, आप बिंदु से चूक गए। यदि वे चाहते थे, तो वे ड्राइव पर 73,400,320 डाल सकते थे जो वास्तव में 66 के बजाय 70M (i) बी होगा। वे 70,000,000 का उपयोग करते हैं क्योंकि यह उस का उपयोग करने के लिए सस्ता है और अभी भी इसे "70MB" कहते हैं। यह सरल कोनों को काटने वाला है और कई निर्माता इसे करते हैं। भोजन को देखो; 500G के बजाय, वे 454G डालेंगे क्योंकि यह 1LB के बराबर है। इससे भी बदतर, 454G के बजाय, वे 450G डालेंगे और लापता 4G को गोलाई पर दोष देंगे। यह कोई साजिश नहीं है, यह लागत में कटौती है।

— Synetech

कृपया बाइनरी इकाइयों का उपयोग करके हार्ड ड्राइव निर्माताओं के कुछ उदाहरण प्रदान करें।

— एंडोलिथ

@endolith, यह एक इतिहास साइट नहीं है। शायद जब मैं कुछ वसंत-सफाई करता हूं और कुछ पुराने ड्राइव को खोदता हूं, तो मैं एक फोटो या कुछ पोस्ट करूंगा। अन्यथा, आप एक कंप्यूटर-इतिहास संग्रहालय या मॉम-एंड-पॉप कंप्यूटर शॉप पर जा सकते हैं और कुछ पुराने हार्ड-ड्राइव पा सकते हैं यदि यह आपके लिए महत्वपूर्ण है। इन दिनों, अधिकांश mfgs जानबूझकर ऐसे लेबल का उपयोग करते हैं जो चीजों को बड़ा बनाते हैं। जैसा कि मैंने कहा, वे सकता है यह 73,400,320 एक 70MB ड्राइव बनाने के लिए अगर वे चाहते थे बाइट्स बनाने, लेकिन क्यों परेशान जब वे कर सकते हैं सस्ते बाहर और अभी भी तकनीकी रूप से यह 70MB कहते हैं? फिर, यह एक साजिश नहीं है, यह आम विपणन धोखा है।

— 18

मैंने पहले से ही बिटस्वर्स अभिलेखागार के माध्यम से देखा है, और मुझे लगता है कि सभी उदाहरण दशमलव हैं। निर्माताओं को धोखा देने के लिए बाइनरी से दशमलव तक स्विच करने वाले ड्राइव के मिथक यह पागल है। वे विपणन विभागों द्वारा नहीं लिखे गए थे, लेकिन इंजीनियरों द्वारा मानक इकाइयों का उपयोग करके जो इंजीनियर उपयोग करते हैं। यह तर्कसंगत है और एक 70,000,000 बाइट आईबीएम 3340 ड्राइव "70 एमबी" कॉल करने के लिए समझदार है। यही कारण है कि '' मेगा- '' का हमेशा मतलब होता है और यही उपयोगकर्ता उम्मीद करते हैं। कुछ स्थानों पर इसे "66 एमबी" और अन्य स्थानों पर "68,359 KB", जैसे कि माइक्रोसॉफ्ट विंडोज करता है, पागल है।

— एंडोलिथ

@endolith, किसी ने भी यह नहीं कहा कि वे दशमलव को धोखा देने के लिए स्विच करते हैं, सिर्फ इसलिए कि वे उन्हें इस तरह से उद्देश्य के लिए विपणन करते हैं, हालांकि वे भ्रम के बारे में जानते हैं और ड्राइव को केवल 70,000,000 के बजाय 73,400,320 बाइट्स बना सकते हैं जो कंप्यूटर में एक गोल संख्या नहीं है। इसके बारे में आपके कथन के अनुसार "हमेशा" का अर्थ है कि, बाइनरी इकाइयों के उपयोग में आने के बारे में पहले से ही यहाँ एक धागा है और यह बहुत समय पहले था, निश्चित रूप से कंप्यूटर से पहले उपभोक्ता उत्पाद बन गए थे।

— Synetech

Answer 3

कुछ जवाब सटीक नहीं हैं।

आइए पहले कुछ नोट्स बनाएं:

उपसर्ग "किलो" का अर्थ 1 000 है। किसी भी चीज़ के लिए "किलो" का उपसर्ग करना 1 000 है। वही "मेगा" या मिलियन, "गीगा" या बिलियन, "तेरा" या ट्रिलियन, और इसी तरह के लिए सच है।

केवल 1 000 होने के बजाय कारण 1 024 मौजूद है क्योंकि बाइनरी अंकगणितीय काम करने का तरीका है। बाइनरी, जैसा कि इसके नाम से पता चलता है, एक आधार 2 प्रणाली है (इसमें 2 अंक हैं: 0, 1)। यह केवल दो अंकों के साथ अंकगणितीय प्रदर्शन कर सकता है, आधार 10 प्रणाली के विपरीत जो हम दैनिक आधार पर उपयोग करते हैं (0, 1, 2 ... 9), जिसमें दस अंक हैं।

बाइनरी अंकगणित का उपयोग करके नंबर 1 000 ( किलो ) तक पहुंचने के लिए , एक अस्थायी बिंदु गणना करना आवश्यक है। इसका मतलब यह है कि एक बाइनरी अंक को प्रत्येक ऑपरेशन तक ले जाना चाहिए जब तक कि 1 000 तक न पहुंच जाए। आधार 10 प्रणाली में, 1 000 = 10 ³ (आप हमेशा 10 को आधार 10 में एक शक्ति बढ़ाते हैं), कंप्यूटर के लिए कोई "अवशेष" के साथ प्रदर्शन करने के लिए एक बहुत ही आसान और त्वरित गणना, लेकिन आधार 2 प्रणाली में, यह 1 000 प्राप्त करने के लिए किसी भी धनात्मक पूर्णांक के लिए 2 (आप हमेशा 2 को आधार 2 में एक शक्ति बढ़ाएँ) संभव नहीं है। फ़्लोटिंग पॉइंट ऑपरेशन या लंबा जोड़ का उपयोग किया जाना चाहिए, और पूर्णांक गणना की तुलना में निष्पादित करने में अधिक समय लगता है 2 ¹⁰ = 1024।

आपने देखा होगा कि 2 ¹⁰ = 1 024 लुभावने रूप से 1 000 के करीब है और 1 024 से 1 महत्वपूर्ण आंकड़ा 1 000 (एक बहुत अच्छा सन्निकटन) है, और जब सीपीयू की गति एक पुराने कुत्ते के रूप में धीमी थी, और स्मृति बहुत सीमित थी , यह एक बहुत ही सभ्य सन्निकटन था और काम करने के लिए बहुत आसान था, न कि तेजी से निष्पादित करने के लिए।

यह इस कारण से है कि "किलो", "मेगा", "गीगा" आदि शब्दों के साथ, उपसर्ग गैर-सटीक आंकड़े (1 024, 2 048, 4 096, और इसी तरह) के साथ चारों ओर अटक जाते हैं। वे कभी भी सटीक संख्या के लिए नहीं थे, वे आधार संख्या के द्विआधारी सन्निकटन थे। वे केवल शब्दजाल के रूप में उत्पन्न हुए, जिसका उपयोग "टेक" लोग करते थे।

मामलों को और अधिक जटिल बनाने के लिए, जेडईडीईसी ने सेमीकंडक्टर मेमोरी सर्किट में उपयोग की जाने वाली इकाइयों के लिए अपने स्वयं के मानक बनाए हैं। आइए कुछ JEDEC इकाइयों की तुलना SI (मानक अंतरराष्ट्रीय) इकाइयों से करें:

Kb = किलोबिट (JEDEC, 1 024 बिट्स। अपर केस 'K' और लोअर केस 'b')
केबी = किलोहिट (SI, 1 000 बिट्स नोट करें। निचले केस 'k' और अपर केस 'B' पर ध्यान दें।

b = बिट (JEDEC, निम्न केस 'b' पर ध्यान दें)
b = ??? (SI शब्द 'बिट' को परिभाषित नहीं करता है इसलिए इसका उपयोग मनमाना हो सकता है)

बी = बाइट (जेडईसीईसी, 8 बिट्स। ऊपरी मामले 'बी' पर ध्यान दें)
बी = ???? (एसआई शब्द "बाइट" को परिभाषित नहीं करता है और "बी" का उपयोग "बेल" के लिए किया जाता है [जैसा कि डेसीबल में)

KB = किलोबाइट (JEDEC, 1 024 बाइट्स। ऊपरी केस 'K' और 'B')
केबी = किलोबाइट (SI, 1 000 बाइट्स पर ध्यान दें। निचले केस 'k' और लोअर केस 'B' के उपयोग पर ध्यान दें)।

मुद्दा यह है कि, विभिन्न स्थान अलग-अलग परिभाषाओं के साथ अलग-अलग उपसर्गों का उपयोग करते हैं। कोई कठिन और तेज़ नियम नहीं है जिसके अनुसार आपको उपयोग करना चाहिए, लेकिन आप जो उपयोग करते हैं उसके अनुरूप होना चाहिए।

डाउन वोटिंग के कारण, मुझे स्पष्ट करने की अनुमति दें कि आप किसी भी सकारात्मक पूर्णांक को बढ़ाकर बाइनरी में 1 000 क्यों नहीं बना सकते हैं।

बायनरी सिस्टम:

+----------------------------------------------------------------------------------+
| 1 024ths | 512ths | 256ths | 128ths | 64ths | 32nds | 16ths | 8ths | 4s | 2s | 0 |
+-----------------------------------------------------------------------------------

ध्यान दें कि बाइनरी सिस्टम में, कॉलम हर बार दोगुना होता है। यह आधार 10 प्रणाली के विपरीत है जो हर बार 10 से बढ़ता है:

+--------------------------------------------------------------------------+
| 1 000 000ths | 100 000ths | 10 000ths | 1 000ths | 100ths | 10s | 1s | 0 |
+--------------------------------------------------------------------------+

बाइनरी में पहले 10 शक्तियां (आधार 2) हैं:

2 ⁰ = 1
2 ¹ = 2
2 ² = 4
2 ³ = 8
2 ⁴ = 16
2 ⁵ = 32
2 ⁶ = 64
2 ⁷ = 128
2 ⁸ = 256
2 ⁹ = 512
2 ¹⁰ = 1 024

जैसा कि आप देख सकते हैं, 1 000 तक पहुंचने के लिए किसी भी सकारात्मक पूर्णांक के लिए बाइनरी 2 को उठाना संभव नहीं है।

Comments

मेरा मानना ​​है कि जब नंबर 1000 को फ्लोटिंग-पॉइंट अंकगणित की आवश्यकता होती है, तो आप गलत हैं। आप किसी भी प्रकार की संख्या प्रणाली का उपयोग करके किसी भी प्राकृतिक संख्या का प्रतिनिधित्व कर सकते हैं। दरअसल, 1000 के बाइनरी बराबर 1111101000 है ।

— डॉकटोरो रीचर्ड

डॉकटोरो, कृपया याद रखें कि हम बाइनरी सिस्टम या बेस 2 में काम कर रहे हैं, इसलिए आप वास्तव में वही हैं जो गलत है। द्विआधारी (आधार 2) में 2 की पहली 10 शक्तियाँ इस प्रकार हैं: 2 ^ 0 = 1. 2 ^ 1 = 2. 2 ^ 3 = 4. 2 ^ 4 = 8. 2 ^ 5 = 16. 2 ^ 6 = 64 । 2 ^ 7 = 128. 2 ^ 8 = 256. 2 ^ 9 = 512. 2 ^ 10 = 1024. ध्यान दें कि उत्तर घातीय है, हर बार जब आप घातांक को बढ़ाते हैं तो यह दोगुना हो जाता है 1. तो आप देखते हैं, यह नहीं है 1 000 बनाने के लिए किसी भी सकारात्मक पूर्णांक के लिए एक बाइनरी 2 (एक बायनरी 2 ... एक बेस दस 2 नहीं) को उठाना संभव है। मैं सभी को एक समान वोट देने की सराहना करता हूं।

— user3005790

यह एक बिट और बाइट के बीच अलग-अलग व्याख्या नहीं करता है। वास्तव में "हार्ड फास्ट नियम" है 1 Kb एक हजार बिट्स है 1KB एक हजार बाइट्स है। एक बहुत बड़ा अंतर है। 8 Kb 1 KB है।

— रामहाउंड

हालाँकि यह कथन सही है, फिर भी आपको किसी भी प्रकार के फ्लोटिंग पॉइंट अंकगणित को करने की आवश्यकता नहीं है। आप 2 की शक्तियों को समझते हैं, इसलिए आप यह भी समझ सकते हैं कि 1111101000 = 2 ^ 9 + 2 ^ 8 + 2 ^ 7 + 2 ^ 6 + 2 ^ 5 + 2 ^ 3 = 1000।

— डॉकटोरो रीचर्ड

मुझे विश्वास नहीं है कि "वे कभी भी सटीक संख्या के लिए नहीं थे, वे आधार संख्या के द्विआधारी सन्निकटन थे" सच है; मुझे लगता है कि यह सिर्फ हार्डवेयर का एक परिणाम है जो (और) स्टोर करने वालों और शून्य तक सीमित है, और बाइनरी रजिस्टरों का उपयोग करते हुए हार्डवेयर को संबोधित करता है। दोनों का आधार 2 है; मैं लगभग 10 गणनाओं से संबंधित नहीं हूं, मुझे लगता है। इसके अलावा, मैं उस बिंदु को देखने में विफल हूं जो आप गणनाओं के बारे में बना रहे हैं। यह ऐसा नहीं है कि कंप्यूटर आउटपुट 1024 दिखाएगा जहां वास्तव में 1000 दिखाने का इरादा था, या 1000 दिखाएगा जब आंतरिक रूप से यह 1024 होगा। आप किस गणना की बात कर रहे हैं?

— अर्जन