javascript एक एरे के कुछ हिस्सों का योग-जावास्क्रिप्ट




arrays sum (5)

आप slice साथ लूप के for उपयोग कर सकते हैं और जब i == 0 आप len + 1 को स्लाइस कर सकते हैं जो आपको खाली सरणी देने जा रहा है और योग 0 होगा।

function partsSums(arr) {
  const res = [], len = arr.length
  for (let i = len; i > -1; i--) {
    res.push(arr.slice(-i || len + 1).reduce((a, n) => a + n, 0))
  }
  return res;
}

console.log(partsSums([0, 1, 3, 6, 10]));
console.log(partsSums([1, 2, 3, 4, 5, 6]));
console.log(partsSums([744125, 935, 407, 454, 430, 90, 144, 6710213, 889, 810, 2579358]));

आप दो डबल reduce उपयोग भी कर सकते हैं और अगर कोई अगला तत्व शून्य नहीं है।

function partsSums(arr) {
  const sum = arr => arr.reduce((r, e) => r + e, 0);
  return arr.reduce((r, e, i, a) => {
    const res = sum(a.slice(i, a.length));
    return r.concat(!a[i + 1] ? [res, 0] : res)
  }, [])
}

console.log(partsSums([0, 1, 3, 6, 10]));
console.log(partsSums([1, 2, 3, 4, 5, 6]));
console.log(partsSums([744125, 935, 407, 454, 430, 90, 144, 6710213, 889, 810, 2579358]));

कोडवर्ड पर इस चुनौती को हल करने की कोशिश कर रहा है। चुनौती के अनुसार, सरणी के भाग:

ls = [0, 1, 3, 6, 10]

कर रहे हैं

ls = [0, 1, 3, 6, 10]
ls = [1, 3, 6, 10]
ls = [3, 6, 10]
ls = [6, 10]
ls = [10]
ls = []

और हमें उन हिस्सों की रकम के साथ एक सरणी वापस करने की आवश्यकता है।

तो मेरा कोड इस प्रकार है:

function partsSums(ls) {
  let arrayOfSums = []; 
  while(ls.length > 0) {
    let sum = ls.reduce((a, b) => a + b);
    arrayOfSums.push(sum);
    ls.shift();
  }
return arrayOfSums;
}

console.log(partsSums([0, 1, 3, 6, 10]));

मुद्दा यह है कि यह चाहता है कि जब सरणी खाली हो, तो हम अंतिम योग को जोड़ दें। तो हमें मिलना चाहिए:

[२०, २०, १ ९, १६, १०, ०]

के बजाय

[२०, २०, १ ९, १६, १०]

इसलिए मैंने यह कोशिश की:

function partsSums(ls) {
  let arrayOfSums = []; 
  while(ls.length > 0) {
    let sum = ls.reduce((a, b) => a + b);
    arrayOfSums.push(sum);
    ls.shift();
  }
arrayOfSums.push(0);
return arrayOfSums;
}
console.log(partsSums([0, 1, 3, 6, 10]));

और इस:

function partsSums(ls) {
  ls.push(0);
  let arrayOfSums = []; 
  while(ls.length > 0) {
    let sum = ls.reduce((a, b) => a + b);
    arrayOfSums.push(sum);
    ls.shift();
  }
return arrayOfSums;
}

लेकिन ये कोडवर्ड पर निष्पादन समय-आउट त्रुटियों का कारण बने:

निष्पादन समय समाप्त (12000 एमएस)

इसलिए मैंने भी कोशिश की:

function partsSums(ls) {
  let arrayOfSums = []; 
  while(ls.length > -1) {
    let sum = ls.reduce((a, b) => a + b);
    arrayOfSums.push(sum);
    ls.shift();
  }
return arrayOfSums;
}

लेकिन अब यह एक प्रकार का कारण बनता है:

TypeError: बिना किसी प्रारंभिक मान के खाली सरणी को कम करना

मैं इस अवधारणा को नहीं समझ पा रहा हूं कि कैसे सरणी में 0 प्राप्त करें जब सभी मानों को स्थानांतरित कर दिया गया हो। चुनौती सरणी के अंतिम "योग" के रूप में चाहते हैं, भले ही सरणी खाली हो। लेकिन आप एक खाली सरणी को कम नहीं कर सकते हैं - मैं यहां और क्या कर सकता हूं?

संपादित करें : कम करने की विधि में प्रारंभिक मूल्य जोड़ने की कोशिश की:

function partsSums(ls) {
  let arrayOfSums = []; 
  while(ls.length > 0) {
    let sum = ls.reduce((a, b) => a + b, 0);
    arrayOfSums.push(sum);
    ls.shift();
  }
return arrayOfSums;
}

दुर्भाग्य से यह अभी भी मूल परीक्षण में विफल रहता है:

अपेक्षित [] गहराई से बराबर होने के लिए [को ०]


यहाँ एक बात आप कर सकते हैं

function partsSums(ls) {
  if(!ls.length) return [0];
  let prevTotal = ls.reduce((a,b) => a + b);
  return [prevTotal, ...ls.map(val => prevTotal -= val)]
}

console.log(partsSums([0, 1, 3, 6, 10]));


इसे पुनरावर्ती के साथ आज़माएं:

function partsSums(ls) {
  let sum = ls.reduce((a, b) => a + b, 0);
  return  ls.length > 0 ? [sum].concat(partsSums(ls.slice(1))) : [0];
}

console.log(partsSums([0, 1, 3, 6, 10]));
console.log(partsSums([1, 2, 3, 4, 5, 6]));
console.log(partsSums([744125, 935, 407, 454, 430, 90, 144, 6710213, 889, 810, 2579358]));


बार-बार योग की गणना करने का कोई कारण नहीं है। एक लंबी सरणी पर यह बहुत ही अकुशल (O (n))) होगा और आपकी टाइमआउट त्रुटियों की व्याख्या कर सकता है। योग की शुरुआत में गणना करें और फिर प्रत्येक तत्व को एक लूप में घटाएं।

ls = [0, 1, 3, 6, 10]

function partsSums(ls) {
    let sum = ls.reduce((sum, n) => sum + n, 0)
    res  = [sum]
    for (let i = 1; i <= ls.length; i++){
        sum -= ls[i-1]
        res.push(sum )
    }
    return res
}
console.log(partsSums(ls))


आप अंत से पुनरावृति कर सकते हैं और इस मान को सेट परिणाम के अंतिम सम्मिलित मूल्य के साथ ले सकते हैं।

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

function partsSums(ls) {
  var result = [0],
      i = ls.length;
      
  while (i--) {
      result.unshift(ls[i] + result[0]);
  }
  return result;
}

console.log(partsSums([0, 1, 3, 6, 10]));
console.log(partsSums([]));
.as-console-wrapper { max-height: 100% !important; top: 0; }

push और reverse

function partsSums(ls) {
  var result = [0],
      l = 0,
      i = ls.length;
      
  while (i--) result.push(l += ls[i]);
  return result.reverse();
}

console.log(partsSums([0, 1, 3, 6, 10]));
console.log(partsSums([]));
.as-console-wrapper { max-height: 100% !important; top: 0; }







reduce