Soma de matriz e média

Estou tendo problemas para adicionar todos os elementos de uma matriz e também calculá-los. Como eu poderia fazer isso e implementá-lo com o código que tenho atualmente? Os elementos devem ser definidos como eu tenho abaixo.

 //<![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 */ + "
"); } //]]>

 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 ); 

Basta percorrer a matriz, já que seus valores são strings, eles precisam ser convertidos em um inteiro primeiro. E a média é apenas a sum dos valores dividida pelo número de valores.

Uma solução que considero mais elegante:

 var sum, avg = 0; // dividing by 0 will return Infinity // arr must contain at least 1 element to use reduce if (arr.length) { sum = arr.reduce(function(a, b) { return a + b; }); avg = sum / arr.length; } document.write("The sum is: " + sum + ". The average is: " + avg + "
");

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); 

geralmente média usando one-liner reduzir é assim

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

especificamente a pergunta feita

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

uma versão eficiente é como

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

Entenda o JavaScript Array Reduce em 1 minuto http://www.airpair.com/javascript/javascript-array-reduce

como gotofritz apontou parece Array.reduce pula valores indefinidos. então aqui está uma correção:

 (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]) 

Vamos imaginar que temos uma matriz de inteiros como este:

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

A média é obtida com a seguinte fórmula

A = (1 / n) Σxi (com i = 1 an ) … Então: x1 / n + x2 / n + … + xn / n

Nós dividimos o valor atual pelo número de valores e adicionamos o resultado anterior ao valor retornado.

A assinatura do método reduzir é

 reduce(callback[,default_previous_value]) 

A function de callback de redução usa os seguintes parâmetros:

  • p : Resultado do cálculo anterior
  • c : Valor atual (do índice atual)
  • i : valor do índice do elemento da matriz atual
  • a : A matriz reduzida atual

O segundo parâmetro da redução é o valor padrão … (Usado caso a matriz esteja vazia ).

Então, o método de redução média será:

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

Se preferir, você pode criar uma function separada

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

E, em seguida, simplesmente consulte a assinatura do método de retorno de chamada

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

Ou aumente o protótipo do Array diretamente.

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

É possível dividir o valor toda vez que o método de redução é chamado.

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

Ou melhor ainda , usando o Array.protoype.sum () definido anteriormente

método, otimizar o processo meu chamando a divisão apenas uma vez 🙂

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

Então, em qualquer object Array do escopo:

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

Nota: uma matriz vazia com retorno um desejo NaN é mais correto do que 0 no meu ponto de vista e pode ser útil em casos de uso específicos.

Não é o mais rápido, mas o mais curto e em uma linha está usando map () & reduce ():

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

Você também pode usar lodash , _.sum (array) e _.mean (array) na parte de matemática (também tem outra equipe conveniente).

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

Eu uso esses methods na minha biblioteca pessoal:

 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); } 

EDIT: Para usá-los, basta perguntar a matriz para a sua sum ou média, como:

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

Uma maneira sorrateira que você poderia fazer, embora exija o uso de (o muito odiado) 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 + "
");

Apenas pensei em postar isso como uma daquelas opções ‘fora da checkbox’. Você nunca sabe, a astúcia pode conceder-lhe (ou tirar) um ponto.

Nos navegadores prontos para ES6, este polyfill pode ser útil.

 Math.sum = (...a) => Array.prototype.reduce.call(a,(a,b) => a+b) Math.avg = (...a) => this.sum(...a)/a.length; 

Você pode compartilhar o mesmo método de chamada entre Math.sum , Math.avg e Math.avg , como

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

você pode usar Math.sum como

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

ou se você tem uma matriz para resumir, você pode usar

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

Assim como

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

Aqui está uma rápida adição ao object “Math” em javascript para adicionar um comando “médio” para ele !!

 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; } 

Então eu tenho essa adição ao object "Math" para obter a sum!

 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; } 

Então tudo que você faz é

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

E onde eu coloquei o array placeholder basta passar na sua variável (A input se eles são números pode ser uma string por causa da análise de um número!)

Comece definindo todas as variables ​​que planejamos usar. Você notará que, para a matriz de numbers , estou usando a notação literal de [] em oposição ao método construtor array() . Além disso, estou usando um método mais curto para definir várias variables ​​como 0.

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

Em seguida, estou preenchendo minha matriz de números vazios com os valores de 0 a 11. Isso é para chegar ao seu ponto de partida original. Note como eu estou empurrando para o array count++ . Isso empurra o valor atual da contagem e, em seguida, incrementa-o para a próxima vez.

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

Por último, estou executando uma function "para cada" dos números na matriz de números. Esta function irá lidar com um número de cada vez, que eu estou identificando como "n" dentro do corpo da function.

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

No final, podemos produzir o valor da sum e o valor do avg no nosso console para ver o resultado:

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

Veja em ação online em http://jsbin.com/unukoj/3/edit

Estou apenas construindo a resposta de Abdennour TOUMI. Aqui estão as razões do porquê:

1.) Eu concordo com Brad, eu não acho que é uma boa idéia estender objects que não criamos.

2.) array.length é exatamente confiável em javascript, prefiro Array.reduce beacuse a=[1,3];a[1000]=5; , agora a.length retornaria 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; }; 

Em navegadores sempre-verdes, você pode usar as funções de seta avg = [1,2,3].reduce((a,b) => (a+b);

Executando-o 100.000 vezes, a diferença de tempo entre a abordagem de loop for e a redução é insignificante.

 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. */ 

Calculando a média (média) usando reduzir e ES6:

 const average = list => list.reduce((prev, curr) => prev + curr) / list.length; const list = [0, 10, 20, 30] average(list) // 15 

Defina o seu contador de loop for para 0 …. você está recebendo o elemento 9 e, em seguida, você está feito como você tem agora. As outras respostas são matemática básica. Use uma variável para armazenar sua sum (precisa converter as strings para ints) e divida pelo tamanho da matriz.

Apenas por diversão:

 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))); 
 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 ) ; }; 

Então :

 [ 1 , 2 , 3].avg() ; //-> OUT : 2 [{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26 
 protected void Submit_Click(object sender, EventArgs e) { foreach (ComputerLabReservationList row in db.ComputerLabReservationLists) { if (row.LabNo == lblLabNo.Text && row.ReservationDate == StartCld.Text && row.StartEndTime == ddlstartendtime.Text) { // string display = "This time have been reserved by others. Please reserve again."; // ClientScript.RegisterStartupScript(this.GetType(), "yourMessage", "alert('" + display + "');", true); ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('This time already booked by other. Please insert another time');window.location ='Computerlabs.aspx';", true); } else { ComputerLabReservationList crl = new ComputerLabReservationList() { ResvId = lblreservationid.Text, LabNo = lblLabNo.Text, LecturerId = lblLecturerID.Text, ReservationDate = StartCld.Text, StartEndTime = ddlstartendtime.Text }; db.ComputerLabReservationLists.InsertOnSubmit(crl); db.SubmitChanges(); ScriptManager.RegisterStartupScript(this, this.GetType(), "alert", "alert('Your Reservation was sucessfully');window.location ='MyComputerReservation.aspx';", true); } } } 

Eu acho que podemos fazer como

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

Estou usando o parseFloat duas vezes, porque quando 1) você adiciona (a) 9 + b (“1”), o resultado será “91”, mas queremos adição. então eu usei parseFloat

2) Quando a adição de (a) 9 + parseFloat (“1”) acontecer, o resultado será “10”, mas será em string que não queremos, então usei parseFloat novamente.

Eu espero que eu seja claro. Sugestões são bem vindas

Aqui está a minha maneira novata de simplesmente encontrar o avg. Espero que isso ajude alguém.

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

aqui está o seu um forro:

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

Eu acho que isso pode ser uma solução direta para calcular a média com um loop e function.

 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); 

Parece haver um número infinito de soluções para isso, mas achei que isso fosse conciso e elegante.

 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 

Ou mais consisamente:

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

Dependendo do seu navegador, você pode precisar fazer chamadas de function explícitas porque as funções de seta não são suportadas:

 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 

Ou:

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

Se você está precisando da média e pode pular o requisito de calcular a sum, você pode calcular a média com uma única chamada de redução:

 // 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 

Média de itens do conteúdo HTML

Com o querySelector do jQuery ou do Javascript você tem access direto aos dados formatados … Exemplo:

 

Elements for an average: 2, 4, 2, 3.

Então, com jQuery você tem

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

Veja outras 4 maneiras (!) Para acessar itens e média: http://jsfiddle.net/4fLWB/

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 (arr) ====== >>>> 3

Isso funciona com seqüências de caracteres como números ou números na matriz.

Eu recomendaria D3 neste caso. É o mais legível (e fornece 2 tipos diferentes de médias)

 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); 

Eu tinha exatamente 10 elementos (como no exemplo), então eu fiz:

 ( elmt[0] + elmt[1] + elmt[2] + elmt[3] + elmt[4] + elmt[5] + elmt[6] + elmt[7] + elmt[8] + elmt[9] ) / 10