किसी सरणी में तत्वों के योग और औसत की गणना कैसे करें?

Question

मुझे एक सरणी के सभी तत्वों को जोड़ने के साथ-साथ उन्हें बाहर निकालने में भी समस्याएँ हो रही हैं। मैं यह कैसे करूँगा और इसे उस कोड के साथ लागू करूंगा जो मेरे पास वर्तमान में है? तत्वों को परिभाषित किया जाना चाहिए क्योंकि मेरे पास यह नीचे है।

<script type="text/javascript">
//<![CDATA[

var i;
var elmt = new Array();

elmt[0] = "0";
elmt[1] = "1";
elmt[2] = "2";
elmt[3] = "3";
elmt[4] = "4";
elmt[5] = "7";
elmt[6] = "8";
elmt[7] = "9";
elmt[8] = "10";
elmt[9] = "11";

// Problem here
for (i = 9; i < 10; i++){
  document.write("The sum of all the elements is: " + /* Problem here */ + " The average of all the elements is: " + /* Problem here */ + "<br/>");
}   

//]]>
</script>

Comments

var elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]इतना अच्छा होगा।

— जेम्स मैक्लॉघिन

Answer 1

var sum = 0;
for( var i = 0; i < elmt.length; i++ ){
    sum += parseInt( elmt[i], 10 ); //don't forget to add the base
}

var avg = sum/elmt.length;

document.write( "The sum of all the elements is: " + sum + " The average is: " + avg );

केवल सरणी के माध्यम से पुनरावृत्ति करें, क्योंकि आपके मूल्य तार हैं, उन्हें पहले एक पूर्णांक में बदलना होगा। और औसत केवल मूल्यों की संख्या से विभाजित मूल्यों का योग है।

Comments

केवल सुधार मुझे क्या करना चाहते हैं बदलने के लिए किया जाएगा for(var i = 0; i < elmt.length; i++;)के साथfor(var i = 0, l = elmt.length; i < l; i++)

— दान डी

उस आदमी के नहीं होने या विषय से हटने के लिए नहीं, बल्कि parixInt () में मूलांक तर्क को शामिल करना एक अच्छा अभ्यास है। इसके द्वारा मेरा मतलब है sum += parseInt(elmt[i], 10);कि एल्मट [i] आधार 10 का है। लिंक

— राइडर ब्रूक्स

0 से विभाजन के लिए बाहर देखो (elmt.length मुझे 0 हो सकता है)

— caulitomaz

@BramVanroy लघु कहानी: नहीं, यह हर बार 'एल' सेट नहीं करता है। लंबी कहानी: डैनडी का समाधान प्रदर्शन / गति में सुधार करना है, क्योंकि एक सरणी की लंबाई की जाँच हर एकल पुनरावृत्ति वास्तव में एक स्थानीय चर में लंबाई को संग्रहीत करने और प्रत्येक पुनरावृत्ति को संदर्भित करने की तुलना में धीमी है।

— कैटलिनबेर्टा

@VitoGentile और DanD प्रदर्शन लाभ के लिए कोड की नकल करते हैं जो आधुनिक ब्राउज़र वैसे भी संकलित करते हैं, यह सर्वोत्तम अभ्यास नहीं होना चाहिए।

— नौटी

Answer 2

एक समाधान जिसे मैं अधिक सुरुचिपूर्ण मानता हूं:

const sum = times.reduce((a, b) => a + b, 0);
const avg = (sum / times.length) || 0;

console.log(`The sum is: ${sum}. The average is: ${avg}.`);

Comments

यह <= IE8 पर काम नहीं करेगा, क्योंकि यह Array.prototype.reduce () डेवलपर.

— mozilla.org/en-US/docs/Web/JavaScript/Reference/…

एक संचयी चलती औसत के साथ, आप यह सब कम फ़ंक्शन ( sum/times.lengthचरण की कोई आवश्यकता नहीं ) के भीतर कर सकते हैं :var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);

— zamnuts

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

— gotofritz

ES2015 में यह थोड़ा अधिक सुरुचिपूर्ण है। times.reduce((a,b) => (a+b)) / times.length;

— रे फॉस

@furf 5 साल बाद, यह कई आधुनिक ब्राउज़रों में दिखता है, अधिक सुरुचिपूर्ण "कम ()" तेज (या जितनी तेजी से) है। Chrome 65 में और सबसे फ़ायरफ़ॉक्स कम उस परीक्षण पर बेहतर है।

— सर रॉबर्ट

Answer 3

ES6

const average = arr => arr.reduce( ( p, c ) => p + c, 0 ) / arr.length;
    
const result = average( [ 4, 4, 5, 6, 6 ] ); // 5
    
console.log(result);

Comments

बेहतर:Array.prototype.average = function () { var sum = 0, j = 0; for (var i = 0; i < this.length, isFinite(this[i]); i++) { sum += parseFloat(this[i]); ++j; } return j ? sum / j : 0; };

— गिलाद पेलेग

कृपया, अपने कोड द्वारा बनाई गई वस्तुओं का विस्तार न करें।

— ब्रैड

अद्यतन नहीं करता है: ["RER", "4", "3re", 5, नई वस्तु ()] औसत (); रिटर्न 4.5 के बजाय अपेक्षित 4.5

— लकीलॉके

और लंबाई नहीं होने पर यह समय-समय पर दुर्घटनाग्रस्त हो जाएगा

— जिमी केन

@ जिमीकेन नहीं, यह वापस आ जाएगी NaN।

— बज़्मैन

Answer 4

कम और ES6 का उपयोग करके औसत (माध्य) की गणना :

const average = list => list.reduce((prev, curr) => prev + curr) / list.length;

const list = [0, 10, 20, 30]
average(list) // 15

Comments

एक योग चर jsben.ch/0xUus

— PirateApp

यहां यह 25% का अंतर है। इतना बुरा नहीं है, मुझे लगता है।

— माइकल

Answer 5

आम तौर पर एक-लाइनर कम का उपयोग करने का औसत इस तरह है

elements.reduce(function(sum, a,i,ar) { sum += a;  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

विशेष रूप से पूछे जाने वाले प्रश्न

elements.reduce(function(sum, a,i,ar) { sum += parseFloat(a);  return i==ar.length-1?(ar.length==0?0:sum/ar.length):sum},0);

एक कुशल संस्करण की तरह है

elements.reduce(function(sum, a) { return sum + a },0)/(elements.length||1);

1 मिनट में जावास्क्रिप्ट ऐरे रिड्यूस को समझें http://www.airpair.com/javascript/javascript-arate-seuce

जैसा कि गेटोफ्रिट्स ने बताया है कि Array.reduce skips अपरिभाषित मूल्यों को दर्शाता है। तो यहाँ एक तय है:

(function average(arr){var finalstate=arr.reduce(function(state,a) { state.sum+=a;state.count+=1; return state },{sum:0,count:0}); return finalstate.sum/finalstate.count})([2,,,6])

Comments

elements.length!=0?elements.length:1 इस तरह से भी लिखा जा सकता है: elements.length || 1 जो छोटा है, और पढ़ने में आसान है।

— क्रेज़ल

यह ध्यान रखें कि यह केवल खाली अंतराल के साथ सरणियों के लिए काम करता है

— gotofritz

सुझाव: अपने कोड के स्निपेट्स के अनमनीकृत (वास्तव में बस सुंदर-मुद्रित) संस्करणों को जोड़ें ताकि लोग उन्हें पढ़ सकें। मैं उन्हें अपने आप में संपादित करूँगा, लेकिन मुझे लोगों के उत्तरों को उस सीमा तक बदलना पसंद नहीं है।

— जस्टिन मॉर्गन

Answer 6

आइए कल्पना करें कि हमारे पास इस तरह पूर्णांक की एक सरणी है:

var values = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

औसत निम्न सूत्र के साथ प्राप्त किया जाता है

ए = (1 / एन) ( xi (आई = 1 से एन के साथ) ... तो: X1 / n + x2 / n + ... + xn / n

हम वर्तमान मान को मूल्यों की संख्या से विभाजित करते हैं और पिछले परिणाम को लौटे मूल्य में जोड़ते हैं।

कम विधि हस्ताक्षर है

reduce(callback[,default_previous_value])

कम कॉलबैक फ़ंक्शन निम्न पैरामीटर लेता है:

• पी : पिछले गणना के परिणाम
• सी : वर्तमान मूल्य (वर्तमान सूचकांक से)
• i : वर्तमान सरणी तत्व का सूचकांक मूल्य
• a : करंट कम हुआ एरियर

दूसरा कम करने वाला पैरामीटर डिफ़ॉल्ट मान है ... (उपयोग की गई स्थिति खाली होने पर )।

तो औसत कम करने की विधि होगी:

var avg = values.reduce(function(p,c,i,a){return p + (c/a.length)},0);

यदि आप चाहें तो आप एक अलग फ़ंक्शन बना सकते हैं

function average(p,c,i,a){return p + (c/a.length)};
function sum(p,c){return p + c)};

और फिर बस कॉलबैक विधि हस्ताक्षर को देखें

var avg = values.reduce(average,0);
var sum= values.reduce(sum,0);

या सीधे ऐरे प्रोटोटाइप को संवर्धित करें।

Array.prototype.sum = Array.prototype.sum || function (){
  return this.reduce(function(p,c){return p+c},0);
};

हर बार मूल्य को कम करने की विधि कहा जाता है, इसे विभाजित करना संभव है।

Array.prototype.avg = Array.prototype.avg || function () {
  return this.reduce(function(p,c,i,a){return p+(c/a.length)},0);
};

या इससे भी बेहतर , पहले से परिभाषित Array.protoype.sum () का उपयोग कर

विधि, इस प्रक्रिया को केवल एक बार मेरे डिविजन को अनुकूलित करें :)

Array.prototype.avg = Array.prototype.avg || function () {
  return this.sum()/this.length; 
};

फिर स्कोप के किसी भी ऐरे ऑब्जेक्ट पर:

[2, 6].avg();// -> 4
[2, 6].sum();// -> 8

नायब: एक NaN इच्छा के साथ एक खाली सरणी मेरे दृष्टिकोण में 0 से अधिक सही है और विशिष्ट उपयोग के मामलों में उपयोगी हो सकती है।

Answer 7

आप मठ के हिस्से में भी लॉश , _.sum (सरणी) और _.mean (सरणी) का उपयोग कर सकते हैं (अन्य सुविधाजनक सामान भी)।

_.sum([4, 2, 8, 6]);
// => 20
_.mean([4, 2, 8, 6]);
// => 5

Answer 8

सबसे तेज़ नहीं है, लेकिन सबसे छोटी और एक पंक्ति में मानचित्र () और कम () का उपयोग किया जा रहा है:

var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})

Comments

शायद कम [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0);लेकिन खाली सरणी पर अलग व्यवहार के साथ। यदि आप चाहते हैं कि परिणाम खाली सरणी पर खाली हो:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")

— Valen

ES5 के बाद से @Tobiq का नक्शा और घटिया मानक बहुत कम हैं (2009 में मानकीकृत)

— जोहान ईचावरिया

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / lengthबहुत स्पष्ट, छोटा और बहुत तेज

— Tobiq

@Tobiq, आपका कोड कुछ भी लेकिन स्पष्ट है। इस प्रकार का लूप पहली नज़र में अकल्पनीय है।

— पोर्कोपेक

Answer 9

एक डरपोक तरीका है कि आप इसे कर सकते हैं, हालांकि इसके लिए (बहुत नफरत) eval () के उपयोग की आवश्यकता होती है।

var sum = eval(elmt.join('+')), avg = sum / elmt.length;
document.write("The sum of all the elements is: " + sum + " The average of all the elements is: " + avg + "<br/>");

बस मैंने सोचा कि मैं इसे 'बॉक्स के बाहर' विकल्पों में से एक के रूप में पोस्ट करूँगा। आप कभी नहीं जानते हैं, धूर्तता आपको (या दूर) एक बिंदु प्रदान कर सकती है।

Comments

+1 अच्छा कुशल वन-लाइनर! यदि यह क्लाइंट-ब्राउज़र-ब्राउज़र जावास्क्रिप्ट में है, तो एकमात्र संभावित eval()मुद्दा जो मैं देख सकता हूं, वह यह है कि आपको यह सुनिश्चित करने की आवश्यकता है कि सरणी में केवल संख्याएं हैं (जो निश्चित रूप से यहां अन्य सभी उत्तरों के लिए भी सही है)। गैर-संख्यात्मक प्रविष्टियों के साथ ReferenceErrorया SyntaxError, except nested arrays of numbers which introduce , `एक गलत संख्यात्मक कुल का कारण बनता है। और निश्चित रूप से सर्वर साइड जेएस में, उदा। नोड्स, फिर स्वाभाविक रूप से eval()सुरक्षा मुद्दों को पेश कर सकते हैं। लेकिन यह किसी भी अच्छी तरह से संरचित क्लाइंट-साइड उपयोगों के लिए एकदम सही लगता है।

— user56reinstatemonica8

असल में वहाँ शामिल हो सकता है एक प्रदर्शन मुद्दा है eval()इस तरह - के प्रदर्शन अनुभाग देखें nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood

— user56reinstatemonica8

Answer 10

मैं अपने निजी पुस्तकालय में इन विधियों का उपयोग करता हूं:

Array.prototype.sum = Array.prototype.sum || function() {
  return this.reduce(function(sum, a) { return sum + Number(a) }, 0);
}

Array.prototype.average = Array.prototype.average || function() {
  return this.sum() / (this.length || 1);
}

संपादित करें: उनका उपयोग करने के लिए, बस इसके योग या औसत के लिए सरणी से पूछें, जैसे:

[1,2,3].sum() // = 6
[1,2,3].average() // = 2

Comments

नीट कार्यान्वयन मैंने सोचा था कि मैंने कम करने के बजाय लूप का उपयोग करने के लिए राशि को लागू किया होगा। अभी भी बहुत सफाई से कोडित हालांकि।

— XDS

Answer 11

में ES6 के लिए तैयार ब्राउज़रों इस polyfill सहायक हो सकता है।

Math.sum = (...a) => Array.prototype.reduce.call(a,(a,b) => a+b)

Math.avg = (...a) => this.sum(...a)/a.length;

आप के बीच एक ही कॉल विधि साझा कर सकते हैं Math.sum, Math.avg और Math.max, जैसे कि

var maxOne = Math.max(1,2,3,4) // 4;

आप के रूप में Math.sum का उपयोग कर सकते हैं

var sumNum = Math.sum(1,2,3,4) // 10

या यदि आपके पास योग करने के लिए कोई सरणी है, तो आप उपयोग कर सकते हैं

var sumNum = Math.sum.apply(null,[1,2,3,4]) // 10

बिलकुल इसके जैसा

var maxOne = Math.max.apply(null,[1,2,3,4]) // 4

Comments

के तरीकों को जोड़ने के बजाय Array.prototype, मुझे लगता है कि विषय को Mathवस्तु में जोड़ना एक बेहतर विकल्प है - वे सभी "नंबर हैंडलर" हैं।

— ओबू चेंग

Answer 12

यहाँ जावास्क्रिप्ट में एक "औसत" कमांड जोड़ने के लिए "मठ" ऑब्जेक्ट में एक त्वरित जोड़ है !!

Math.average = function(input) {
  this.output = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.output+=Number(input[this.i]);
  }
  return this.output/input.length;
}

तो मैं इस राशि के लिए "गणित" वस्तु के लिए इसके अलावा है!

Math.sum = function(input) {
  this.output = 0;
  for (this.i = 0; this.i < input.length; this.i++) {
    this.output+=Number(input[this.i]);
  }
  return this.output;
}

तो आप सब करते हैं

alert(Math.sum([5,5,5])); //alerts “15”
alert(Math.average([10,0,5])); //alerts “5”

और जहां मैंने प्लेसहोल्डर एरे लगाई है, बस अपने वेरिएबल में पास करें (यदि वे नंबर हैं तो इनपुट एक स्ट्रिंग हो सकता है क्योंकि यह एक नंबर पर पार्सिंग है!)

Answer 13

लूप काउंटर के लिए अपना सेट 0 पर करें। आप तत्व 9 प्राप्त कर रहे हैं और फिर जैसा कि अब आपके पास है। अन्य उत्तर मूल गणित हैं। अपनी राशि को संग्रहीत करने के लिए एक चर का उपयोग करें (स्ट्रेट्स को तार में डालने की आवश्यकता है), और अपनी सरणी लंबाई से विभाजित करें।

Answer 14

उन सभी चरों को परिभाषित करके शुरू करें जिनका हम उपयोग करने की योजना बना रहे हैं। आप ध्यान देंगे कि numbersसरणी के लिए, मैं []कंस्ट्रक्टर विधि के विपरीत शाब्दिक अंकन का उपयोग कर रहा हूं array()। इसके अतिरिक्त, मैं कई चर को 0 पर सेट करने के लिए एक छोटी विधि का उपयोग कर रहा हूं।

var numbers = [], count = sum = avg = 0;

इसके बाद मैं अपने खाली नंबरों की सरणी को मानों के साथ 0 से 11. पर पॉप्युलेट कर रहा हूं। यह मुझे आपके मूल शुरुआती बिंदु पर लाना है। ध्यान दें कि मैं कैसे सरणी पर जोर दे रहा हूं count++। यह गणना के वर्तमान मूल्य को आगे बढ़ाता है, और फिर अगली बार के लिए इसे बढ़ाता है।

while ( count < 12 )
    numbers.push( count++ );

अंत में, मैं संख्या सरणी में संख्याओं के "प्रत्येक" के लिए एक फ़ंक्शन कर रहा हूं। यह फ़ंक्शन एक बार में एक नंबर को हैंडल करेगा, जिसे मैं फ़ंक्शन बॉडी के भीतर "n" के रूप में पहचान रहा हूं।

numbers.forEach(function(n){
  sum += n; 
  avg = sum / numbers.length;
});

अंत में, हम परिणाम देखने के sumलिए avgमूल्य और हमारे कंसोल के मूल्य दोनों को आउटपुट कर सकते हैं:

// Sum: 66, Avg: 5.5
console.log( 'Sum: ' + sum + ', Avg: ' + avg );

इसे http://jsbin.com/unukoj/3/edit पर ऑनलाइन देखें

Answer 15

मैं सिर्फ अब्देनॉर टुमी के उत्तर पर निर्माण कर रहा हूं। यहाँ कारण हैं:

1.) मैं ब्रैड के साथ सहमत हूं, मुझे नहीं लगता कि यह उस वस्तु का विस्तार करने के लिए एक अच्छा विचार है जिसे हमने नहीं बनाया है।

2.) array.lengthजावास्क्रिप्ट में बिल्कुल विश्वसनीय है, मुझे Array.reduceबीक्युस पसंद है a=[1,3];a[1000]=5;, अब a.lengthवापस आ जाएगा 1001।

function getAverage(arry){
    // check if array
    if(!(Object.prototype.toString.call(arry) === '[object Array]')){
        return 0;
    }
    var sum = 0, count = 0; 
    sum = arry.reduce(function(previousValue, currentValue, index, array) {
        if(isFinite(currentValue)){
            count++;
            return previousValue+ parseFloat(currentValue);
        }
        return previousValue;
    }, sum);
    return count ? sum / count : 0; 
};

Answer 16

Array.prototype.avg=function(fn){
    fn =fn || function(e,i){return e};
    return (this.map(fn).reduce(function(a,b){return parseFloat(a)+parseFloat(b)},0) / this.length ) ; 
};

फिर :

[ 1 , 2 , 3].avg() ;  //-> OUT : 2

[{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26

Answer 17

सदाबहार ब्राउज़रों पर आप तीर फ़ंक्शन का उपयोग कर सकते हैं avg = [1,2,3].reduce((a,b) => (a+b);

इसे 100,000 बार चलाना, लूप अप्रोच और कम करने के बीच का समय अंतर नगण्य है।

s=Date.now();for(i=0;i<100000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("100k reduce took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<100000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("100k for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){n=[1,2,3]; nl=n.length; a=0; for(j=nl-1;j>0;j--){a=a+n[j];} a/nl };
console.log("1M for loop took " + (Date.now()-s) + "ms.");

s=Date.now();for(i=0;i<1000000;i++){ n=[1,2,3]; a=n.reduce((a,b) => (a+b)) / n.length };
console.log("1M reduce took " + (Date.now()-s) + "ms.");

/* 
 * RESULT on Chrome 51
 * 100k reduce took 26ms.
 * 100k for loop took 35ms.
 * 10M for loop took 126ms.
 * 10M reduce took 209ms.
 */

Comments

आप के बारे में console.timeऔर अधिक जानने की जरूरत हैconsole.timeEnd

— अब्देनौर टुमी

@AbdennourTOUMI टिप के लिए धन्यवाद, मैं इसे ध्यान में रखूंगा ... हालांकि यह गैर मानक है और मानकों पर नहीं है। developer.mozilla.org/en-US/docs/Web/API/Console/timeEnd

— रे फॉस

मुझे पता है कि मैं मूल सवालों से पर्दा उठा रहा हूं लेकिन प्रदर्शन माप के लिए प्रदर्शन (सीए) का उपयोग कैसे करूं?

— डेजेबी

@deejbee जो फ्लोटिंग पॉइंट सटीकता की पेशकश करता है ... लेकिन यह भी एक अधिक क्रिया है और कम संगत है। इसके साथ मार्कर सेट करना वास्तविक विश्व कोड में उपयोगी होगा

— रे फॉस

Answer 18

औसत सबसे छोटा एक लाइनर:

let avg = [1,2,3].reduce((a,v,i)=>(a*i+v)/(i+1));

सम सबसे कम एक लाइनर:

let sum = [1,2,3].reduce((a,b)=>a+b);

Answer 19

लातों के लिए:

var elmt = [0, 1, 2,3, 4, 7, 8, 9, 10, 11], l = elmt.length, i = -1, sum = 0;
for (; ++i < l; sum += elmt[i])
    ;
document.body.appendChild(document.createTextNode('The sum of all the elements is: ' + sum + ' The average of all the elements is: ' + (sum / l)));

Answer 20

मुझे लगता है कि हम ऐसा कर सकते हैं

var k=elmt.reduce(function(a,b){return parseFloat(a+parseFloat(b));})
var avg=k/elmt.length; 
console.log(avg);

मैं दो बार parseFloat का उपयोग कर रहा हूं क्योंकि जब 1) आप जोड़ते हैं (ए) 9 + बी ("1") संख्या तब परिणाम "91" होगा लेकिन हम इसके अलावा चाहते हैं। तो मैं parseFloat का इस्तेमाल किया

2) जब (a) 9 + parseFloat ("1") का जोड़ होता है, हालांकि परिणाम "10" होगा, लेकिन यह स्ट्रिंग में होगा जो हम नहीं चाहते कि मैं फिर से parseFloat का उपयोग करूं।

मुझे उम्मीद है कि मैं स्पष्ट हूँ। सुझावों का स्वागत है

Answer 21

यहाँ केवल avg खोजने का मेरा धोखेबाज़ तरीका है। आशा है कि यह किसी की मदद करेगा।

function numAvg(num){
    var total = 0;
    for(var i = 0;i < num.length; i++) { 
        total+=num[i];
    }
    return total/num.length;
}

Answer 22

यहाँ आपका एक लाइनर है:

var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-1?sum+item:sum+item/arr.length,0)

Answer 23

मुझे लगता है कि लूप और फ़ंक्शन के साथ औसत की गणना करने के लिए यह एक सीधा समाधान हो सकता है।

var elmts = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];

function average(arr) {
    var total = 0;
    for (var i = 0; i < arr.length; i++) {
        total += arr[i];
    }
        console.log(Math.round(total/arr.length));
}

average(elmts);

Answer 24

इसके लिए एक अंतहीन संख्या में समाधान प्रतीत होते हैं लेकिन मुझे यह संक्षिप्त और सुरुचिपूर्ण लगता है।

const numbers = [1,2,3,4];
const count = numbers.length;
const reducer = (adder, value) => (adder + value);
const average = numbers.map(x => x/count).reduce(reducer);
console.log(average); // 2.5

या अधिक होशियारी से:

const numbers = [1,2,3,4];
const average = numbers.map(x => x/numbers.length).reduce((adder, value) => (adder + value));
console.log(average); // 2.5

अपने ब्राउज़र के आधार पर आपको स्पष्ट फ़ंक्शन कॉल करने की आवश्यकता हो सकती है क्योंकि तीर फ़ंक्शन समर्थित नहीं हैं:

const r = function (adder, value) {
        return adder + value;
};
const m = function (x) {
        return x/count;
};
const average = numbers.map(m).reduce(r);
console.log(average); // 2.5

या:

const average1 = numbers
    .map(function (x) {
        return x/count;
     })
    .reduce(function (adder, value) {
        return adder + value;
});
console.log(average1);

Comments

आप मैप फंक्शन में एन डिवीजन बना रहे हैं। बेहतर होगा कि पहले सभी नंबरों को घटाकर कुल मूल्य में कर दिया जाए और उसके बाद केवल एक डिविजन बनाया जाए

— यूजेनियो

Answer 25

यदि आपको औसत की आवश्यकता है और योग की गणना करने की आवश्यकता को छोड़ सकते हैं, तो आप औसत को कम करने की एक कॉल के साथ गणना कर सकते हैं:

// Assumes an array with only values that can be parsed to a Float
var reducer = function(cumulativeAverage, currentValue, currentIndex) {
  // 1. multiply average by currentIndex to find cumulative sum of previous elements
  // 2. add currentValue to get cumulative sum, including current element
  // 3. divide by total number of elements, including current element (zero-based index + 1)
  return (cumulativeAverage * currentIndex + parseFloat(currentValue))/(currentIndex + 1)
}
console.log([1, 2, 3, 4, 5, 6, 7, 8, 9, 10].reduce(reducer, 0)); // => 5.5
console.log([].reduce(reducer, 0)); // => 0
console.log([0].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0
console.log([,,,].reduce(reducer, 0)); // => 0
console.log([].reduce(reducer, 0)); // => 0

Answer 26

अगर किसी को कभी भी इसकी आवश्यकता होती है - यहाँ एक पुनरावर्ती औसत है।

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

/**
 * Computes the recursive average of an indefinite set
 * @param {Iterable<number>} set iterable sequence to average
 * @param {number} initAvg initial average value
 * @param {number} initCount initial average count
 */
function average(set, initAvg, initCount) {
  if (!set || !set[Symbol.iterator])
    throw Error("must pass an iterable sequence");

  let avg = initAvg || 0;
  let avgCnt = initCount || 0;
  for (let x of set) {
    avgCnt += 1;
    avg = avg * ((avgCnt - 1) / avgCnt) + x / avgCnt;
  }
  return avg; // or {avg: avg, count: avgCnt};
}

average([2, 4, 6]);    //returns 4
average([4, 6], 2, 1); //returns 4
average([6], 3, 2);    //returns 4
average({
  *[Symbol.iterator]() {
    yield 2; yield 4; yield 6;
  }
});                    //returns 4

किस तरह:

यह वर्तमान औसत और तत्व गणना को बनाए रखकर काम करता है। जब एक नया मूल्य शामिल किया जाना है तो आप 1 से वृद्धि की गणना करें, मौजूदा औसत को स्केल करें (count-1) / count, और जोड़ेंnewValue / count औसत में ।

लाभ:

• आप सभी तत्वों का योग नहीं करते हैं, जिसके परिणामस्वरूप बड़ी संख्या हो सकती है जिसे 64-बिट फ्लोट में संग्रहीत नहीं किया जा सकता है।
• अतिरिक्त मान उपलब्ध होने पर आप मौजूदा औसत को "अपडेट" कर सकते हैं।
• आप अनुक्रम लंबाई को जाने बिना एक रोलिंग औसत प्रदर्शन कर सकते हैं।

downsides:

• बहुत अधिक विभाजनों को लागू करता है
• जब तक आप काम नहीं करते हैं, अनंत - नंबर.मैक्स_एसएएफई_ईएनजीईईआर आइटम तक सीमित नहीं BigNumber

Answer 27

HTML सामग्री का औसत इटेंस

JQuery या जावास्क्रिप्ट के साथ querySelectorआप तैयार डेटा के लिए सीधे acess है ... उदाहरण:

<p>Elements for an average: <span class="m">2</span>, <span class="m">4</span>,
   <span class="m">2</span>, <span class="m">3</span>.
</p>

तो, jQuery के साथ आपके पास है

var A = $('.m')
  .map(function(idx) { return  parseInt($(this).html()) })
  .get();
var AVG = A.reduce(function(a,b){return a+b}) / A5.length;

और अधिक 4 तरीके (!) का उपयोग करें और इसे औसत करने के लिए देखें: http://jsfiddle.net/4fLWB/

Comments

डाउनवोट क्योंकि ओपी ने एक्स करने के लिए कहा और आपने उसे बताया कि वाई तो एक्स कैसे करें। इसके अलावा, डॉम से डेटा बनाने के बजाय डोम से डेटा खींचने का विचार ऐसा लगता है जैसे आप कुछ भी करना चाहते हैं।

— १em:०

हाय @eremzeit, धन्यवाद ध्यान। मैं बोल्ड शीर्षक का उपयोग यह कहने के लिए करता हूं "यह HTML में सामग्री के साथ अन्य मामला है", कृपया इस पर विचार करें ... संबंधित के बारे में, इस तरह का उपयोग (HTML से डेटा का प्रत्यक्ष उपयोग जो उपयोगकर्ता देखते हैं) एक अकादमिक गेम नहीं है ... यह "श्रव्य सत्य" के बारे में है, जो कि HTML में है (!), जावास्क्रिप्ट में "मनुष्यों से छिपा नहीं" ... न केवल विकिपीडिया पर, विशिष्ट मामलों को देखें: पीएमसी में 3.7 मिलियन वैज्ञानिक लेख , विधायी दस्तावेजों के 6.6 मिलियन LexML । कुछ लोग जेएस के साथ केवल डिजाइन और गेम नहीं करते हैं, ऑडिट के लिए उपकरण करते हैं।

— पीटर क्रूस

Answer 28

var arr = [1,2,3,4,5]

function avg(arr){
  var sum = 0;
  for (var i = 0; i < arr.length; i++) {
    sum += parseFloat(arr[i])
  }
  return sum / i;
}

avg (गिरफ्तार) ====== >>>> 3

यह सरणी में संख्याओं या संख्याओं के रूप में स्ट्रिंग्स के साथ काम करता है।

Comments

आपके उत्तर की कुछ व्याख्या क्रम में है।

— डेविड होल्ज़र

आप सही हैं: एक संख्या के रूप में परिभाषित राशि ताकि यह अब काम करे। फ़ंक्शन को एक सरणी खिलाएं और यह सरणी के औसत को बाहर निकालता है।

— डेन चो

Answer 29

    var scores =[90, 98, 89, 100, 100, 86, 94];
        var sum = 0;
        var avg = 0;
        for(var i = 0; i < scores.length;i++){
  //Taking sum of all the arraylist
            sum = sum + scores[i];   
                }
  //Taking average     
             avg = sum/scores.length;        
  //this is the function to round a decimal no    
             var round = avg.toFixed();
             console.log(round);

Comments

ढेर अतिप्रवाह में आपका स्वागत है। आपके उत्तर को विस्तार से बताना चाहिए कि यह प्रश्न का उत्तर क्यों और कैसे देता है। जबकि कोड स्निपेट को प्रोत्साहित किया जाता है, आपको कोड की व्याख्या करनी चाहिए ताकि आगंतुक इसे समझ सकें। गाइड का जवाब देने का तरीका यहां बताया गया है: stackoverflow.com/help/how-to-answer

— ChrisM

Answer 30

मैं इस मामले में डी 3 की सिफारिश करूंगा। यह सबसे पठनीय है (और औसत के 2 विभिन्न प्रकार प्रदान करता है)

let d3 = require('d3');
let array = [1,2,3,4];
let sum = d3.sum(array); //10
let mean = d3.mean(array); //2.5
let median = d3.median(array); 

Comments

केवल एक औसत से बाहर काम करने के लिए पूरे डी 3 को जोड़ने के लिए हास्यास्पद है

— 15-20 पर गॉफिट्ज़