javascript - क्या जावास्क्रिप्ट में सरणी आइटमों के आंशिक रूप से करने का एक बेहतर तरीका है?




arrays functional-programming (7)

आप अंतिम राशि का ट्रैक रखने के लिए एक चर के साथ लूप के for उपयोग कर सकते हैं

let x = [ 0, 1, 2, 3, 4, 5 ]

let sum = (arr) => {
  let sum = 0
  let final = []
  for(let i=0; i<arr.length; i++){
    sum+= arr[i]
    final.push(sum)
  }
  return final
}

console.log(sum(x))

आप मानचित्र का उपयोग भी कर सकते हैं:

let x = [0, 1, 2, 3, 4, 5]

let sum = (arr) => {
  let sum = 0
  return arr.map(current => sum += current )
}

console.log(sum(x))

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

किसी सरणी को x = [ 0, 1, 2, 3, 4, 5 ] , मैंने आइटमों के उप-सरणियों को उत्पन्न किया, और फिर प्रत्येक सरणी के योग की गणना की जो देता है:

[ 0, 1, 3, 6, 10, 15 ]

तो पूर्ण कोड है:

x.map((y,i)=>x.filter((t,j)=>j<=i))
 .map(ii=>ii.reduce((x,y)=>x+y,0))

मुझे आश्चर्य है कि अगर फ्लैट मैप या किसी अन्य सरणी विधि में एक समाधान होगा जिसमें प्रत्येक उपप्रकार के विस्तार की आवश्यकता नहीं है।


आपको बस पिछले परिणाम के लिए हर कदम को वर्तमान मूल्य में जोड़ना होगा, ताकि आप एक सरल कमी का उपयोग कर सकें।

const array = [0, 1, 2, 3, 4, 5, 6];

const sums = array.reduce((acc,current,index) => {
  const prev = acc.length ? acc[index-1] : 0;
  acc.push(prev + current);
  return acc;
},[]);

console.log(sums.toString());


एक पुनरावर्ती फ़ंक्शन का उपयोग करके यहां एक सरल उत्तर दिया गया है।

var array = [ 0, 1, 2, 3, 4, 5 ];

function sumArray(arrayToSum, index){
    if(index < arrayToSum.length-1){
        arrayToSum[index+1] = arrayToSum[index] + arrayToSum[index+1];
        return sumArray(arrayToSum, index+1);
  }else
    return arrayToSum;

}
sumArray(array, 0);

console.log(array);

एक विकल्प एकल .reduce का उपयोग करना है जो कटा हुआ आंशिक सरणी को योग करने के लिए .reduce का उपयोग करता है:

const x = [0, 1, 2, 3, 4, 5];

const sum = (x, y) => x + y;
const partialSums = x.map((_, i, arr) => arr.slice(0, i + 1).reduce(sum));
console.log(partialSums);


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

[0, 1, 2, 3, 4, 5]
.reduce(
   ([arr, sum], el) => { // We pass along array and running sum
       const next = sum + el
       return [[...arr, next], next]
   },
   [[], 0] // We need to seed our reduce with empty array and accumulator for calculating running sum
)[0] // Array containing array and the last sum is returned, so we need to take only the first element

यह सरणी को केवल एक बार पुनरावृत्त करता है, इसलिए यह स्लाइस बनाने वाले समाधान की तुलना में थोड़ा अधिक प्रदर्शन करने वाला हो सकता है और फिर उन्हें समेट सकता है।

या array.push साथ एक संस्करण, जो समान सरणी का पुन: उपयोग करता है:

[0, 1, 2, 3, 4, 5]
.reduce(
   ([arr, sum], el) => { // We pass along array and running sum
       const next = sum + el
       arr.push(next)
       return [arr, next]
   },
   [[], 0] // We need to seed our reduce with empty array and accumulator for calculating running sum
)[0] 

बहुत, एक कुल रनिंग रखकर:

function* partialSums(iterable) {
    let s = 0;

    for (const x of iterable) {
        s += x;
        yield s;
    }
}

const x = [0, 1, 2, 3, 4, 5];
console.log(Array.from(partialSums(x)).join(', '));

रैखिक समय, ऑनलाइन। (आप सीधे एक सरणी भी बना सकते हैं; नीचे विस्तार करें।)

const partialSums = arr => {
    let s = 0;
    return arr.map(x => s += x);
};

const x = [0, 1, 2, 3, 4, 5];
console.log(partialSums(x).join(', '));


यदि आप बाहरी संचयकर्ता चर रखते हैं, तो सीधे मानचित्र का उपयोग करना संभव है:

const x = [ 0, 1, 2, 3, 4, 5 ];

let acc = 0;
const prefixSum = x.map(x => acc += x);

console.log(prefixSum);








prefix-sum