कंप्यूटर शून्य से क्यों गिनते हैं?

Question

कंप्यूटर पारंपरिक रूप से शून्य से शुरू होने वाले संख्यात्मक मानों को दर्शाता है। उदाहरण के लिए, C- आधारित प्रोग्रामिंग भाषाओं में सरणियाँ इंडेक्स शून्य से शुरू होती हैं।

इसके लिए कौन से ऐतिहासिक कारण मौजूद हैं, और शून्य से गिनने के लिए कौन से व्यावहारिक फायदे हैं?

नोट: यह प्रश्न केवल व्याख्याओं के लिए नहीं बल्कि अच्छी तरह से समझाए गए तकनीकी उत्तरों के लिए कहता है, और इसका उद्देश्य केवल प्रोग्रामिंग के बजाय सामान्य रूप से कंप्यूटर को कवर करना है। यह सवाल प्रोग्रामर के सवाल पर फैलता है "क्यों संरचनाएं / सरणियाँ शून्य-आधारित हैं?" ।

Comments

Djkstra राय

— बकुरीउ

1-मूल सरणियों का उपयोग करने वाले कंप्यूटर भाषाओं के कुछ से अधिक उदाहरण हैं।

— डैनियल आर हिक्स

मनुष्य 0 से क्यों नहीं गिनते?

— शीर्षकहीन

वाह, वाह, शून्य से कोई मायने नहीं रखता, हम शून्य से सूचकांक करते हैं। कोई भी "शून्य" तत्व नहीं कहता है। हम सूचकांक में "प्रथम" तत्व कहते हैं । सूचकांक के बारे में सोचें कि पहली स्थिति से कोई तत्व कितना दूर है। ठीक है, पहला तत्व पहली स्थिति में है, इसलिए यह बिल्कुल भी ऑफसेट नहीं है, इसलिए इसका सूचकांक 0. है। इससे पहले एक तत्व के रूप में दूसरा तत्व है, इसलिए यह 1 तत्व को ऑफसेट करता है और सूचकांक 1 पर है

— mowwwalker

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

— पीटर ओल्सन

Answer 1

0 से सरणियों की गणना प्रत्येक तत्व के मेमोरी एड्रेस की गणना को सरल बनाती है।

यदि किसी सरणी को स्मृति में दिए गए स्थान पर संग्रहीत किया जाता है (इसे पता कहा जाता है) तो प्रत्येक तत्व की स्थिति की गणना की जा सकती है

element(n) = address + n * size_of_the_element

यदि आप पहले तत्व को पहला मानते हैं, तो गणना बन जाती है

element(n) = address + (n-1) * size_of_the_element

बहुत बड़ा अंतर नहीं है, लेकिन यह प्रत्येक पहुंच के लिए एक अनावश्यक घटाव जोड़ता है।

संपादित करें

• एक ऑफसेट के रूप में सरणी सूचकांक का उपयोग एक आवश्यकता नहीं है, बल्कि सिर्फ एक आदत है। पहले तत्व की ऑफसेट सिस्टम द्वारा छिपाया जा सकता है और तत्व को आवंटित और संदर्भित करते समय ध्यान में रखा जाता है।

• दिज्क्स्ट्रा ने एक पेपर प्रकाशित किया "नंबरिंग शून्य पर क्यों शुरू होनी चाहिए" ( पीडीएफ ) जहां वह बताते हैं कि 0 से शुरू करना बेहतर विकल्प क्यों है। शून्य पर शुरू होने से श्रेणियों का बेहतर प्रतिनिधित्व होता है।

Comments

सही उत्तर के लिए +1। ध्यान दें कि प्रयुक्त भाषा का 0-आधारित अनुक्रमण केवल (बहुत सामान्य) सम्मेलन है; यह सार्वभौमिक नहीं है। उदाहरण के लिए, लुआ 1-आधारित अनुक्रमण का उपयोग करता है । "अनावश्यक घटाव" पुराने दिनों में 0-आधारित अनुक्रमण के पीछे तर्क हो सकता है, लेकिन अब ज्यादातर भाषाएं इसका उपयोग केवल इसलिए करती हैं क्योंकि यह सभी के लिए पहले से ही उपयोग किया जाता है (मोटे तौर पर सी के लिए धन्यवाद) , और इसे बदलने के लिए कोई मजबूर कारण नहीं है सम्मेलन।

— ब्लूराजा - डैनी पफ्लुगुएफ्ट

इसका कोई अर्थ नहीं निकलता। प्रत्येक तत्व की स्थिति की गणना हमेशा की जा सकती है जब address + n * size_of_elementतक कि "पता" शून्य तत्व का पता है। यह पूरी तरह से काम करता है कि शून्य तत्व तत्व के तत्व के रूप में मौजूद है या नहीं। सवाल यह है कि शून्य तत्व क्यों मौजूद है, न कि क्यों हम पते को संभवतः (संभवतः उल्लेखनीय) शून्य तत्व के रूप में संग्रहीत करते हैं। (जो यह जवाब देता है।)

— डेविड श्वार्ट्ज

@DavidSchwartz चलो सी के रूप में एक पुरानी भाषा लेते हैं। स्मृति को आवंटित करने पर आपको एक पता मिलता है जहां मेमोरी शुरू होती है। यदि एक कंपाइलर कुछ देखता है जैसे v[n]उसे अभिव्यक्ति के पते की गणना करना है। यदि अनुक्रमित 0 शुरू करते हैं तो गणना v + x * आकार है। यदि 1 पर अभिकलन v + (x-1) * आकार है। जैसे, v [1] v + (१-१) * के आकार के अनुरूप होगा जो कि v है।

— माटेओ

@ डेविड: सी में (वह भाषा जो वास्तव में 0-आधारित अनुक्रमण को लोकप्रिय बनाती है) , एरे और पॉइंटर्स काफी हद तक परस्पर विनिमय करने योग्य होते हैं, इसलिए यह कई कारणों से महत्वपूर्ण है जो *arrayवास्तव में पहले तत्व को संदर्भित करता है। एक उदाहरण: यदि हमारे पास पहले तत्व से पहलेarray मेमोरी लोकेशन है , तो एक अलग प्रकार की एक सरणी के लिए कास्टिंग करना परेशानी की तरह होगा। एस के एक सरणी में दूसरे बाइट की स्थिति शब्द-आकार पर निर्भर हो जाएगी; एक 32-बिट मशीन पर, यह होगा !! int((char*)intArray + 5)

— ब्लूराजा - डैनी पफ्लुगुफ्ट

नहीं, यह इस बात का मुद्दा नहीं है कि सरणी में शून्य तत्व है या नहीं। क्योंकि, आप देखते हैं, स्केलिंग भी है। अगर मेरे पास 8 बाइट ऑब्जेक्ट हैं, और मैं बाइट सरणी के साथ ओवरले करता हूं, तो ऑब्जेक्ट का बाइट इंडेक्स क्या है [42]? यह सरल क्यों है: 42 * 8. 1 आधारित के साथ समस्या यह है कि 1 की यह ऑफसेट 1 बाइट है जब मैं बाइट सरणी को देखता हूं, और यह 8 बाइट्स होता है जब मैं 8-बाइट-यूनिट सरणी को देखता हूं।

— काज

Answer 2

जबकि नीचे दिए गए सिद्धांत दशमलव के साथ-साथ किसी अन्य आधार पर लागू होते हैं, कंप्यूटर में 0 से गणना को कंप्यूटर में उपयोग किए जाने वाले संख्याओं का प्रतिनिधित्व करने के निश्चित-अंक बाइनरी सिस्टम से स्वाभाविक रूप से आसानी से समझा जा सकता है। यदि आपके पास 8 बिट्स हैं, तो 1s और 0s के 256 संभावित संयोजन हैं जिन्हें व्यक्त किया जा सकता है। आप इन 8-बिट का उपयोग 1-256 संख्याओं को व्यक्त करने के लिए कर सकते हैं, लेकिन यह 0 को छोड़ देगा जो गणित में अपने आप में एक संख्या के रूप में उपयोगी है, इसलिए इनका उपयोग संख्याओं को 0-255 व्यक्त करने के लिए किया जाता है।

यह पहले से ही 0 (सभी 0 के बाइनरी प्रतिनिधित्व में) से 255 तक (सभी 1 के 8-बिट संख्या में) से शुरू होने वाले प्राकृतिक आदेश की एक मिसाल कायम करता है। संख्याओं का प्रतिनिधित्व करने की प्रणाली को ध्यान में रखते हुए, 0 से शुरू करना मायने रखता है क्योंकि 0 प्रणाली में "पहली" संख्या है, इसलिए 1 "दूसरी" संख्या है, और इसके आगे।

कंप्यूटरों में 0 से शुरू होने का एक अतिरिक्त कारण ऑफ़सेट की अवधारणा के कारण बहुत सुविधाजनक है। एक ऑफसेट एक संख्या है जो मेमोरी या हार्ड डिस्क या किसी अन्य "पता योग्य" माध्यम से किसी स्थान से दूरी का प्रतिनिधित्व करती है। कंप्यूटर में, व्यावहारिक रूप से सभी डेटा को रैखिक रूप से संग्रहीत किया जाता है, जिसका अर्थ है कि डेटा के लिए एक आदेश है, एक पहली बाइट, दूसरा बाइट, आदि। यह एक ऑफसेट के माध्यम से डेटा के "क्षेत्रों" के स्थान को व्यक्त करने के लिए सुविधाजनक है। डेटा के एक ब्लॉक में पहली बाइट कौन सी है? यह ऑफसेट '0' पर है, जिसका अर्थ है कि यह डेटा के ब्लॉक में पहली बाइट के बाद 0 बाइट्स पाया जाता है। हालांकि यह संभव है कि "1" पहले बाइट को नामित करे, यह कई कारणों से डेटा के प्रतिनिधित्व में जटिलताएं पैदा करता है:

• डेटा को संबोधित करने के लिए उपयोग किए जाने से 0 के बहिष्करण द्वारा, आप उन चीजों की संख्या को कम कर सकते हैं जिन्हें आप 8-बिट नंबर से एक के साथ संबोधित कर सकते हैं।
• ऑफसेट की गणना करने के लिए, जो डेटा एक्सेस के हार्डवेयर स्तर पर आवश्यक है, कुछ बिंदु पर आपको नंबरिंग से एक को घटाना होगा, जो एक जटिलता का परिचय देता है।
• डेटा के एक ब्लॉक की ओर संकेत हमेशा पहले ब्लॉक को इंगित करता है, इसलिए जब आप 0. से शुरू करते हैं तो अंकगणितीय सीधा होता है। (जब डेटा के पहले क्लस्टर के पहले ब्लॉक में 1 बाइट 0 + 0 + 0 होता है, जब आप 0 से शुरू करते हैं। , यह 1 + 1 + 1 - 1 -1 है जब आप 1 से शुरू करते हैं।) इस के लिए अंकगणित जब आप 1 से शुरू करते हैं तो इस तरह के उदाहरण के रूप में नेस्टेड डेटस्ट्रक्टर्स भ्रामक हो सकते हैं।

Comments

बाइनरी प्रतिनिधित्व से कोई लेना-देना नहीं है। दोनों बाइनरी और दशमलव संख्या 0. से शुरू होती हैं

— Matteo

यदि आप 0 से गिनना शुरू करते हैं, तो आप उन पतों की संख्या को कम नहीं कर सकते हैं जो आप (सिद्धांत रूप में) 1 से 257 तक जा सकते हैं।

— माटेओ

@Matteo एक भी बाइट में आप नहीं कर सकते हैं

— OrangeDog

@Dougvj जीरो-आधारित काउंटिंग का बाइनरी से कोई लेना- देना नहीं है। आप जो बिंदु बना रहे हैं, वह एक निश्चित अंकों के प्रतिनिधित्व में प्रत्येक संख्या का उपयोग करने के बारे में है, जो एक चिंता का विषय है कि आप आधार 2, आधार 10, या आधार 23517 का उपयोग कर रहे हैं या नहीं।

— पीटर ओल्सन

-1 इसका बाइनरी प्रतिनिधित्व से कोई लेना-देना नहीं है।

— ब्लूराजा - डैनी पफ्लुघोफ्ट

Answer 3

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

कंप्यूटर और मानव (किसी भी) गिनती तकनीकों के बीच इस कथित असंगतता के बारे में कुछ भी भ्रमित नहीं है। आइए प्रश्न का विघटन करें।

कंप्यूटर शून्य से क्यों गिनते हैं?

• उनकी गिनती शून्य से नहीं होती है

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

• सूचकांक (स्थिति का सूचक, मिलान) शून्य से शुरू होता है। एक सरणी में तत्वों की गिनती जहां सूचकांक शून्य पर एक तत्व है, वह एक है

शून्य किसी चीज़ के शून्य या किसी पैमाने के मध्य बिंदु का प्रतिनिधित्व करने के लिए व्यावहारिक है। यह कुछ भी गिनने के लिए व्यावहारिक नहीं है क्योंकि यह शून्य की परिभाषा से असंभव है।

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

तो हाँ, कंप्यूटर शून्य से टैली करते हैं, लेकिन वे एक से गिनती करते हैं। दो शब्द अलग अर्थ धारण करते हैं।

तावीज़ [ताल-एई]

संज्ञा

1. एक खाता या रेकिंग; डेबिट और क्रेडिट का रिकॉर्ड, गेम के स्कोर, या पसंद का।
2. कुछ भी जिस पर एक अंक या खाता रखा जाता है ..
3. दर्ज की गई वस्तुओं की एक संख्या या समूह।

गिनती [kount]

क्रिया (वस्तु के साथ प्रयुक्त)

1. कुल संख्या निर्धारित करने के लिए एक-एक करके (एक संग्रह के अलग-अलग इकाइयों या समूहों) की जांच करने के लिए; जोड़ें; enumerate: उन्होंने अपने टिकट गिने और पाया कि उनके पास दस थे।
2. ऊपर उठना; गणना; गणना।
3. संख्याओं को सूचीबद्ध या नाम देने के लिए: अपनी आँखें बंद करें और दस गिनें।

(Dictionary.com)

---

व्यावहारिक कारणों को डगविज द्वारा पर्याप्त रूप से वर्णित किया गया है, मेरे पास वहां जोड़ने के लिए कुछ भी नहीं है। यदि केवल हम एक ऐतिहासिक विवरण देने के लिए (60 के दशक से) सीएस प्रोफेसर हो सकते हैं ...

Comments

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

— डैनियल आर हिक्स

मैं यहां अवधारणाओं और तर्क की परिभाषाओं पर बात कर रहा हूं, न कि यह कि कंप्यूटर कैसे काम करते हैं। मुझे थोड़ा बहुत पता है कि कंप्यूटर कुछ भी शुरू करता है क्योंकि मैंने सीएस पाठ्यक्रम लिया है।

— урослав Рахматуллин

पूरी तरह से पांडित्यपूर्ण होने के लिए, आप एक संज्ञा के साथ एक क्रिया की तुलना कर रहे हैं। मुझे लगता है कि "टैली" और "काउंट" वास्तव में पर्यायवाची हैं, और दोनों को एक क्रिया या संज्ञा के रूप में इस्तेमाल किया जा सकता है।

— ब्रायन

@ ब्रायन एक निष्पक्ष अवलोकन और मेरा उद्देश्य (एक पांडित्यपूर्ण तरीके से) वर्णन करना है कि भ्रम गलत शब्दों की शर्तों से उपजा है। "प्रथम तत्व" और "स्थिति 0 पर तत्व" के बीच वास्तव में कोई अंतर नहीं है। वे दोनों तत्व एक हैं। पहले , नहीं " zeroth "। शून्य से गिनती जैसी कोई चीज नहीं है । गणना एक परिभाषा से शुरू होती है , जबकि संबोधित एक-> 1, बी-> 2 हो सकता है। c-> 3 या 0-> 1, 1-> 2, 2-> 3। "शून्य से गिनती" का सबसे आम उदाहरण मिडिल स्कूल की गणित की किताबों में {x₀, x₂, x the} के रूप में पाया जा सकता है - लेकिन सबस्क्रिप्ट एक इंडेक्स है ।

यह सिर्फ इतना है कि डिजाइनर वास्तव में वर्तमान योजना पर बसने से पहले काफी घूम चुके थे। क्या लगता है "स्पष्ट" अब नहीं था। और संभवत: कुछ अलग योजना को चुना जा सकता था और अब हमारे पास इससे अधिक "स्पष्ट" प्रतीत होगा।

— डैनियल आर हिक्स

Answer 4

मुझे लगता है कि इससे पहले " prof.dr. Edsger W. Dijkstra " द्वारा कवर किया गया है - 11 अगस्त 1982 के पत्र में बरोज़ रिसर्च फेलो: cf EWD831

शीर्षक: शून्य पर संख्या क्यों शुरू होनी चाहिए । "क्या एक सम्मेलन को दूसरे के लिए पसंद करने के कारण हैं? हाँ, वहाँ हैं ...।"

यह भी ध्यान दें कि डीजेकस्ट्रा 1968 तक देर से ALGOL 68 डिज़ाइन टीम में था। अल्गोलोल 68 0, 1 या किसी भी नंबर से अनुमति देता है जो प्रोग्रामर एल्गोरिथम के लिए उपयुक्त है। cf ( "द मेकिंग ऑफ अल्गोल 68" कहता है "क्या आप त्रिकोणीय सरणियों को परिभाषित कर सकते हैं?"

विशेष रूप से, Algol68 में, जब arrays (& matrices) कटा हुआ होता है, तो उन्हें @ 1 सूचकांक मिलता है, इसलिए [1: ...] सरणियों के प्रति पूर्वाग्रह होता है। लेकिन "1 ^सेंट " लोअर बाउंड पर शुरू करने के लिए ले जाया जा सकता "0 ^वें " को निर्दिष्ट "@ 0" द्वारा स्थिति, जैसे वेक्टर x [4: 99 @ 2], मैट्रिक्स y [4: 99 @ 1,4: 99 @ 0]। इसी प्रकार वहाँ एक डिफ़ॉल्ट / के पूर्वाग्रह है से में 1 करते ~ आयुध डिपो छोरों (जब तक " से 0" स्पष्ट रूप से कहा गया है), और 1 से पूर्णांक के लिए मामले मैं में ~, ~, ~ esac और $ ग (~, ~, ~ ) $ पसंद खंड।

ऐसा लगता है कि मार्च 1968 के ड्राफ्ट रिपोर्ट ( MR93 ) और उनके आग्रह के बारे में दीजकस्ट्रा की टिप्पणी से स्पष्ट है कि पूर्व- लौ लौ युद्ध क्या है : "ऐसे लेखन हैं जो प्यारा हैं, हालांकि कुछ भी नहीं हैं, और अन्य लेखन भी हैं जो अत्यंत व्याकरणिक हैं, लेकिन हैं घृणित। यह एक ऐसी चीज है जिसे मैं सतही व्यक्तियों को नहीं समझा सकता। " EWD230

अल्गोल 68 फाइनल रिपोर्ट (एफआर) 20 दिसंबर 1968 को सामने आई थी, जब इसे म्यूनिख मीटिंग में नाराजगी जताई गई थी और फिर वर्किंग ग्रुप द्वारा अपनाया गया था। इसके बाद प्रकाशन के लिए यूनेस्को की IFIP की महासभा द्वारा अनुमोदित रिपोर्ट ।

23 दिसंबर (?) के आसपास 1968 डिज्कस्ट्रा, डंकन, Garwick, होरे , रंदेल्ल , Seegmuller, Turski, Woodger और Garwick पर हस्ताक्षर किए AB31.1.1.1 "अल्पसंख्यक रिपोर्ट", पृष्ठ 7 (प्रकाशित 1970)।

Answer 5

किसी और के द्वारा लाया गया उपमा एक बहुत ही व्यावहारिक चित्रण के लिए उधार देता है:

"आपका घर निकटतम गैस स्टेशन से कितनी दूर है?"

"1 मील।"

"आप गैस स्टेशन पर रहते हैं?"

"नहीं, अगर मैं गैस स्टेशन पर रहता तो यह 0 मील होता"

"आप एक के बजाय शून्य से क्यों गिन रहे हैं?"

एक और अच्छा उदाहरण जन्मदिन होगा - हम यह नहीं कहते कि किसी का जन्म एक वर्ष पुराना है, हम कहते हैं कि यह एक साल बाद है।

हम कहते हैं कि लीप वर्ष या अमेरिकी राष्ट्रपति चुनाव हर चार साल में होते हैं, भले ही आप एक से गिनती करें: 2000 , 2001, 2002, 2003, 2004 पांच साल। (संयोग से, रोमियों ने कुछ समय के लिए इसे खराब कर दिया था, और लीप वर्ष भी एक साथ बंद हो गए थे)

मेरा कहना है, हम वास्तविक दुनिया में हर समय शून्य से "गणना" करते हैं - "कितने पदों के बाद [सरणी की शुरुआत] वह तत्व है जो आप चाहते हैं" बस ऐसा होता है कि आप जिस सवाल का जवाब दे रहे हैं वह एक गिनती से शून्य है। कई कंप्यूटर प्रोग्राम में। आप यह नहीं कहेंगे कि पहला तत्व शुरू होने के बाद एक स्थिति है , आप करेंगे? यह है शुरू।

Comments

चुनाव से संबंधित आपका गणित एक वर्ष के लिए बंद हो जाता है। आपके उदाहरण में 5 वर्ष की अवधि के भीतर 2 चुनावी वर्ष शामिल हैं; सही चित्रण यह होगा कि एक चुनाव से अगले वर्ष तक 4 वर्ष गुजरते हैं, अर्थात 2000 -> 2001 (एक वर्ष का अंतराल), 2001 -> 2002, 2002 -> 2003, 2003 -> 2004.

— जिमी

@ जिमी यही मेरी बात थी - अगर लोग "एक से गिना" इस मायने में कि वे कंप्यूटर चाहते हैं, तो वे 2000 को शून्य के बजाय एक के रूप में गिनेंगे। यह, संयोग से, प्राचीन रोमियों ने वास्तव में यह कैसे किया (और वास्तव में "2000, 2004, 2008" जैसे पांच साल के चक्र का वर्णन करेगा)।

— रैंडम 832 23

आपका जन्मदिन उदाहरण सार्वभौमिक रूप से सत्य नहीं है। उदाहरण के लिए, दक्षिण कोरिया में जीवन के पहले वर्ष को शून्य के बजाय एक के रूप में गिना जाता है ।

— BennyMcBenBen 21

Answer 6

जैसा कि पहले ही दूसरों ने कहा है कि कंप्यूटर शून्य से नहीं गिना जाता है ।

0. से अनुक्रमणिका कुछ भाषाओं में 0 से दो मुख्य लाभ हैं:

1. यह एक प्राकृतिक फैशन में असेंबली में परिवर्तित हो जाता है क्योंकि इसे एक पॉइंटर से पहली स्थिति में ऑफसेट के रूप में व्याख्या किया जा सकता है।

2. जब आप नकारात्मक चाहते हैं तो आपको अजीब नहीं लगता। 1BC और 1AD के बीच कितने साल हैं? कोई नहीं। क्योंकि ईसा पूर्व प्रभावी रूप से नकारात्मक तिथियां हैं, कोई भी वर्ष शून्य नहीं है। अगर 0AD होता तो यहां कोई समस्या नहीं होती। आप विज्ञान में सभी जगह एक ही समस्या देखते हैं जहाँ लोगों ने एक सेट में पहले तत्व को +1 के रूप में परिभाषित किया है।

Comments

हाँ, और नई मिल्निियम के लिए 2001 तक प्रतीक्षा करने की पूरी मूर्खता। यह वास्तव में उन लोगों को भ्रमित करता है जो प्रोग्रामिंग में डब करने पर शून्य आधारित सरणियाँ "नहीं" प्राप्त करते हैं। :)

— कज़

इसके अलावा, यदि "1 मील" का अर्थ "यहीं है", तो चूंकि एक मील 1760 फीट है, इसका मतलब है कि "1760 फीट" का मतलब "सही यहां" भी है, है ना? गलत, "1 फुट" का मतलब यहीं है, उफ़! इस एक आधारित मूर्खता में, "ठीक है यहाँ" एक पैर, एक इंच, एक सेंटीमीटर, आदि है

— कज़

@kaz जहां पैर => गज। एक मील में 1760 गज।

— ब्रैड

Answer 7

स्वाभाविक रूप से गिनती शून्य पर शुरू होती है

यहाँ एक टोकरी में सेब की गिनती के लिए एल्गोरिथ्म है:

count := 0

for each apple in basket
   count := count + 1

उपरोक्त के निष्पादन के बाद, countसेब की संख्या रखती है। यह शून्य हो सकता है, क्योंकि बास्केट खाली हो सकते हैं।

यदि आप पूरे महीने के लिए अपने क्रेडिट कार्ड का उपयोग नहीं करते हैं, तो क्या आपको 1 डॉलर का बिल मिलता है? या 1 प्रतिशत?

जब आप अपनी कार के ओडोमीटर पर ट्रिप मीटर को रीसेट करते हैं, तो क्या यह 0001 या 0000 पर जाता है?

Arrays एक ही डेटा के कई दृश्य प्रदान कर सकता है

32 बिट संरचनाओं की एक सरणी पर विचार करें d, जो प्रत्येक 16 बिट शब्दों से बने हैं w। प्रत्येक शब्द दो 8 बिट बाइट्स से बना है b। शून्य अनुक्रमण के तहत, ओवरले बहुत सुविधाजनक लगता है:

d: |   0   |   1   |
w: | 0 | 1 | 2 | 3 |
b: |0|1|2|3|4|5|6|7|

d[1]शब्द पते पर 32 बिट ऑब्जेक्ट w[2]जो आसानी से 2 से सूचकांक गुणा करके गणना की जाती है, जो कि 32 और 16 बिट ऑब्जेक्ट के आकार का अनुपात है। इसके अलावा, बाइट संबोधन में, यह है b[4]।

यह काम करता है क्योंकि माप की प्रत्येक इकाई में शून्य शून्य है: बाइट, शब्द, दोहरा शब्द और इसी तरह।

उपरोक्त आरेख को देखें: यह एक शासक की तरह दिखता है, जहां इकाई रूपांतरण सहज होते हैं।

एक आधारित अनुक्रमण के साथ, यह टूट जाता है:

d: |   1   |   2   |
w: | 1 | 2 | 3 | 4 |
b: |1|2|3|4|5|6|7|8|

अब हम dसूचकांक प्राप्त करने के लिए सूचकांक को 2 से गुणा नहीं कर सकते हैं w, या bसूचकांक प्राप्त करने के लिए 4 से बढ़ा सकते हैं । इकाइयों के बीच रूपांतरण अनाड़ी हो जाता है। उदाहरण के लिए से जाने के d[2]लिए b[4], हमें गणना करनी होगी ((2 - 1) * 4) + 1 = 5।

हमें dइकाइयों में उस pesky 1 पूर्वाग्रह को घटाना होगा , फिर प्राकृतिक शून्य-आधारित समन्वय प्रणाली में स्केलिंग करना होगा, और फिर bइकाइयों में pesky 1 को वापस जोड़ना होगा । ध्यान दें कि यह वही 1 नहीं है! हम एक डबल शब्द चौड़ाई घटाते हैं, लेकिन फिर एक बाइट चौड़ाई में जोड़ते हैं ।

डेटा के विभिन्न विचारों के बीच परिवर्तित करना सेल्सियस-फ़ारेनहाइट रूपांतरण की तरह कुछ हो जाता है।

जो लोग कहते हैं कि कार्यान्वयन के स्तर पर एक-आधारित सरणियों से निपटना आसान है, क्योंकि केवल 1 का एक सरल घटाव खुद को बेवकूफ बना रहा है, और आप। यह केवल तभी सच है जब हम विभिन्न डेटा प्रकारों के बीच कोई स्केलिंग गणना नहीं करते हैं। ऐसी गणना किसी भी कार्यक्रम में होती है जिसमें डेटा पर एक लचीला दृष्टिकोण होता है (जैसे कि एक बहुआयामी सरणी भी एक आयामी एक के रूप में एक्सेस किया जाता है) या जो भंडारण में हेरफेर करता है: उदाहरण के लिए, एक मेमोरी एलोकेटर, फाइल सिस्टम, या वीडियो फ्रेम बफर लाइब्रेरी।

अंकों को न्यूनतम करना

किसी भी आधार में, यदि हम कुछ मानों का उपयोग करना चाहते हैं तो मूल्यों की एक श्रृंखला को लागू करने के लिए जो आधार की शक्ति है, हमें शून्य से शुरू करना चाहिए। उदाहरण के लिए, बेस दस में, तीन अंक हमें 0 से 999 तक एक हजार अलग-अलग मान देने के लिए पर्याप्त हैं। यदि हम 1 से शुरू करते हैं, तो हम केवल एक मान से ओवरफ्लो करते हैं, और हमें चार अंकों की आवश्यकता होती है।

यह कंप्यूटर में महत्वपूर्ण है, क्योंकि बाइनरी में अंकों की संख्या हार्डवेयर पता लाइनों में बदल जाती है। उदाहरण के लिए, इसमें 256 शब्दों वाली एक ROM चिप को 0 से 255 तक संबोधित किया जा सकता है, जिसके लिए 8 बिट्स की आवश्यकता होती है: 00000000 से 11111111। यदि इसे 1 से 256 तक संबोधित किया जाता है, तो नौ बिट्स की आवश्यकता होती है। हमें सर्किट बोर्ड या इंटीग्रेटेड सर्किट में एक से अधिक एड्रेस ट्रेस को बेकार में जोड़ना होगा। तो व्यवहार में संभवतः ऐसा क्या होगा कि 0 बस कहा जाएगाउस चिप तक पहुँचने के लिए सॉफ्टवेयर एपीआई स्तर पर 1। शब्द 1 के लिए एक अनुरोध वास्तव में 8 बिट एड्रेस बस पर 00000000 डाला जाएगा। या फिर, 1 के लिए एक अनुरोध 00000001 पते पर अनुवाद करेगा, जैसा कि अपेक्षित था, लेकिन 256 के लिए एक अनुरोध 9 बिट पते 100000000 के बजाय अन्यथा अप्रयुक्त 8 बिट पते 00000000 के लिए मैप करेगा। इन दोनों बैग-काटने वाले कीचड़ वास्तव में समाधान हैं एक समस्या की खोज , और हार्डवेयर में, सॉफ्टवेयर में और सभी उपयोगकर्ता इंटरफेस और प्रलेखन में लगातार 0 से 255 का उपयोग करके पूरी तरह से बचा जाता है।

एक-आधारित विस्थापन मौलिक रूप से बेवकूफ हैं

उदाहरण के लिए पश्चिमी संगीत सिद्धांत पर विचार करें। हमारे पास सात नोटों के साथ डायटोनिक तराजू हैं, लेकिन हम उस स्थान को कहते हैं जिसे वे एक सप्तक को कवर करते हैं ! अंतराल का उलटा तो नौ के नियम का पालन करता है : उदाहरण के लिए तीसरे का उलटा एक छठा है (नौ से तीन घटाएँ)। तो तीन अलग-अलग संख्याएं कुछ सरल के लिए खेलती हैं: सात (एक पैमाने में नोट), आठ (सप्तक) और नौ (इनवर्ट से घटाना)।

यदि सात नोटों में सेप्टेव या हेप्टेव बनाया जाता है, और अंतराल शून्य आधारित होते हैं, तो हम सात से उल्टे को घटाएंगे। सात पर आधारित सब कुछ।

इसके अलावा, अंतराल आसानी से खड़ी हो सकती है। वर्तमान प्रणाली में, यदि हम पाँचवें और फिर चौथे से फिर छलांग लगाते हैं, और फिर एक तिहाई करके, हम इन्हें जोड़ नहीं सकते हैं। परिणामी अंतराल दो कम है। यह एक गोधूलि नहीं है, लेकिन वास्तव में दसवां है! प्रत्येक चरण में, हमें एक को घटाना होगा। एक पांचवें और फिर एक चौथे से ऊपर जाना एक नौवां नहीं है, लेकिन केवल एक सप्तक है।

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

संगीत सिद्धांत और लेखन बुरी तरह से पुराना है। अधिकांश यह तब से नहीं बदला है जब से एक मोमबत्ती की रोशनी से क्विल पेन के साथ कम्पोजिंग की गई थी।

एक-आधारित सिस्टम उन्हीं लोगों को भ्रमित करता है जो शून्य-आधारित सरणियों को संभाल नहीं सकते हैं

जब वर्ष 2000 घूमने लगा, तो कई लोगों को भ्रम हुआ कि नई सहस्राब्दी की शुरुआत क्यों नहीं हुई। वे बताते हैं कि यह 2001 तक शुरू नहीं होगा जब तक कि पार्टी के शिकारियों और dweebs के रूप में नहीं माना जाता था। आखिरकार, आप अपने 20 साल के हो गए, जब आप 20 वर्ष के हो गए, ठीक है? जब आप 21 वर्ष के हो जाते हैं तो नहीं। यदि आपको लगता है कि सहस्राब्दी 1 जनवरी 2000 को शुरू हुआ है, तो आपको किसी भी प्रोग्रामिंग भाषा में शून्य आधारित सरणियों के बारे में शिकायत करने का कोई अधिकार नहीं है। वे काम करते हैं कि आप कैसे पसंद करते हैं। (लेकिन, हाँ, एक-आधारित विस्थापन और सरणियों के प्रस्तावक dweebs और पार्टी-कवि हैं। शताब्दी XXX वर्ष पर शुरू होनी चाहिए, और X000 वर्ष पर सहस्राब्दी।)

कैलेंडर गूंगे हैं, लेकिन दिन का कम से कम समय शून्य आधारित है

आपकी घड़ी में प्रत्येक नया मिनट: 00 सेकंड से शुरू होता है। प्रत्येक नया घंटा 00:00 मिनट और सेकंड से शुरू होता है। और, कम से कम एक 24 घंटे की घड़ी में, दिन लगभग आधी रात और 11:59:59 से 00:00:00 तक बढ़ जाता है।

इस प्रकार यदि आप 13:53:04 जैसे समय के लिए आधी रात से सेकंड की गणना करना चाहते हैं, तो आपको बस मूल्यांकन करना होगा 13 * 3600 + 53 * 60 + 4। कोई भी 1जोड़ या घटाव नहीं।

मिडी के बारे में शेख़ी बंद

ठीक है, यह संगीतकारों के साथ क्या है, यहां तक ​​कि कथित तौर पर तकनीकी वाले?

मिडी! यह संदेशों के वास्तविक तार प्रतिनिधित्व में कार्यक्रमों और चैनलों के लिए शून्य-आधारित नंबरिंग का उपयोग करता है, लेकिन गियर इसे 1 आधारित के रूप में प्रदर्शित करता है! उदाहरण के लिए प्रोग्राम 0 से 127 को अधिकांश गियर पर 1 से 128 कहा जाता है, लेकिन कुछ उन्हें 0 से 127 पर कॉल करते हैं या उपयोगकर्ता को विकल्प भी देते हैं।

80 के माध्यम से 71 कार्यक्रम दस का "बैंक" माना जाता है। उदाहरण के लिए, यह मेरे मिडी पेडल पर सही कहता है। फ़ुटस्विच को 1 से 10 तक लेबल किया जाता है और अगर मैं सातवें बैंक में हूं, तो वे 80 के माध्यम से 71 प्रोग्राम लेते हैं। हालांकि, कुछ डिवाइस या कंप्यूटर सॉफ़्टवेयर 1-128 प्रोग्राम नंबर को 0 से 127 तक प्रदर्शित करते हैं, या उपयोगकर्ता को एक भी देता है पसंद! क्या बुरा है: एक-आधारित प्रणाली, या अराजकता एक ही समय में एक और शून्य दोनों का उपयोग करके बनाई गई?

मिडी चैनल संख्याओं को 1 से 16 कहा जाता है, लेकिन 0 से 15 बाइनरी द्वारा दर्शाया जाता है। जैसे कि एक-आधारित प्रस्तुति के बावजूद, कुछ गियर चैनल नंबर को कॉन्फ़िगर करने के लिए एक डिस्सिविच का उपयोग करते हैं और, अक्सर, thes स्विच सिर्फ शून्य आधारित बाइनरी कोड का उपयोग करते हैं। इसलिए यदि आप चैनल 3 चाहते हैं, तो आपको इसे 0010 (बाइनरी 2) पर टॉगल करना होगा।

Answer 8

अगर मैं अपनी प्रोग्रामिंग लैंग्वेज कॉन्सेप्ट क्लास से सही तरीके से याद करता हूं ... 0-इंडेक्स वाली भाषाओं और अन्य को 1-इंडेक्स होने के कारण ऐतिहासिक कारणों से करना पड़ा। अल्गोल -68, प्रोग्रामिंग भाषाओं के ग्रैंड-डैडी वास्तव में 1-अनुक्रमित थे, साथ ही फोरट्रान और कुछ अन्य "व्यवसाय" भाषाओं जैसे COBOL। हालाँकि इनमें से कुछ भाषाओं में, आप वास्तव में स्पष्ट रूप से निर्दिष्ट कर सकते हैं कि आपका शुरुआती सूचकांक क्या होगा। यहाँ इसकी एक दिलचस्प तालिका है ।

मूल रूप से " ये ओल्डे डेज " में गणितज्ञ, वैज्ञानिक और अन्य "शिक्षाविदों" ने आमतौर पर 0-अनुक्रमित भाषाओं का उपयोग किया था, जबकि COBOL जैसी भाषाओं के उपयोगकर्ताओं को 0 पर गिनती शुरू करने का कोई फायदा नहीं मिला, इसलिए उन भाषाओं में अधिक अर्थ लगाया। 1 पर शुरू करने के लिए (यह कम भ्रामक लग रहा था)।

अब यदि आपका प्रश्न यह बताता है कि क्यों एक कंप्यूटर ( एक भाषा नहीं ) स्वाभाविक रूप से शून्य से गिनना शुरू कर देता है ... तो यह है कि मुझे लगता है कि द्विआधारी में निहित वास्तव में: पूर्व: 0000= शून्य 0001= एक ... और इतने पर आगे ...

Comments

बाइनरी प्रतिनिधित्व से कोई लेना-देना नहीं है। बाइनरी और दशमलव संख्या दोनों 0 से शुरू होती हैं (जैसा कि आप अपने उदाहरण में दिखाते हैं)।

— मत्तो

खैर, इसका बाइनरी के साथ कुछ और है। चार बिट्स के साथ, 0000 से 1111 तक, आप 16 शब्दों के मेमोरी बैंक को संबोधित कर सकते हैं। यदि आप इसे एक-आधारित करते हैं, तो आपको 0001 से 10000 तक का प्रतिनिधित्व करने के लिए पांच पता लाइनों की आवश्यकता होती है। या फिर आप ऐसा करते हैं, उदाहरण के लिए, MIDI चैनल संख्याओं के साथ करता है: 0000 का उपयोग आंतरिक रूप से किया जाता है, लेकिन उपयोगकर्ता इंटरफ़ेस शो 1! यदि हार्डवेयर दशमलव आधारित था, तो यह एक ही मुद्दा होगा, हालांकि। यदि आप शून्य से शुरू करते हैं तो तीन अंक आपको एक हजार पते देते हैं, लेकिन यदि आप 1 से शुरू करते हैं, तो आपको चार अंकों की आवश्यकता होती है।

— काज़

Answer 9

संख्या 0 विभिन्न अर्थों को निरूपित कर सकती है: संख्यात्मक मान, क्रम, स्मृति पता आदि।

'सूचकांक शून्य' का मतलब यह नहीं है कि प्रोग्रामर शून्य से गिनती करें। यह आवंटित मेमोरी ब्लॉक के पहले स्थान को दर्शाता है और '0' इसका पता है।

सी में, एक सरणी के माध्यम से लूपिंग को नीचे लिखा जा सकता है:

int arr[N];
for (i=0; arr[N]; ++i) {
...
}

समान कार्य C # में किया जा सकता है:

Object[] arr;

for (Object o in arr) {
...
}

मुझे लगता है कि दोनों उदाहरणों में कोई गिनती नहीं है।

Answer 10

किसी चीज़ से दूरी का वर्णन करते समय शून्य पर शुरू करना व्यावहारिक है। तो इस सरणी में:

[4,9,25,49]

सरणी की शुरुआत से 25 तक की दूरी 2 है - आपको वहां पहुंचने के लिए दो चरणों को छोड़ना होगा। 4 की दूरी शून्य है - आपको शुरू से ही स्थानांतरित करने की आवश्यकता नहीं है।

यह इस तरह से सोचने के लिए व्यावहारिक है जब दूरी (या अनुक्रमित) को जोड़ते हुए - मैं एक कदम आगे बढ़ाता हूं, फिर शून्य कदम, फिर दो कदम, मैं कहां हूं? मैं सूचकांक 1 + 0 + 2 = 3 पर हूं। तीन चरणों को छोड़ कर, मैं ऊपर दिए गए सरणी में 49 पर समाप्त होता हूं।

Comments

एक इमारत में फर्श की गिनती वास्तव में उसी तरह होनी चाहिए (भले ही हम इसे यूएस में उस तरह से नहीं करते हैं) ग्राउंड लेवल शून्य होना चाहिए क्योंकि आप ऊपर या नीचे नहीं गए हैं; यह एक प्रारंभिक स्थिति है।

फिर भी भूतल सबसे पहले आप आते हैं। जब आप भवन में, भूतल में प्रवेश करते हैं, और जब आप ऊपर जाते हैं, तब आप गिनना शुरू करते हैं। शून्य पर शुरू करने से समझ में आता है यदि आप "एक इमारत में" को डिफ़ॉल्ट / सामान्य / प्राकृतिक स्थिति मानते हैं, जो शहरी समाज पर दिलचस्प टिप्पणी है। जमीनी स्तर के लिए शून्य भी बहुत मायने रखता है यदि कई उप-स्तर सामान्य हैं।

Answer 11

याद रखें कि कंप्यूटर में संख्याओं का प्रतिनिधित्व कैसे किया जाता है। चलो एक byteचर लेते हैं। 0 को बाइनरी में 00000000 ^{1 के} रूप में दर्शाया गया है । 1 00000001 है। 2 00000010 है। और इसी तरह।

ध्यान दें कि सबसे कम संख्या जो एक byteस्टोर कर सकती है। 0. यदि हमने 1 के साथ सरणी सूचकांकों को शुरू किया है, तो सिस्टम अक्षम होगा, क्योंकि अब हमारे पास 256 की बजाय लंबाई 255 की है। चूंकि C प्रोग्राम में संख्याएं बाइनरी संख्याओं के लिए संकलित हैं ( intआमतौर पर, unsigned intसरणी सूचकांकों में s), ऐसा लगता है कि 0 को एक आरंभिक सूचकांक के रूप में उपयोग करना स्वाभाविक है क्योंकि यह अधिक कुशल है।

इसके अलावा, C ++ में, जहां डेटाटाइप का आकार है , के a[p]सामने आता है । दूसरे शब्दों में, का अर्थ है "मुझे सूचकांक में तत्व दें "। यदि इसके साथ शुरुआत की जाती है , तो हमारे पास सूचकांक में एक खाली / अप्रयुक्त भाग होगा ।*(a+p*n)na[p]a+n*pp1a

^{1. बेशक, स्पष्ट सवाल "क्यों" उठता है। क्यों नहीं सेट करें 00000000 to1? सरल: बाइनरी जोड़ (पूर्ण योजक इकाइयों के कैस्केड द्वारा किया गया) हार्डवेयर में आसान है जब 00000000 0. बाइनरी जोड़ सभी अंकगणितीय कार्यों का एक अभिन्न अंग है। यदि आप इसे 1 का प्रतिनिधित्व करते हैं, तो आपको या तो कंपाइलर को सभी नंबरों में से 1 को घटाने के लिए बताना होगा, या आपको एडिटर सर्किट को हार्डवेर में जोड़ने के लिए पहले एक से घटाकर इसे वापस योग करने की आवश्यकता होगी। (ध्यान दें कि आप सिर्फ एक बाद में घटा नहीं सकते, क्योंकि कैरी बिट शामिल हो सकता है)}

Comments

@sec क्योंकि हार्डवेयर स्तर पर यह बेतुका हो जाता है (देखें संपादित करें)

— मनीषीर्थ

Answer 12

modulo

मौजूदा अच्छे उत्तरों में एक बात अभी तक उल्लेख नहीं की गई है: शून्य-आधारित अनुक्रमण मॉडुलो संचालन के साथ मिलकर काम करता है, इसलिए इसे चक्रीय सूची बनाने के लिए जोड़ा जा सकता है। उदाहरण के लिए कुछ के बारे में सोचो

color = colors[i % colors.length]

जो प्रत्येक वस्तु iको सूची से एक अलग रंग दे सकता है colors, जब तक कि सभी रंगों का उपयोग नहीं किया जाता है, इस बिंदु पर यह शुरुआत से फिर से शुरू होगा। एक-आधारित अनुक्रमण में समान व्यक्त करना बहुत ही अनाड़ी है:

color = colors[(i - 1) % colors.length + 1]

रैप-अराउंड के साथ निश्चित आकार के अहस्ताक्षरित द्विआधारी अंकगणित द्वारा लगाए गए स्वचालित मोडुलो संचालन इस बात का एक और उदाहरण है कि यह क्यों समझ में आता है।

दोनों के लिए पूरा करता है

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

Answer 13

कंप्यूटर सिस्टम दोनों प्राकृतिक संख्याओं (0 से गिनती) और पूरे नंबर (1 से गिनती) का उपयोग करते हैं। लोग पूरी संख्या में चीजों को गिनते हैं, जो उन्हें नंबरिंग सूचियों के लिए सहज बनाता है, और कई प्रोग्रामिंग भाषाएं इसका लाभ उठाती हैं: BASIC, COBOL, फोरट्रान, लुआ और पास्कल सभी 1 से गिनती। वे भाषाएं डेटा प्रोसेसिंग, संख्यात्मक विश्लेषण जैसे niches को लक्षित करती हैं, और शिक्षण, जहाँ सरल, सहज सूचियाँ एक फायदा है।

जब आप क्रम में सब कुछ संसाधित करने के बजाय डेटा की संरचना का विश्लेषण और हेरफेर करना शुरू करते हैं, तो पूरी संख्या अजीब हो जाती है। जब आपको किसी सूत्र या एल्गोरिथ्म में अनुक्रमों को संदर्भित करने की आवश्यकता होती है, तो उन्हें 0 से संख्या में लाना आसान और कम त्रुटि वाला होता है, जैसे गणितज्ञ करते हैं: ₀ , ₁ , _एन , आदि, अन्यथा, आपको अक्सर +1 द्वारा समायोजित करना होगा। और -1 सही डेटा पर पाने के लिए, और यह गलत है, बग बनाना आसान है। इसलिए, कंप्यूटर वैज्ञानिकों के लिए डिज़ाइन की गई भाषाएं आमतौर पर प्राकृतिक संख्याओं का उपयोग करती हैं: C, Java, और लिस्प सभी को 0 से गिना जाता है।

प्रोग्रामिंग लैंग्वेज से परे, कंप्यूटर सिस्टम के बहुत सारे नंबर 0 से हैं क्योंकि कंप्यूटर वैज्ञानिकों के लिए इसका उपयोग किया जाता है। इसके अलावा, क्योंकि 1 से नंबरिंग करने से इतने सारे कपटी कीड़े हो जाते हैं, हम में से कई इसे गैर-तकनीकी महंगे उपयोगकर्ताओं के लिए सख्ती से डिज़ाइन किए गए इंटरफ़ेस तत्वों से बाहर रखते हैं।

Comments

जावा ... कंप्यूटर वैज्ञानिकों के लिए। जबरदस्त हंसी!

— काज

Answer 14

सरल उत्तर यह है कि पहला अंक 1 नहीं है, यह 0 है।

स्पष्टीकरण: किसी भी आधार में एक बहु-अंक संख्या की गणना करने का सूत्र है:

n = sum(i=0 to n, Di^i)

WHERE 
n = numeric result
i = index (starting with 0)
Di = is the digit at index i

चलो दशमलव प्रणाली लेते हैं, यह वह है जिसका हम सबसे अधिक उपयोग करते हैं।

संख्या 1234 को देखते हुए, हम इसे इस प्रकार लिख सकते हैं:

4 x 10^0 = 4
3 x 10^1 = 30
2 x 10^2 = 200
1 x 10^3 = 1000

in other words, sum of digits raised to the power if their index.

तो, यह सिर्फ कंप्यूटर नहीं है, हम, लोग, 0 से भी गिनती करते हैं।

Answer 15

एक एरे इंडेक्स बेस मेमोरी लोकेशन से एलिमेंट की मेमोरी लोकेशन तक की ऑफसेट है। तत्व I तो आधार + i है। पहला तत्व बेस स्थान पर स्थित है, इसलिए यह स्थान 0 (बेस + 0) पर है।

Answer 16

कम्प्यूटेशनल दक्षता के अलावा, गिनती करने के लिए एक और पहलू भी है। अनुक्रम में प्रत्येक तत्व को अनुक्रमिक संख्या देने के दो तरीके हैं:

1. पूर्ववर्ती (संपूर्ण) तत्वों की संख्या (कार्डिनल संख्या)
2. तत्व की स्थिति (क्रम संख्या)

लोगों की उम्र कार्डिनल संख्या है: बच्चे के जन्म के बाद पहले वर्ष में यह 0 वर्ष का होता है, क्योंकि यह पूरे शून्य वर्षों तक जीवित रहा है।

तिथियों में वर्ष क्रमिक संख्याएँ हैं: पहले वर्ष में अन्नो डोमिनी (AD), वर्ष 1 AD है। कोई वर्ष 0 नहीं है, जैसे शून्य कुछ भी नहीं है।

प्रोग्रामिंग लैंग्वेज (जैसे कि मैटलैब और मैथेमेटिका) जहां एक तत्व का सूचकांक सरणी में अपनी स्थिति का प्रतिनिधित्व करता है 1 से गणना शुरू करें: पहला तत्व। अन्य भाषाओं में (जैसे कि सभी सी-आधारित भाषाएं) एक तत्व का सूचकांक पूर्ववर्ती तत्वों की संख्या है, और इसलिए पहला तत्व 0 है।

---

बेशक, माटेओ केवल आंशिक रूप से सही है जब यह कहा जाता है कि शून्य-आधारित अनुक्रमण अधिक कुशल है।

element(n) = address + n * element_size

एक-आधारित अनुक्रमण केवल कुशल हो सकता है बशर्ते कि सभी सरणी पते पहले से ही उनमें से element_sizeघटाए गए हों। यह तब किया जा सकता है जब सरणी आवंटित की जाती है, जिस स्थिति में यह उतना ही तेज़ है:

array_address = address - element_size
element(n) = array_address + n * element_size

Answer 17

कंप्यूटर पारंपरिक रूप से शून्य से शुरू होने वाले संख्यात्मक मानों को दर्शाता है। उदाहरण के लिए, C- आधारित प्रोग्रामिंग भाषाओं में सरणियाँ इंडेक्स शून्य से शुरू होती हैं।

0 ... आप विभिन्न अवधारणाओं को गड़बड़ कर रहे हैं: प्रोग्रामिंग भाषाएं, कंप्यूटर और गिनती।

1. 2 राज्यों का उपयोग करना (उनमें से अधिकांश योजनाबद्ध तरीके से ठीक वैसा ही करते हैं) इसका मतलब है कि आप उन्हें (करने, कहने, संदर्भ देने) के लिए उन्हें मैप करने के लिए 2 अंक चुन सकते हैं। "3" और "5" (या "एफ" और ",") ठीक होगा, लेकिन फिर आप पूछेंगे कि कंप्यूटर "3" (या "एफ" से) क्यों गिना जाता है। स्वाभाविक रूप से पसंद 0 और 1 स्पष्ट है।
2. पास्कल में आगमन 1 से शुरू होता है। यह भाषा निम्न-स्तरीय C की तुलना में अधिक अमूर्त है।