शून्य-आधारित सरणियाँ मानदंड क्यों हैं?

Question

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

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

Comments

एक n- तत्व सरणी में, तत्व 'n' मौजूद नहीं है। एक n- तत्व सरणी में सदस्य होते हैं जो 0 से n-1 तक की संख्या रखते हैं। इसलिए, यह बेहतर नहीं है अगर हमारे पास 1 से शुरू होने वाला एक सरणी है और इसलिए एन-एलीमेंट सरणी वास्तव में एरे में मौजूद एन तत्वों का प्रतिनिधित्व करता है।

मुझे शून्य आधारित सरणियाँ पसंद हैं क्योंकि बाइट में पहली बिट 2 ^ 0 है, 2 ^ 1 नहीं। इससे मुझे कभी

— -

यदि कोई इस सूची को उदाहरण के लिए देखता है, तो en.wikipedia.org/wiki/… , कोई ध्यान देगा कि अधिकांश डोमेन विशिष्ट भाषाएं 1 पर अनुक्रमित करना शुरू कर देती हैं, और सीएस स्कूल ऑफ़ थिंकिंग से अधिकांश भाषाएँ 0. पर खोजती हैं। यदि कोई थोड़ी देर के लिए खोज करता है , वह इस बात पर ध्यान देगा कि इस विषय पर इतनी मूर्खतापूर्ण चर्चा की गई है, कि दोनों में से किसी से भी बात करने की कोशिश करना संभव नहीं है। "1" के बचाव में, दुनिया के अधिकांश लोग उस एक का उपयोग करते हैं। अधिकांश प्रोग्रामर "0" का उपयोग करते हैं। ज्यादातर लोग प्रोग्रामर को नहीं समझते हैं, जिससे आपको लगता है ...

— रुके

मुझे विश्वास नहीं हो रहा है कि यह प्रश्न स्टैकऑवरफ्लो से प्रोग्रामर के लिए माइग्रेट किया गया था, और फिर, गैर-रचनात्मक के रूप में बंद हो गया। यह गूंगा है।

— पियरसबल

Answer 1

मुझे नहीं लगता कि हममें से कोई भी एग्जर डब्ल्यू। डेज्स्ट्रा के लेख "क्यों नंबरिंग को शून्य से शुरू करना चाहिए" की तुलना में अधिक मजबूत तर्क प्रदान कर सकता है ।

Comments

उन्होंने कुछ आँकड़े लाए और गणित शैली प्रमाण का उपयोग किया। लेकिन मुझे यकीन है कि कोई फिर भी बहस कर सकता है। हालांकि मुझे मंजूर है तो मैं नहीं करूंगा।

दीजकस्ट्रा का लेख शैली के बारे में है, लेकिन फिर, उनके तर्क सादगी और उपयोग में आसानी के बारे में हैं ... +1।

— पियरसबल

Answer 2

प्राधिकरण का तर्क

खैर ... जाहिर है, अधिकांश भाषाएं, जिनमें बहुत हालिया हैं, वे शून्य-आधारित हैं। जैसा कि उन भाषाओं को काफी कुशल लोगों द्वारा लिखा गया था, आपके दोस्त को गलत होना चाहिए ...

क्यों एक?

क्यों 1 शून्य से बेहतर प्रारंभिक सूचकांक होगा? 2, या 10 क्यों नहीं? इसका उत्तर स्वयं दिलचस्प है क्योंकि यह विचार का बचाव करने वाले लोगों की प्रक्रिया के बारे में बहुत कुछ दिखाता है।

पहले तर्क है कि यह, और अधिक प्राकृतिक है, क्योंकि है 1 आम तौर पर है एक , अन्य सभी से पहले कम से कम लोगों के बहुमत के लिए ...

संख्या- एक तर्क यह है कि अंतिम सूचकांक भी सरणी का आकार है ...

मैं अभी भी उन कारणों की "गुणवत्ता" से प्रभावित हूं जो मैं आमतौर पर इस तरह के तर्कों के लिए सुनता हूं ... और इससे भी अधिक जब मुझे याद दिलाया जाता है कि ...

शून्य क्यों नहीं?

... "एक-आधारित" नोटेशन पश्चिमी संस्कृति से बचे हुए ओवर हैं जो सदियों से शून्य के अस्तित्व को अनदेखा करते हैं, यदि अधिक नहीं।

मानो या न मानो, मूल ग्रेगोरियन कैलेंडर -3, -2, -1, 1, 2, 3 से जाता है ... समस्या की कल्पना करने की कोशिश करें कि यह पश्चिमी विज्ञान में योगदान देता है (उदाहरण के लिए, 1 जनवरी -2 से कितने साल 1 जनवरी से 2 जनवरी तक मूल ग्रेगोरियन कैलेंडर की तुलना में देखने के लिए विकल्प के रूप में कुछ के साथ संघर्ष ...)।

एक-आधारित सरणियों की तरह रखना (ठीक है, मैं उस के लिए नीच हो जाऊंगा ... ^ _ ^ ...), 21 वीं शताब्दी में मील और गज की दूरी पर रखते हुए ...

शून्य क्यों? क्योंकि यह गणित है!

पहले (ओह ... क्षमा करें ... मैं फिर से कोशिश करूँगा)

शून्य , शून्य कुछ भी नहीं है, एक कुछ है। और कुछ धार्मिक ग्रंथ मानते हैं कि "शुरुआत में, कुछ भी नहीं था"। कुछ कंप्यूटर से संबंधित चर्चा धार्मिक बहस के रूप में जल सकती है, इसलिए यह बिंदु विषयों से बाहर नहीं है क्योंकि ऐसा लगता है ... ^ _ ^

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

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

तीसरा , जैसा कि कंप्यूटर की भाषा सरणियों को हार्डवेयर से बांधा जा रहा है, 21 पूर्णांकों की C सरणी आवंटित करें, और सूचक 10 सूचक को दाईं ओर ले जाएं, और आपके पास एक प्राकृतिक [-10 से 10] सरणी होगी। यह हार्डवेयर के लिए स्वाभाविक नहीं है। लेकिन यह गणित के लिए है। बेशक, गणित अप्रचलित हो सकता है, लेकिन पिछली बार जब मैंने जाँच की, तो दुनिया के अधिकांश लोगों का मानना ​​था कि यह नहीं था।

चार , जैसा कि पहले से ही कहीं और बताया गया है, यहां तक ​​कि असतत स्थिति के लिए (या मूल्यों को कम करने के लिए), पहला सूचकांक शून्य होगा, जैसे किसी भवन में फर्श (शून्य पर शुरू), घटती उलटी गिनती (3, 2, 1, शून्य) !), जमीन की ऊँचाई, एक छवि का पहला पिक्सेल, तापमान (शून्य केल्विन, पूर्ण शून्य के लिए, या शून्य सेंटीग्रेड डिग्री, 273 K के पानी के ठंड तापमान के रूप में)। वास्तव में, केवल एक चीज जो वास्तव में किसी एक के साथ शुरू होती है, वह " पहले , दूसरे , तीसरे , आदि" का पारंपरिक तरीका है । पुनरावृत्ति संकेतन, जो मुझे स्वाभाविक रूप से अगले बिंदु तक ले जाता है ...

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

निष्कर्ष

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

गणित से संबंधित कारणों के कारण शून्य-आधारित सरणियाँ शून्य-आधारित हैं। हार्डवेयर से संबंधित कारणों के लिए नहीं।

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

Comments

); शून्य सेंटीग्रेड डिग्री 273,15K है

मुझे पता है (मेरे पास भौतिकी पर एक मास्टर डिप्लोमा है), लेकिन मुझे लगा कि दशमलव के साथ खेलने की तुलना में मैं अपने तर्क को रंग देने की कोशिश की तुलना में कम था ... ^ _ ^ ...

— 17

आपके पैराग्राफ को "शून्य, पहला, दूसरा, तीसरा, चार, पांच" लेबल दिया गया है। स्थिरता के लिए, आपको या तो कार्डिनल नंबर ("जीरो, वन, टू, थ्री, फोर, फाइव") या ऑर्डिनल नंबर ("जीरोथ, फर्स्ट, सेकंड, थर्ड, फोर्थ, फिफ्थ") का उपयोग करना चाहिए। :-)

— श्रीवत्सआर

इसी तरह, हमारे जीवन के पहले वर्ष के लिए, हम एक वर्ष के नहीं हैं, लेकिन शून्य वर्ष के हैं

@ नीकिता रायबाक: क्या अद्भुत बात है कि आपके सामने सभी टिप्पणीकारों द्वारा देखी गई बात याद आ गई: बिल का बिल छिपकली का जवाब सही है। यही कारण है कि मैंने उसे +1 किया, और यही कारण है कि इसे प्रश्न के सर्वश्रेष्ठ उत्तर के रूप में चुना गया। मेरा उत्तर 1-आधारित सरणियों के पीछे के कारण का मजाक उड़ाने और ठोस मामलों की पेशकश करने के बारे में अधिक है, जहां 1-आधारित सरणी एक उपद्रव होगा। फिर भी, मुझे आश्चर्य है कि आपने पाया "एक भी समझाने वाला नहीं", यहां तक ​​कि कारणों को देखते हुए विडंबना के साथ मिलाया जाता है ...

— paercebal

Answer 3

आधे खुले अंतराल अच्छी तरह से रचना करते हैं। यदि आप काम कर रहे हैं 0 <= i < limऔर आप nतत्वों द्वारा विस्तार करना चाहते हैं, तो नए तत्वों की सीमा में सूचकांक हैं lim <= i < lim + n। शून्य-आधारित सरणियों के साथ काम करने से अंकगणित या समतल करने वाले सरणियों या तत्वों की गिनती करते समय अंकगणितीय आसान हो जाता है । एक उम्मीद करता है कि सरल अंकगणित कम बाड़ की त्रुटियों की ओर जाता है ।

Comments

+1 आधे-खुले अंतराल के लिए - यह बस सब कुछ आसान बनाता है।

— ग्रहण

Answer 4

कुछ प्रकार के सरणी हेरफेर 1-आधारित सरणियों के साथ पागल हो जाते हैं, लेकिन 0-आधारित सरणियों के साथ सरल रहते हैं।

मैंने एक बिंदु पर कुछ संख्यात्मक विश्लेषण प्रोग्रामिंग की। मैं एल्गोरिथ्म के साथ काम कर रहा था, संकुचित, विरल मैट्रीक में हेरफेर करने के लिए, दोनों फोरट्रान और सी ++ में लिखा गया था।

FORTRAN एल्गोरिदम में बहुत सारे थे a[i + j + k - 2], जबकि C ++ में था a[i + j + k], क्योंकि FORTRAN सरणी 1-आधारित थी, जबकि C ++ सरणी 0-आधारित थी।

Comments

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

— फैबियो सेकोनेलो

मैंने 1 आधारित सरणियों की अनावश्यक जटिलता को भी मार दिया है, 0 आधारित सरणियों को, मेरे सीमित अनुभव में, हमेशा दुर्लभ अपवाद के साथ सरणी अनुक्रमण के लिए स्पष्ट कोड का उत्पादन किया है।

फोरट्रान और सी ++ सूचकांक 2 से भिन्न कैसे होंगे यदि उनके संबंधित सूचकांक केवल 1 से ऑफसेट हों? इसके अलावा, माइनस 2 क्यों ? यदि FORTRAN 1-आधारित है, तो क्या आप 2 (या 1) नहीं जोड़ेंगे?

— रेक्स डे

@RexE: कि यह कैसे काम करता है, और यही कारण है कि यह 1-आधारित सरणियों के साथ बहुत जटिल है।

— जय बज़ुजी

@RexE: मान लीजिए कि आप एक फ्लैट के साथ एक 3D सरणी का अनुकरण करते हैं। फिर, 0 बेस में, तत्व (0 0 0) फ्लैट ऐरे में एलिमेंट 0 से मेल खाता है। OTOH, यदि यह 1-आधारित है, तो तत्व (1 1 1) समतल सरणी में तत्व 1 से मेल खाता है: 1 + 1 + 1-2।

Answer 5

किसी सरणी में अनुक्रमणिका वास्तव में अनुक्रमणिका नहीं है। यह केवल एक ऑफसेट है जो सरणी के प्रारंभ से दूरी है। पहला तत्व सरणी की शुरुआत में है इसलिए कोई दूरी नहीं है। इसलिए ऑफसेट 0 है।

Comments

आजकल तैयार होने वाली अधिकांश भाषाओं के लिए, यह वास्तव में एक कार्यान्वयन विवरण है, जो भाषा में प्रकट नहीं होना चाहिए (ऐसा करने के लिए जब अन्य बेहतर कारण हैं) को छोड़कर

— जेन्स स्काउडर

Answer 6

कारण सिर्फ ऐतिहासिक नहीं हैं: C और C ++ अभी भी आसपास हैं और व्यापक रूप से उपयोग किए जाते हैं और सूचक अंकगणित अनुक्रमणिका 0 पर शुरू होने के लिए एक बहुत ही मान्य कारण है।

सूचक अंकगणित की कमी वाली अन्य भाषाओं के लिए, चाहे पहला तत्व इंडेक्स 0 पर हो या 1 किसी अन्य चीज़ के बजाय एक कन्वेंशन का अधिक हो।
समस्या यह है कि वे भाषाएँ जो अपने पहले तत्व के रूप में इंडेक्स 1 का उपयोग करती हैं, वे एक निर्वात में मौजूद नहीं होती हैं और आमतौर पर उन पुस्तकालयों के साथ बातचीत करनी होती है जिन्हें अक्सर लिखा जाता है -आप ने अनुमान लगाया था कि- C या C ++ ...

VB और इसके व्युत्पन्न फ्लेवर को 0 या 1 से शुरू होने से एरेज़ का सामना करना पड़ा है और यह लंबे समय तक समस्याओं का स्रोत रहा है।

निचला-रेखा यह है: इससे कोई फर्क नहीं पड़ता कि आपकी भाषा पहले तत्व सूचकांक पर तब तक विचार करती है, जब तक वह पूरे अनुरूप हो। समस्या यह है कि पहले सूचकांक के रूप में 1 पर विचार करने से अभ्यास में काम करना कठिन हो जाता है।

Comments

माना। संगति मायने रखती है, और जब तक आपके पास निम्न-स्तरीय कोड (सी / सी ++ सहित) से बचने की लक्जरी नहीं है, तब तक 1-आधारित सरणियों के साथ काम करना सिर्फ परेशानी के लिए पूछ रहा है।

— शोग

जब हम इस पर हैं, तो एक सवाल: क्या आप कभी भी एक गैर-प्लेटफ़ॉर्म विशिष्ट तरीके से निम्न-स्तरीय कोड का उपयोग करते हैं? दूसरे शब्दों में, आप हमेशा एक मंच या किसी अन्य पर होते हैं और आपको यह जानना होता है कि कौन सा, सही?

— दान रोसेनस्टार्क

जैसा कि किसी को लगता है कि VB .NET आमतौर पर गलत तरीके से गलत है, मेरा कहना है कि सरणियों पर VB .NET अभ्यास भयानक है। उन्होंने अंतर को विभाजित किया और इसे और भी भ्रामक बना दिया: Arrays 0 से शुरू होता है, लेकिन Dim as Integer (5) 6 पदों के साथ एक सरणी बनाता है । औचित्य प्रतीत हो रहा था कि एक अतिरिक्त स्थिति होने से सरणी की लंबाई को संबोधित करने से कीड़े होने से बेहतर था। दुर्भाग्य से उस पर (और अन्य मुद्दों, जैसे कि और या बिटवाइज़) वे बहुत सारे VB6 प्रोग्रामर से मांगों को पूरा करते थे, जो कि वैसे भी VB .NET का उपयोग करके समाप्त नहीं हुए थे।

— Kyralessa

@Kyralessa: नहीं, तर्क में VB6 (स्वचालित अपग्रेड असिस्टेंट ...) के लिए बैकवर्ड संगतता थी, हालांकि वे अच्छी तरह जानते थे कि अंकन सहज और त्रुटि-प्रवण है। दूसरी ओर, Andऔर OrVB6 के साथ कुछ भी नहीं करने के लिए बिटवाइज़ होने के नाते, यह VB- प्रकार की भाषा के लिए एकमात्र तार्किक समाधान है। आप करते है AndAlsoऔर OrElseअपने तार्किक कार्यों के लिए।

— कोनराड रुडोल्फ

Andऔर Orबिटवाइज़ का VB6 के साथ सब कुछ है, क्योंकि वे VB6 में बिटवाइज़ थे। बदसूरत ऑपरेटरों AndAlsoऔर OrElseउन्हें बिटवाइज़ बना दिया जाना चाहिए, क्योंकि बिटवाइज़ ऑपरेशंस तार्किक लोगों की तुलना में कम सामान्य हैं। "पीछे की ओर अनुकूलता" के कारण भाषा पर छोड़ दिए गए जैसे बहुत सारे बदसूरत मौसा हैं, इस तथ्य की तरह कि बायवैल को डिफ़ॉल्ट होने के बावजूद सभी जगह पर प्लास्टर किया गया है।

— क्लेरासेला

Answer 7

शून्य-आधारित सरणियों की जड़ें सी और यहां तक ​​कि कोडांतरक भी हैं। सी के साथ, सूचक गणित मूल रूप से इस तरह काम करता है:

• एक सरणी के प्रत्येक तत्व में बाइट्स की एक निश्चित संख्या होती है। एक 32 बिट पूर्णांक है (स्पष्ट रूप से) 4 बाइट्स;
• एक सरणी का पता सरणी के पहले तत्व द्वारा उसके बाद समान आकार के सन्निहित ब्लॉकों में तत्वों के साथ कब्जा कर लिया जाता है।

समझाने के लिए, मान int a[4]0xFF00 पर है, पते हैं:

• एक [0] -> 0xFF00;
• एक [1] -> 0xFF04;
• एक [2] -> 0xFF08;
• एक [३] -> ०x एफ ० सी।

तो, शून्य आधारित सूचकांकों के साथ, अतिरिक्त गणित सरल है:

तत्व का पता = सरणी का पता + सूचकांक * आकार (प्रकार)

वास्तव में C में भाव सभी समतुल्य हैं:

• एक [2];
• 2 [एक]; तथा
• * (अ + 2)।

एक-आधारित सरणियों के साथ, गणित (कभी ऐसा है) थोड़ा और अधिक जटिल है।

तो कारण काफी हद तक ऐतिहासिक हैं।

Comments

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

वर्थ उल्लेख है कि एन-आधारित सरणियों की अनुमति देने वाली भाषाएं आमतौर पर 'रन ऑफसेट' के साथ कोड उत्पन्न करती हैं जो स्वचालित रूप से शून्य रनटाइम लागत पर गणना की जाती हैं।

— रोडी

Answer 8

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

0 = {}
1 = 0 U {0} = {0}
2 = 1 U {1} = {0,1}
3 = 2 U {2} = {0,1,2}
...
n = n-1 U {n-1} = {0,1,2...n-1}

तो यह एक अर्थ में, सबसे प्राकृतिक संकेतन है।

Answer 9

क्योंकि C में सरणियों और बिंदुओं के बीच एक मजबूत सहसंबंध है

char* p = "hello";
char q[] = "hello";

assert(p[1] == q[1]);

assert(*p == *q)

* p * के समान है (p + 0)

1 का शुरुआती इंडेक्स होने से आपको बाद में सिरदर्द होगा

Answer 10

1-आधारित सरणियों के लिए एक ढेर फायदे का एक उदाहरण है। एक इंडेक्स i को देखते हुए , i के माता-पिता और बाएं बच्चे के सूचकांक हैं

PARENT[ i ] = मैं ÷ २

LCHILD[ i ] = i × २

लेकिन केवल 1-आधारित सरणियों के लिए। आपके पास 0-आधारित सरणियों के लिए

PARENT[ i ] = ( i + 1) ] 2 - 1

LCHILD[ i ] = ( i + 1) × २ - १

और फिर आपके पास संपत्ति है कि मैं उस सूचकांक के उप-सरणी का आकार भी है (अर्थात रेंज में सूचकांकों [1, i ])।

लेकिन अंत में, इससे कोई फर्क नहीं पड़ता, क्योंकि आप 0-आधारित सरणी को 1-आधारित सरणी में सामान्य से एक अधिक तत्व आवंटित करके और शून्य को अनदेखा कर सकते हैं। इस प्रकार आप उपयुक्त होने पर 1-आधारित सरणियों का लाभ प्राप्त करने के लिए ऑप्ट-इन कर सकते हैं, और लगभग सभी अन्य स्थितियों में क्लीनर अंकगणित के लिए 0-आधारित सरणियों को रख सकते हैं।

Answer 11

मेरी भावना यह है कि यह पूरी तरह से मनमाना है। शून्य या एक-आधारित सरणियों के बारे में कुछ खास नहीं है। विजुअल बेसिक से खुद को आज़ाद करने के बाद (ज्यादातर, कभी-कभी मैं एक्सेल में छोटे काम करता हूं) मैंने 1-आधारित सरणियों के साथ काम नहीं किया है, और ... यह वही है। तथ्य यह है कि यदि आपको सरणी के तीसरे तत्व की आवश्यकता है, तो यह सिर्फ एक कार्यान्वयन विवरण है जिसे इसे 3 या 2 कहा जाता है। हालाँकि, 99% आप जो कार्य सरणियों के साथ करते हैं, वह केवल दो पूर्ण बिंदुओं में रुचि रखता है: पहला तत्व और गिनती या लंबाई। फिर, यह सिर्फ एक कार्यान्वयन विवरण है कि पहले तत्व को एक के बजाय शून्य कहा जाता है, या कि अंतिम तत्व को गिनती -1 कहा जाता है या, इसके बजाय, गिनती।

संपादित करें: उत्तरदाताओं में से कुछ ने उल्लेख किया है कि 1-आधारित सरणियों में फ़ीनपोस्ट त्रुटियों के लिए अधिक संभावना है। मेरे अनुभव में, अब इसके बारे में सोचना, यह सच है। मुझे याद है, VB में, "यह या तो काम करेगा या उड़ा देगा क्योंकि मैं एक से दूर हूं।" जावा में जो कभी नहीं होता है। हालांकि मुझे लगा कि मैं बेहतर हो रहा था, उत्तर देने वालों में से कुछ ऐसे मामलों को इंगित करते हैं जिनमें 0-आधारित सरणियों का परिणाम नीस अंकगणित, ईवीएन में होता है जब आपको निचले स्तर के अंतराल से निपटने की आवश्यकता नहीं होती है।

Comments

PHP में, स्ट्रिंग फंक्शन रिटर्न FALSE के अंदर अधिकांश खोज नहीं मिली। नहीं -1।

— jmucchiello

आप अंतिम तत्व के सूचकांक के साथ गणना को भ्रमित कर रहे हैं। खाली सरणी की गिनती हमेशा 0 होती है, चाहे आप शून्य-आधारित या एक-आधारित सरणियों का उपयोग करें। एक-आधारित सरणियों का लाभ यह है कि गणना अंतिम तत्व की स्थिति है (लेकिन यह एकमात्र लाभ के बारे में है)।

इन दोनों बिंदुओं के बारे में सही: पिछले आधे हटाए गए, क्योंकि यह शून्य-आधारित या एक-आधारित सरणियों के लिए समान है: यदि आपने शून्य तत्व प्राप्त किए हैं तो गिनती 0 है।

— दान रोसेनस्टार्क

मेरे जवाब के अंतिम आधे का मतलब था ...

— डैन रोसेनस्टार्क

Answer 12

10 + yr C / C ++ प्रोग्रामर के रूप में, पास्कल और डेल्फी में एक बहुत मजबूत पृष्ठभूमि के साथ, मैं अभी भी पास्कल की मजबूत सरणी बाध्य और सूचकांक प्रकार की जाँच, और लचीलेपन और सुरक्षा को याद करता हूं जो इसके साथ आता है। इसका एक स्पष्ट उदाहरण प्रत्येक महीने के लिए एक सरणी डेटा होल्डिंग मान है।

पास्कल:

 Type Month = (Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec);

  Var Days[Month] of integer;

  ... 
  if Year mod 4 = 0 then // yes this is vastly simplified for leap years and yes i don't know what the comment marker is in pascal and no i won't go look it up
    Days[Feb] := 29
  else
    Days[Feb] := 28;

+/- 1 या 'मैजिक नंबर' का उपयोग किए बिना सी भाषाओं में समान कोड लिखना बहुत चुनौतीपूर्ण है। ध्यान दें कि दिन [2] और दिन [जन + दिसंबर] जैसे भाव संकलित नहीं होंगे, जो उन लोगों के लिए क्रूर दिखाई दे सकते हैं जो अभी भी सी या असेंबलर में सोचते हैं।

मेरा कहना है कि पास्कल / डेल्फी भाषाओं के कई पहलू हैं जो मुझे थोड़ा याद नहीं हैं, लेकिन सी शून्य-आधारित सरणियों की तुलना में सिर्फ "गूंगा" लगते हैं।

Comments

यह ध्यान देने योग्य हो सकता है कि आपका एल्गोरिथ्म वर्ष 2100 के लिए सही नहीं है। en.wikipedia.org/wiki/Leap_year#Al

मुझे पता है;; हालाँकि, यह वर्ष 2000 के लिए सही था। मैं "स्पॉट द पेडेंट" खेल रहा हूं ...

— रोडी

पेडेंट को हाजिर करो! जबरदस्त हंसी।

— जेकलूम

हाँ। पूरे मामले से बचें, लेकिन जिस सरणी को आप चाहते हैं उसे आधार बनाएं।

— लोरेन Pechtel

मुझे आश्चर्य नहीं होगा अगर आपका औसत पास्कल संकलक मशीन कोड जनरेट करते समय Jan = 0, Dec = 11 असाइन करता है :-)

Answer 13

इसका कारण 0 से शुरू होता है और 1 नहीं, यह है कि आप ऑफसेट के बारे में सोच सकते हैं कि सरणी की मेमोरी की शुरुआत से यह तत्व कितना दूर है। यह मुझे 0 तत्व नहीं दे रहा है - यह कह रहा है, मुझे वह तत्व दें जो शुरू से 0 तत्व है।

इसे देखने का एक और तरीका यह है कि ये (अधिकांश भाग के लिए) बराबर हैं:

array[n]

*(array + n)

मानक को कभी नहीं बदला जाएगा क्योंकि C लगभग 40 वर्षों से है। इसे बदलने के लिए कोई बाध्यकारी कारण नहीं है और यदि उन्होंने किया, तो मौजूदा कोड जो 0 पर शुरू होने वाले सरणी पर निर्भर करता है, सभी को तोड़ दिया जाएगा।

Comments

वास्तव में, आप को फिर से लिखने कर सकते हैं array[n]के रूप में n[array]सी में यह यह करने के लिए एक अच्छा विचार नहीं है, यह भ्रामक है! लेकिन यह कानूनी है (ठीक है, कम से कम C89 तक) क्योंकि उस पहचान के ऊपर और तथ्य यह है कि इसके अलावा सराहनीय है।

— डोनाल्ड फेलो

यह लिखने का एक पागल तरीका है - ऐसा कुछ जो अगर आपने किसी भी कोड में देखा है जिसे आपको बनाए रखना है तो यह एक बड़ा चेतावनी संकेत होगा। शुक्र है कि मैं उस पार नहीं चला ... अभी तक :)

— डेनिस मुंसी

Answer 14

कुछ मूल स्थिति / रिश्तेदार स्थिति की जानकारी सहित कोड 0 पर शुरू होने वाले सरणियों के साथ बहुत अधिक स्वच्छ हैं।

उदाहरण के लिए: एक वेक्टर में एक निर्धारित स्थिति में एक वेक्टर को कॉपी करने के लिए कोड 1 से शुरू होने वाले सरणियों के साथ एक दर्द है:

function copyAtPos (dest, vect, i):
    for i from 1 -> vect.length do
        dest[pos+i-1] = vect[i]

0 से शुरू होने वाले सरणियों के विरोध में:

function copyAtPos (dest, vect, i):
    for i from 0 -> vect.length-1 do
        dest[pos+i] = vect[i]

यदि आप बड़े संकल्प फार्मूला लिखना शुरू करते हैं, तो यह बहुत जरूरी हो जाता है।

Answer 15

2 या 3 या 20 क्यों नहीं? ऐसा नहीं है कि 1-आधारित सरणियों को किसी तरह से समझना आसान है या फिर शून्य आधारित सरणियों को समझना आसान है। 1-आधारित सरणियों पर स्विच करने के लिए, प्रत्येक प्रोग्रामर को यह पता लगाना होगा कि सरणियों के साथ कैसे काम करना है।

और इसके अलावा, जब आप मौजूदा सरणियों में ऑफसेट के साथ काम कर रहे हैं, तो यह और भी अधिक समझ में आता है। यदि आपने किसी सरणी से 115 बाइट्स पढ़े हैं, तो आप जानते हैं कि अगला चंक 115 पर शुरू होता है। और इसी तरह, अगला बाइट हमेशा बाइट के आकार को पढ़ता है। 1-आधारित के साथ आपको हर समय एक जोड़ना होगा।

और आपको कभी-कभी सरणियों में डेटा के विखंडन से निपटने की आवश्यकता होती है, यहां तक ​​कि भाषा में "सही" सूचक अंकगणित के बिना भी। जावा में आपके पास मेमोरी मैप्ड फ़ाइलों या बफ़र्स में डेटा हो सकता है। उस स्थिति में, आप जानते हैं कि ब्लॉक i आकार में है * i। 1-आधारित इंडेक्स के साथ यह ब्लॉक * i + 1 पर होगा।

1-आधारित अनुक्रमण के साथ, बहुत सारी तकनीकों को पूरे स्थान पर + 1s की आवश्यकता होगी।

Comments

2 या 3 या 20 क्यों नहीं? क्योंकि 0 योजक की पहचान है और 1 गुणक की पहचान है। वे सबसे अधिक समझ में आता है।

Answer 16

1-आधारित सरणियों का उपयोग करना, एकल-आयामी सरणी को बहुआयामी सरणी में बदलना:

int w = 5, h = 5, d = 5;

int[] a1 = new int[w * h * d], new a2 = int[w,h,d];

for (int z = 1; z <= d; z++)

  for (int y = 1; y <= h; y++)

    for (int x = 1; x <= w; x++)

      a1[x + (y - 1) * w + (z - 1) * h] = a2[x,y,z];

ध्यान दें कि जब आपका सरणी 1-आधारित हो तब भी आपका y और z इंडेक्स 0-आधारित (y - 1, z - 1) हो। कुछ परिस्थितियों में, आप 0-आधारित अनुक्रमित से बच नहीं सकते। स्थिरता के लिए, हमेशा 0-आधारित इंडेक्स का उपयोग क्यों नहीं किया जाता है?

Answer 17

आप एक पर शुरू करने के लिए सरणियाँ क्यों चाहते हैं?

जब आप कहते हैं a[x][y], संकलक इस में अनुवाद करता है a+(x*num_cols+y):। यदि एक पर सरणियाँ शुरू होती हैं, तो यह बन जाएगी a+(x*num_cols+y-1)। यह हर बार जब आप किसी ऐरे तत्व तक पहुँचना चाहते हैं तो एक अतिरिक्त अंकगणितीय ऑपरेशन होगा । आप कार्यक्रमों को धीमा क्यों करना चाहेंगे?

Comments

वास्तव में, यह + (+ (x - 1) * num_cols) + y - 1 बनना होगा - दोनों x और y 1 से शुरू होंगे।

— डेनिस मुंसी जूल

Answer 18

मैं यहां एक अंग पर कदम रखने जा रहा हूं और पूर्णांक 'की' सरणी से अलग कुछ सुझाता हूं।

मुझे लगता है कि आपके सहकर्मी को भौतिक दुनिया में 'सेट' की एक से एक मैपिंग बनाने में मदद मिल रही है, जहां हम हमेशा 1 पर गिनना शुरू करते हैं। मैं यह समझ सकता हूं, जब आप कुछ भी नहीं कर रहे हैं, तो कुछ कोड समझना आसान है जब आपको सॉफ्टवेयर और भौतिक दुनिया के बीच 1 से 1 मैप किया जाता है।

मेरा सुझाव

आप जो भी स्टोर कर रहे हैं, उसके लिए पूर्णांक आधारित सरणियों का उपयोग न करें, लेकिन किसी अन्य प्रकार के शब्दकोश या मुख्य मूल्य जोड़ी का उपयोग करें। ये नक्शे वास्तविक जीवन के लिए बेहतर हैं क्योंकि आप एक मनमाने ढंग से पूर्णांक से बंधे नहीं हैं। इसकी जगह है और मैं इसका उपयोग करने की सलाह दूंगा जितना आप सॉफ्टवेयर और भौतिक दुनिया के बीच 1 से 1 मानचित्रण अवधारणाओं के लाभ के कारण कर सकते हैं।

यानी kvp['Name Server'] = "ns1.example.com"; (यह एक लाख संभावित उदाहरणों में से सिर्फ एक है)।

Discaimer

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

अंतिम विचार शून्य-आधारित सरणियों या कुंजी मूल्य जोड़े का उपयोग करना है जहां यह समझ में आता है, याद रखें कि जब आपके पास केवल एक हथौड़ा होता है, तो हर समस्या नाखून की तरह दिखना शुरू हो जाती है ...

Answer 19

व्यक्तिगत रूप से, एक तर्क यह है कि सरणी इंडेक्स को ऑफ़सेट के रूप में देखा जाए। यह सिर्फ समझ में आता है।

कोई कह सकता है कि इसका पहला तत्व है, लेकिन सरणी की उत्पत्ति के सापेक्ष पहले तत्व की भरपाई शून्य है। जैसे, ऐरे की उत्पत्ति और शून्य को जोड़ने से पहला तत्व निकलेगा।

इसलिए पहले जोड़ने के बजाय पहले तत्व को खोजने के लिए शून्य को जोड़ना आसान है और फिर एक को हटा दें।

मुझे लगता है कि किसी ने भी निचले स्तर के सामान को हमेशा आधार शून्य तरीका माना है। और जो लोग शुरुआत या उच्च स्तर के लिए उपयोग किए जाते हैं, वे अक्सर एल्गोरिथम प्रोग्रामिंग नहीं करते हैं, वे आधार एक प्रणाली की इच्छा कर सकते हैं। या हो सकता है कि हम पिछले अनुभवों से सिर्फ पक्षपाती हों।

Comments

वास्तव में - यह मूल रूप से एक सम्मेलन है जो निचले स्तर की भाषाओं से घिरा हुआ है।

Answer 20

1-आधारित सूचकांकों के बजाय 0-आधारित सूचकांकों का उपयोग करने के केवल दो (बहुत) गंभीर कारणों से लगता है कि बहुत सारे प्रोग्रामर और पिछड़े हमवतन के लिए फिर से शिक्षित होने से बचें ।

मैंने आपके द्वारा प्राप्त सभी उत्तरों में 1-आधारित सूचकांकों के खिलाफ कोई अन्य गंभीर तर्क नहीं देखा।

वास्तव में, सूचकांक स्वाभाविक रूप से 1-आधारित हैं , और यहाँ क्यों है।

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

वास्तविक दुनिया में, सूचकांक 1-आधार हैं।

जैसा कि थॉमस ने ऊपर कहा, 0-अड्डों के सूचकांकों का इस्तेमाल करने वाली भाषाएं वास्तव में ऑफसेट का उपयोग कर रही हैं , न कि सूचकांकों का। और डेवलपर्स जो इन भाषाओं का उपयोग कर रहे हैं , वे ऑफ़सेट के बारे में सोचते हैं , न कि सूचकांकों के बारे में । यह एक समस्या नहीं होगी यदि चीजें स्पष्ट रूप से बताई गई थीं, लेकिन वे नहीं हैं। बहुत से डेवलपर्स ऑफ़सेट का उपयोग करते हुए अभी भी सूचकांकों के बारे में बात करते हैं। और इंडेक्स का उपयोग करने वाले बहुत से डेवलपर्स अभी भी नहीं जानते हैं कि सी, सी ++, सी #, ... ऑफसेट का उपयोग करते हैं।

यह एक शब्दांकन समस्या है ।

(डिस्कस्ट्रा के पेपर के बारे में ध्यान दें - यह ठीक कहता है कि मैंने ऊपर क्या कहा है : गणितज्ञ 1-आधारित सूचकांकों का उपयोग करते हैं । लेकिन डिस्कस्ट्रा का मानना ​​है कि मेटमैटिशियन को उनका उपयोग नहीं करना चाहिए क्योंकि कुछ अभिव्यक्ति तब बदसूरत होगी (उदाहरण: 1 <= n <= 0) )। ठीक है, यकीन नहीं है कि वह उस एक पर सही है - उन असाधारण खाली क्रमों से बचने के लिए इस तरह के प्रतिमान बदलाव करना थोड़ा परिणाम के लिए बहुत परेशानी लगता है ...)

Comments

गणितज्ञ हमेशा 1-आधारित सूचकांकों का उपयोग नहीं करते हैं। मैंने देखा है x0 एक अनुक्रम के प्रारंभिक मूल्य के लिए बहुत बार उपयोग किया जाता है। यह जो भी अधिक सुविधाजनक है पर निर्भर करता है।

Answer 21

क्या आप कभी "20 वीं सदी" से वास्तव में 1900 के दशक का जिक्र करते हैं? खैर, यह 1-आधारित सरणियों का उपयोग करते समय हर समय आपके साथ होने वाली थकाऊ चीजों के लिए एक अच्छा सादृश्य है।

.Net IO.stream पठन विधि की तरह एक सामान्य सरणी कार्य पर विचार करें:

int Read(byte[] buffer, int offset, int length)

यहाँ मैं आपको सुझाव देता हूं कि आप खुद को समझाने के लिए 0-आधारित सरणियाँ बेहतर हैं:

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

अब, उनमें से कौन सा कार्यान्वयन सरल है? किसके पास +1 और -1 ऑफसेट यहां और वहां छिड़के गए हैं? बिल्कुल यही मैने सोचा। वास्तव में मैं यह तर्क दूंगा कि अनुक्रमण शैली कोई मायने नहीं रखती है, जब आपको किसी ऐसी चीज़ का उपयोग करना चाहिए था जो सेट की तरह नहीं थी।

Comments

यह फ्लोटिंग पॉइंट के साथ पूर्णांक भ्रामक पूर्णांक लॉजिक है।

Answer 22

इसका कारण यह है कि सरणियों का निर्माण कैसे किया जाता है। यह उनके लिए एक से शुरू करने के लिए बहुत मायने नहीं रखता है। एक सरणी स्मृति, एक आकार और एक सूचकांक में एक आधार पता है। Nth तत्व तक पहुँचने के लिए, यह है:

base + n * element_size

तो 0 स्पष्ट रूप से पहली ऑफसेट है।

Answer 23

वास्तव में इसे लागू करने के कई अलग-अलग तरीके हैं:

• 0-आधारित सरणी सूचकांक
• 1-आधारित सरणी अनुक्रमणिका
• या तो 0 या 1 आधारित सरणियाँ (जैसे VB 6.0 ... यह वास्तव में भयानक है)

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

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

dim i as integer, lb as integer, ub as integer
lb = LBound(array)
ub = UBound(array)
for i = lb to ub
       '...
next

Comments

हाहाहा मुझे याद है कि, वह आदमी जो चूसा ...

— डैन रोसेनस्टार्क

मुझे लगता है कि मुझे याद है कि नकारात्मक संख्याओं से शुरू होने वाले एरेज़ भी हैं। वीबी से दूर रहने के कई कारणों में से सिर्फ एक।

Answer 24

रैखिक संग्रह में किसी आइटम के स्थान के बारे में बात करते समय शून्य स्वाभाविक है ।

पुस्तकों से भरा शेल्फ के बारे में सोचें - पहली पुस्तक शेल्फ की साइड दीवार के साथ फ्लश स्थित है - यह स्थान शून्य है।

इसलिए मुझे लगता है कि यह इस बात पर निर्भर करता है कि क्या आप सरणी सूचकांकों को चीजों को खोजने या चीजों का संदर्भ देने का साधन मानते हैं।

Answer 25

मैं modulo के बाद से 0 आधारित सूचकांक पसंद करता हूं (और modulo के लिए इस्तेमाल किया जाने वाला AND ऑपरेटर) हमेशा कुछ मानों के लिए 0 देता है।

मैं अक्सर अपने आप को इस तरह सरणियों का उपयोग कर पाता हूं:

int blah = array[i & 0xff];

मुझे अक्सर 1 आधारित सूचकांकों का उपयोग करते समय उस तरह के कोड गलत मिलते हैं।

Answer 26

यह बहुत सारे सरणी-आधारित कोड की प्रोग्रामिंग के बिना 0-आधार का बचाव करना कठिन है, जैसे कि स्ट्रिंग खोज और विभिन्न छँटाई / विलय एल्गोरिदम, या एकल-आयाम सरणी में बहुआयामी सरणियों का अनुकरण करना। फोरट्रान 1-आधारित है, और इस तरह के कोड को सही तरीके से प्राप्त करने के लिए आपको बहुत अधिक कॉफी की आवश्यकता होती है।

लेकिन यह उससे आगे जाता है। अपने तत्वों के सूचकांकों के बजाय किसी चीज की लंबाई के बारे में सोचने में सक्षम होना एक बहुत ही उपयोगी मानसिक आदत है। उदाहरण के लिए, पिक्सेल-आधारित ग्राफिक्स करने में, उनके बजाय पिक्सेल के बीच गिरने के रूप में निर्देशांक के बारे में सोचना बहुत स्पष्ट है। इस तरह, एक 3x3 आयत में 9 नहीं बल्कि 9 पिक्सेल होते हैं।

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

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

Answer 27

यह सिर्फ इतना है, और कई सालों से है। इसे बदलने के लिए, या यहां तक ​​कि इस पर बहस करने के लिए, बस ट्रैफिक लाइट को बदलने या बहस करने के रूप में व्यर्थ है। चलो नीला = बंद करो, लाल = जाओ।

C ++ के लिए न्यूमेरिकल रेसिपी में समय के साथ बदलाव देखें। उन्होंने नकली 1-आधारित इंडेक्सिंग के लिए मैक्रोज़ का उपयोग किया था, लेकिन 2001 के संस्करण में झुंड में शामिल हो गए। उनकी साइट www.nr.com पर इसके पीछे के कारणों पर ज्ञानवर्धक सामग्री हो सकती है

BTW, भी कष्टप्रद एक सरणी से बाहर एक सीमा निर्दिष्ट करने के वेरिएंट है। उदाहरण: अजगर बनाम आईडीएल; 100 तत्वों को पाने के लिए [100: 200] बनाम एक [100: 199]। बस प्रत्येक भाषा की बोली सीखना होगा। एक भाषा को बदलने के लिए जो इसे दूसरे से मिलाने का एक तरीका है, जिससे दांतों की ऐसी cussing और gnashing हो जाएगी, और किसी भी वास्तविक समस्या का समाधान नहीं होगा।

Answer 28

मैं 0-आधारित सरणियों को पसंद करता हूं क्योंकि, जैसा कि दूसरों द्वारा बताया गया है, यह गणित को आसान बनाता है। उदाहरण के लिए, यदि हमारे पास 10x10 ग्रिड का अनुकरण करने वाले 100 तत्वों का 1-आयामी सरणी है, तो पंक्ति आर, कॉल सी में तत्व का सरणी सूचकांक I क्या है:

0-आधारित: i = 10 * r + c
1-आधारित: i = 10 * (आर - 1) + सी

और, इंडेक्स i को देखते हुए, पंक्ति और स्तंभ पर वापस जा रहा है:

0-आधारित: c = i% 10
         आर = मंजिल (i / 10)
1-आधारित: c = (i - 1)% 10 + 1
         आर = छत (i / 10)

यह देखते हुए कि 1-आधारित सरणियों का उपयोग करते समय उपरोक्त गणित स्पष्ट रूप से अधिक जटिल है, मानक के रूप में 0-आधारित सरणियों को चुनना तर्कसंगत लगता है।

हालांकि, मुझे लगता है कि कोई यह दावा कर सकता है कि मेरा तर्क त्रुटिपूर्ण है क्योंकि मेरा मानना ​​है कि 1 डी सरणी में 2 डी डेटा का प्रतिनिधित्व करने का एक कारण होगा। मैं C / C ++ में ऐसी कई स्थितियों में भाग चुका हूं, लेकिन मुझे यह स्वीकार करना चाहिए कि इस तरह की संगणना करने के लिए कुछ हद तक निर्भर रहना पड़ता है। यदि सरणियों ने क्लाइंट, सभी समय के लिए सभी इंडेक्स गणित को वास्तव में निष्पादित किया है, तो कंपाइलर आपके एम-आधारित सरणी एक्सेस को संकलन-समय पर 0-आधारित में परिवर्तित कर सकता है और उपयोगकर्ता से इन सभी कार्यान्वयन विवरणों को छिपा सकता है। वास्तव में, किसी भी संकलन-समय स्थिरांक का उपयोग ऑपरेशन के एक ही सेट को करने के लिए किया जा सकता है, हालांकि इस तरह के निर्माणों से शायद समझ से बाहर कोड हो जाएगा।

शायद एक बेहतर तर्क यह होगा कि 1-आधारित सरणियों के साथ एक भाषा में सरणी सूचकांक संचालन की संख्या को कम करने के लिए यह आवश्यक होगा कि पूर्णांक विभाजन का उपयोग छत फ़ंक्शन का उपयोग करके किया जाए। हालांकि, गणितीय दृष्टिकोण से, पूर्णांक विभाजन को शेष शेष r होना चाहिए, जहां d और r दोनों धनात्मक हैं। इसलिए, गणित को सरल बनाने के लिए 0-आधारित सरणियों का उपयोग किया जाना चाहिए।

उदाहरण के लिए, यदि आप N तत्वों के साथ एक लुकअप तालिका उत्पन्न कर रहे हैं, तो मान x के लिए सरणी में वर्तमान मान से पहले निकटतम सूचकांक होगा (लगभग, मानों को अनदेखा करते हुए जहां परिणाम पूर्णांक से पहले पूर्णांक है):

फर्श के साथ 0-आधारित: मंजिल ((एन - 1) * x / xRange)
1-मंजिल के साथ आधारित: मंजिल ((एन - 1) * x / xRange) + 1
छत के साथ 1-आधारित: छत ((एन - 1) * x / xRange)

ध्यान दें कि यदि राउंडिंग डाउन के मानक सम्मेलन का उपयोग किया जाता है, तो 1-आधारित सरणियों को एक अतिरिक्त ऑपरेशन की आवश्यकता होती है, जो अवांछनीय है। इस तरह के गणित को संकलक द्वारा छिपाया नहीं जा सकता है, क्योंकि इसमें पर्दे के पीछे क्या हो रहा है, इसके बारे में निचले स्तर के ज्ञान की आवश्यकता होती है।

Comments

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

Answer 29

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

जहां तक ​​कंप्यूटर का संबंध है और गणितीय रूप से 0 शायद बेहतर होने वाला है, लेकिन मुझे लगता है कि यहां एक बिंदु छूट रहा है। यदि हम चीजों का अधिक मानवीय तरीके से वर्णन करना चाहते हैं (जैसे कक्षाएं), तो हम भाषा के अन्य हिस्सों के लिए ऐसा क्यों नहीं चाहेंगे? क्या यह समान रूप से तार्किक या वैध नहीं है (या उस मामले के लिए उच्च प्राथमिकता ...) एक भाषा को मनुष्यों के लिए अधिक आसानी से समझने योग्य और प्रयोग करने योग्य बनाने के लिए और इस प्रकार, विस्तार से, कम परिदृश्यों की संभावना है जो तर्क-कीड़े और अधिक प्रवण बनाने की प्रवृत्ति रखते हैं प्रयोग करने योग्य निर्माण का तेजी से उत्पादन करने के लिए। PHP उदाहरण:

array(1 => 'January', 'February', 'March');

हमारे अनुरोध के अनुसार 1 आधारित सरणी देता है।

मानदंड क्यों नहीं है:

array('January', 'February', 'March');

और अपवाद हो:

array(0 => 'Value for scenario where 0 *has* to be used as the key',
      'value2', 'value3');

PHP कहने के मामले में, मेरी शर्त 80% है समय 1 आधारित सरणी डिफ़ॉल्ट वाक्यविन्यास-वार होने के कारण वास्तविक दुनिया के उपयोग के मामलों में तर्क-कीड़े कम हो जाएंगे, या कम से कम यह बहुत अधिक होने का कारण नहीं होगा। कोडर पर प्रयोग करने योग्य कोड जल्दी बनाने के लिए आसान है। याद रखें, मैं यह मान रहा हूं कि जब जरूरत होगी तब उसके लिए सरणी (0 => 'मान') का विकल्प होगा, लेकिन यह मानकर भी कि यह वास्तविक दुनिया के विवरण के करीब होने के लिए व्यावहारिक है।

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

तो, यह मेरा दो सेंट है। मुझे गंभीरता से संदेह है कि वह क्या कह रहा था, या क्या व्याख्या की गई थी, उसका क्या मतलब था। वह शायद इसका मतलब था, "मुझे कंप्यूटर को यह बताने का कम सहज तरीका होने से नफरत है कि मुझे क्या चाहिए।" :) क्या हम सब नहीं? जबरदस्त हंसी।

Answer 30

यह संभव है यदि आप अपना "अपना" कोड लिखते समय ध्यान रखते हैं। आप मान सकते हैं कि आपका इंडेक्स n से = n और 0 के लिए शुरू होता है और उसी के अनुसार प्रोग्राम किया जाता है।

मानक के बारे में, बोरेलिड का एक बड़ा तर्क है।