Como calcular a soma e a média dos elementos em uma matriz?


177

Estou tendo problemas para adicionar todos os elementos de uma matriz e fazer a média deles. Como eu faria isso e o implementaria com o código que tenho atualmente? Os elementos devem ser definidos como eu abaixo.

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

26
var elmt = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]seria muito melhor.
James McLaughlin

Respostas:


134
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 cadeias de caracteres, eles devem ser convertidos em um número inteiro primeiro. E a média é apenas a soma dos valores divididos pelo número de valores.


13
A única melhoria que eu faria seria substituir for(var i = 0; i < elmt.length; i++;)comfor(var i = 0, l = elmt.length; i < l; i++)
Dan D.

5
não ser esse cara ou ficar de fora do tópico, mas é uma boa prática incluir o argumento radix em parseInt (). Por isso quero dizer sum += parseInt(elmt[i], 10);assumindo elmt [i] é da base 10. ligação
Ryder Brooks

9
Cuidado com as divisões por 0 (elmt.length pode me 0)
caulitomaz

2
@BramVanroy Conto: Não, ele não define 'l' toda vez. Longa história: A solução da DanD é melhorar o desempenho / velocidade, porque a verificação do comprimento de uma matriz é cada vez mais lenta do que realmente armazenar o comprimento em uma variável local e fazer referência a cada iteração.
CatalinBerta

9
@VitoGentile e DanD uglificando o código para obter ganhos de desempenho que os Navegadores modernos compilam de qualquer maneira não devem ser as melhores práticas.
nauti

496

Uma solução que considero mais elegante:

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

1
Isso não funcionará no <= IE8, pois não suporta Array.prototype.reduce () Veja mais em developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
aabele

14
com um acumulado de média móvel, você pode fazer tudo isso dentro da função de reduzir (não é necessário para a sum/times.lengthetapa):var avg = times.reduce(function(p,c,i){return p+(c-p)/(i+1)},0);
zamnuts

6
@zamnuts Estou com você, acho que o comentário do Thor84no está totalmente fora de ordem - eu ficaria feliz em ser demitido de um lugar que acha o array.reduce muito complexo. No entanto, eu também não usaria seu código, pelo simples fato de ele ter uma divisão e duas adições extras em cada etapa, o que nunca será tão eficiente quanto uma única divisão no final
gotofritz,

12
No ES2015, é um pouco mais elegante. times.reduce((a,b) => (a+b)) / times.length;
Ray Foss

12
@furf 5 anos depois, parece que em muitos navegadores modernos, o mais elegante "reduzir ()" é mais rápido (ou mais rápido). No Chrome 65 e na maioria dos casos, a redução do firefox é melhor nesse teste.
Sir Robert

116

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


3
Melhorado: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; };
Gilad Peleg 07/10

42
Por favor, não estenda objetos que não foram criados pelo seu código.
Brad

1
UPDATE não funciona para: ["RER", "4", "3re", 5, new Object ()]. ​​Average (); retorna 0 em vez do esperado 4.5 #
Luckylooke 6/14/14

4
E isso vai epically falhar quando não há nenhum comprimento
Jimmy Kane

2
@JimmyKane Não, ele retornará NaN.
bzeaman

37

Cálculo da 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

muito lento em comparação com um simples para a adição com base loop com um variável soma jsben.ch/0xUus
PirateApp

Aqui está uma diferença de 25%. Não é tão ruim, eu acho.
Michael

20

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 para a pergunta

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

Compreender a matriz de Javascript Reduzir em 1 minuto http://www.airpair.com/javascript/javascript-array-reduce

como gotofritz apontou, parece que Array.reduce ignora 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])

2
elements.length!=0?elements.length:1 Também pode ser escrito assim: elements.length || 1 que é mais curto e mais fácil de ler.
4rzael 28/10/2015

2
Tenha em mente que este só funciona para matrizes, sem espaços vazios
gotofritz

1
Sugestão: adicione versões não minificadas (na verdade, apenas impressas) dos seus trechos de código para que as pessoas possam lê-los. Eu os editaria em mim mesmo, mas não gosto de mudar as respostas das pessoas nessa medida.
11557 Justin Morgan

16

Vamos imaginar que temos uma matriz de números 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 para n) ... Então: x1 / n + x2 / n + ... + xn / n

Dividimos o valor atual pelo número de valores e adicionamos o resultado anterior ao valor retornado.

A assinatura do método de redução é

reduce(callback[,default_previous_value])

A função de redução de retorno de chamada utiliza 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 de redução é o valor padrão ... (Usado no caso de a matriz estar vazia ).

Portanto, 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 função separada

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

E, em seguida, basta consultar 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 da matriz diretamente.

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

É possível dividir o valor cada 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 chamando a divisão apenas uma vez :)

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

Então, em qualquer objeto Array do escopo:

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

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


13

Você também pode usar lodash , _.sum (array) e _.mean (array) na parte Math (também possui outros itens convenientes).

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

6

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

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

1
talvez mais curto, [7,14,21].reduce((avg,e,i,arr)=>avg+e/arr.length,0);mas com comportamento diferente na matriz vazia. Se você deseja que o resultado fique vazio na matriz vazia:[].reduce((a,e,i,arr)=>(a?a:0)+e/arr.length,"")
Valen

@Tobiq mapear e reduzir são bastante padrão desde ES5 (padronizado em 2009)
Johann Echavarria

for (var avg = 0, length = i = arr.length; i--;) avg += arr[i] / lengthMuito mais clara, mais curto e mais rápido
Tobiq

2
@Tobiq, seu código é tudo menos claro. Este tipo de loop é ininteligível à primeira vista.
Porkopek

5

Uma maneira sorrateira de fazê-lo, embora exija o uso de (o tão 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 + "<br/>");

Só pensei em postar isso como uma daquelas opções 'fora da caixa'. Você nunca sabe, a astúcia pode lhe conceder (ou tirar) um ponto.


+1 Nice one-liner eficiente! Se for Javascript no navegador do lado do cliente, o único eval()problema possível é que você precisa garantir que a matriz contenha apenas números (o que, obviamente, também é válido para todas as outras respostas aqui). Entradas não numéricas falham com um ReferenceErrorou SyntaxError, except nested arrays of numbers which introduce , `causando um total numérico incorreto. E, é claro, no JS do lado do servidor, por exemplo, node.js, naturalmente eval()pode apresentar problemas de segurança. Mas isso parece perfeito para qualquer uso bem estruturado do lado do cliente.
usar o seguinte comando

1
Na verdade, há talvez um problema de desempenho de incluir eval()como este - veja a seção desempenho de nczonline.net/blog/2013/06/25/eval-isnt-evil-just-misunderstood
user56reinstatemonica8

5

Eu uso esses métodos 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 pedir ao array sua soma ou média, como:

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

Implementação pura, já que eu teria implementado soma para usar um loop for em vez de reduzir. Ainda muito bem codificado embora.
XDS

5

Em navegadores prontos para ES6, esse 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.max, 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ê tiver uma matriz para resumir, poderá 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

Em vez de adicionar métodos Array.prototype, acho que adicionar tema ao Mathobjeto é uma escolha melhor - todos eles são "manipuladores de números".
Oboo Cheng

3

Aqui está uma rápida adição ao objeto "Math" em javascript para adicionar um comando "médio" a 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 objeto "Math" para obter a soma!

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 a matriz de espaço reservado, basta passar sua variável (a entrada, se forem números, pode ser uma string por causa da análise de um número!)


1

defina seu contador de loop for como 0 .... você está obtendo o elemento 9 e, em seguida, está pronto como o possui agora. As outras respostas são matemática básica. Use uma variável para armazenar sua soma (é necessário converter as strings em ints) e divida pelo comprimento da matriz.


1

Comece definindo todas as variáveis ​​que planejamos usar. Você notará que, para a numbersmatriz, estou usando a notação literal []em oposição ao método construtor array(). Além disso, estou usando um método mais curto para definir várias variáveis ​​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 me levar ao seu ponto de partida original. Observe como estou pressionando a matriz count++. Isso pressiona o valor atual de count e o incrementa para a próxima vez.

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

Por fim, estou executando uma função "para cada" dos números na matriz de números. Essa função manipulará um número de cada vez, que eu estou identificando como "n" no corpo da função.

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

No final, podemos gerar o sumvalor e o avgvalor para 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


1

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

1.) Concordo com Brad, não acho que seja uma boa ideia estender um objeto que não criamos.

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

1
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

1

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

Ao executá-lo 100.000 vezes, a diferença de tempo entre a abordagem do 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.
 */


1
Você precisa aprender mais sobre console.time&console.timeEnd
Abdennour TOUMI 4/16

@AbdennourTOUMI Obrigado pela dica, vou ter em mente ... no entanto, não é padrão e não está na trilha dos padrões. developer.mozilla.org/pt-BR/docs/Web/API/Console/timeEnd
Ray Foss

1
Sei que estou saindo das perguntas originais, mas que tal usar o performance.now () para medições de desempenho?
deejbee

@deejbee Isso oferece precisão de ponto flutuante ... mas também é um pouco mais detalhado e menos compatível. Definindo marcadores com que seria útil em código do mundo real
Ray Foss

1

Um forro mais curto médio:

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

Sum Shortest One Liner:

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

0

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

0

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 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") acontece, o resultado será "10", mas será na string que não queremos, então usei parseFloat.

Espero estar claro. Sugestões são bem-vindas


0

Aqui está o meu jeito novato de simplesmente encontrar a média. 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;
}

0

aqui está o seu forro:

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

0

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

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

0

Parece haver um número infinito de soluções para isso, mas eu achei isso 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 de forma mais consistente:

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, pode ser necessário fazer chamadas de função 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);

Você está criando N divisões na função de mapa. É melhor primeiro reduzir todos os números no valor total e, em seguida, fazer apenas uma divisão
Eugenio

0

Se você precisar da média e puder ignorar o requisito de calcular a soma, poderá 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

0

Se alguém precisar - aqui está uma média recursiva.

No contexto da pergunta original, convém usar a média recursiva se você permitir que o usuário insira valores adicionais e, sem incorrer no custo de visitar cada elemento novamente, deseje "atualizar" a média existente.

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

Quão:

isso funciona mantendo a média atual e a contagem de elementos. Quando um novo valor deve ser incluído, você incrementa a contagem em 1, escala a média existente em (count-1) / counte adicionanewValue / count à média.

Benefícios:

  • você não soma todos os elementos, o que pode resultar em um grande número que não pode ser armazenado em um flutuador de 64 bits.
  • você pode "atualizar" uma média existente se valores adicionais estiverem disponíveis.
  • você pode executar uma média móvel sem saber o tamanho da sequência.

Desvantagens:

  • incorre muito mais divisões
  • não infinito - limitado a itens Number.MAX_SAFE_INTEGER, a menos que você use BigNumber

-1

Média de itens de conteúdo HTML

Com jQuery ou Javascript, querySelectorvocê tem acesso direto a dados formatados ... Exemplo:

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

Então, com o 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 (!) De acessar itens e calcule a média: http://jsfiddle.net/4fLWB/


2
Voto negativo porque o OP pediu para fazer X e você lhe disse como fazer Y e X. Além disso, a ideia de extrair dados do DOM em vez de criar o DOM a partir de dados parece algo que você provavelmente deseja evitar.
precisa saber é o seguinte

Oi @eremzeit, obrigado atenção. Uso um título em negrito para dizer "é outro caso, com conteúdo em HTML", por favor, considere ... Sobre relevante, esse tipo de uso (acesso direto a dados de HTML que o usuário vê) não é um jogo acadêmico ... Trata-se da "verdade auditável", que está em HTML (!), Não "escondida dos seres humanos" no javascript ... Não apenas na Wikipedia, veja casos típicos: 3,7 milhões de artigos científicos no PMC , 6,6 milhões de documentos legislativos no LexML . Algumas pessoas não fazem apenas design e jogos com js, fazem ferramentas para auditoria.
Peter Krauss /

-1

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

média (arr) ====== >>>> 3

Isso funciona com cadeias de caracteres como números ou números na matriz.


Alguma explicação da sua resposta está em ordem.
David Hoelzer

Você está certo: soma definida como um número para que isso funcione agora. Alimente a função com uma matriz e ela cospe a média da matriz.
amigos estão dizendo sobre dan chow

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

1
Bem-vindo ao Stack Overflow. Sua resposta deve explicar em detalhes por que e como ela responde à pergunta. Embora os trechos de código sejam incentivados, você deve explicar o código para que os visitantes possam entendê-lo. Há uma forma de guia de resposta aqui: stackoverflow.com/help/how-to-answer
Crisma

-3

Eu recomendaria o 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); 

4
Puxa adicionando todo o D3 apenas para trabalhar fora uma média é ridículo
gotofritz
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.