निम्न नंबर्स के ऐरे पर विचार करें:
const arr = [10, 5, 6, 12, 7, 1];
इसके लगातार तत्वों का योग हर बार एक कम तत्व लेने पर होगा:
[10, 5, 6, 12, 7, 1] = 10 + 5 + 6 + 12 + 7 + 1 = 41; [5, 6, 12, 7, 1] = 5 + 6 + 12 + 7 + 1 = 31; [6, 12, 7, 1] = 6 + 12 + 7 + 1 = 26; [12, 7, 1] = 12 + 7 + 1 = 20; [7, 1] = 7 + 1 = 8; [1] = 1 = 1;
तो, अंतिम आउटपुट ऐसा ऐरे होना चाहिए:
[ 41, 31, 26, 20, 8, 1 ]
हमें एक फ़ंक्शन लिखना आवश्यक है जो ऐसा एक ऐरे लेता है और ऊपर दिए गए उदाहरण में दिखाए अनुसार partialSum ऐरे लौटाता है।
दृष्टिकोण 1: map() और reduce() का एक साथ उपयोग करना
यहां विचार सरल है, चूंकि हमें ऐरे में प्रत्येक तत्व के लिए एक विशेष तत्व लौटाना आवश्यक है, हम Array.prototype.map() मेथड का उपयोग कर सकते हैं जो हमारे लिए ठीक यही करता है।
और यदि हम map() मेथड को विशेष इंडेक्स की तुलना करके आवश्यक तत्वों के कम किए गए योग को लौटाने के लिए बनाते हैं, तो हम काम पूरा कर लेंगे।
इसे करने का कोड यहां है:
const arr = [10, 5, 6, 12, 7, 1];
const partSum = arr.map((item, index) => {
return arr.reduce((acc, val, ind) => {
return ind >= index ? acc+val : acc;
}, 0);
});
console.log(partSum);
दृष्टिकोण 2: रिकर्सिव फ़ंक्शंस का उपयोग करना
यहां हम दो रिकर्सिव फ़ंक्शंस का उपयोग करेंगे,
- पहला है sumRecursively(arr, start) जो start इंडेक्स से लेकर अंत तक arr के तत्वों का योग लौटाता है।
- दूसरा है partSumRecursively() जो आवश्यक योग को ऐरे में रिकर्सिवली कन्कैट करता है और जब हम ऐरे के अंत तक पहुंचते हैं, तो यह कन्कैट किया गया ऐरे लौटाता है।
इसे करने का कोड होगा:
उदाहरण
const arr = [10, 5, 6, 12, 7, 1];
const sumRecursively = (arr, start = 0, res = 0) => {
if(start < arr.length){
return sumRecursively(arr, start+1, res+arr[start]);
};
return res;
};
const partSumRecursively = (arr, partSum = [], start = 0, end = arr.length-1) => {
if(start <= end){
return partSumRecursively(arr, partSum.concat(sumRecursively(arr, start)), ++start, end);
};
return partSum;
};
console.log(partSumRecursively(arr));
आउटपुट
दोनों विधियों के लिए कंसोल में आउटपुट होगा:
[ 41, 31, 26, 20, 8, 1 ]
