सरल घटती सरणी भ्रम - जावा, सरणी

मैं जावा में एक सरल सा तरीका बनाने की कोशिश कर रहा हूँजो भी इनपुट देता है उससे पूर्णांक मान घटने की सूची बना देगा (उदाहरण के लिए यदि N = 10, तो यह एक सरणी लौटाएगा: {10,9,8,7,7,6,6,5,4,3, 2,1}। यह मेरे कोड का एक छोटा सा हिस्सा है और यह सही ढंग से संकलित करता है, लेकिन मुझे रनवे के दौरान शून्य सूचक मिल रहा है। क्या कोई मुद्दा है जो नीचे दिए गए कोड में है?

private static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
for(int i = N; i > 1; i--) {
int q = 0;
a[q] = i;
q++;
}
return a;
}  `

उत्तर:

उत्तर № 1 के लिए 1

आपको शून्य सूचक अपवाद नहीं मिल रहे हैं, आपके कोड में एक इंडेक्स-आउट-ऑफ-रेंज अपवाद है। यह आपके द्वारा उपयोग किए जाने के कारण है। i से N नीचे 1, विशेष, जबकि यह से जाना चाहिए N-1 नीचे 0:

for(int i = N-1, q=0; i >= 0; i--, q++) {
a[q] = i+1;
}

ध्यान दें कि कैसे q तथा i लूप के हेडर में घोषित किया जा सकता है।

आप बिना इस लूप को फिर से लिख सकते हैं q भी:

for(int i = 0 ; i != N ; i++) {
a[q] = N-i;
}

---

उत्तर № 2 के लिए 1

आप शुरू करते हैं q हर पुनरावृत्ति पर 0। क्यों नहीं

private static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
for(int i = N; i >= 1; i--) {
a[i-1] = N - i + 1;
}

return a;
}

वैकल्पिक रूप से, आप उपयोग कर सकते हैं

 private static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
for(int i = 0; i < N; i++) {
a[i] = N - i;
}

return a;
}

जो शायद साफ़ है

---

जवाब के लिए 0 № 3

आप बार-बार स्थिति को अधिलेखित करते हैं 0 बार-बार redeclaring करके अपने सरणी q। यहाँ ठीक है:

private static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
int q = 0;
for(int i = N; i > 1; i--) {
a[q] = i;
q++;
}
return a;
}

---

जवाब के लिए 0 № 4

N ऊपरी बाउंड है। जावा में आकार N के साथ सारणियां 0 से N-1 तक अनुक्रमित की जाती हैं। इसलिए जब आप एक [एन] का संदर्भ लेते हैं, तो यह सीमा से बाहर एक सूचकांक का उल्लेख करेगा।

---

जवाब के लिए 0 № 5

आपके कोड के रूप में यह अब खड़ा आकार की एक सरणी वापस आ जाएगी N लेकिन सरणी का केवल पहला तत्व दस बार अपडेट किया जाएगा। यहाँ क्यों हम आपके कार्यक्रम के तर्क से गुजरते हैं,

create an array of type Integer, sized N
First iteration:
for-loop starts at i=N, let"s make N = 10 for our purposes
q is set to 0 and a[0] is updated to N, which is 10 in the first iteration
q is incremented to 1
i is decremented to 9
Second iteration:
i is now 9
q is set to 0 and a[0] is set to 9
q is incremented to 1
i is decremented to 8

इस बिंदु पर हम समस्या को देख सकते हैं। आप सोच रहे होंगे कि q दूसरे पुनरावृत्ति में 1 से शुरू होना चाहिए और 2 को अपडेट करने के बाद बढ़ाना चाहिए a[1] और नहीं a[0], पर ये स्थिति नहीं है। लूप के प्रत्येक पुनरावृत्ति के साथ एक नया चर q से बना। चलना समाप्त होने के बाद, चर q कचरा इकट्ठा / बाहर फेंक दिया जाता है। इसलिए, समाधान के लिए एक चर का उपयोग करना है जो "लूप फॉर-लूप के प्रत्येक पुनरावृत्ति के बाद बाहर नहीं फेंका जाता है। इसलिए" का उपयोग करें। i बजाय सरणी में एक विशिष्ट सूचकांक का उपयोग करने के लिए

1) एक ही चर i लूप के हर पुनरावृत्ति के साथ पहुँचा जा सकता है और

2) चर i लूप हैडर के आधार पर प्रत्येक पुनरावृत्ति के अंत में स्वचालित रूप से बढ़ा या घटाया जाता है

इसलिए इन परिवर्तनों को लागू करने के परिणामस्वरूप,

private static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
int q = 0;
for(int i = 0; i < N; i++) {
a[i] = N - i;
}
return a;
}

---

जवाब के लिए 0 № 6

आपका कोड इस तरह दिखना चाहिए:

public static Integer[] descendingIntegerArray(int N) {
Integer[] a = new Integer[N];
int q = 0;
for(int i = N - 1; i >= 0; i--) {
a[q] = i + 1;
q++;
}
return a;
}

आपको लूप के लिए q को इनिशियलाइज़ करना होगा, क्योंकि हर बार लूप्स, q को ज़ीरो से इनिशियलाइज़ किया जाता है और यह एक [0] = 10, [0] = 9 और इसी तरह ...

---