배열에서 요소의 합과 평균을 계산하는 방법은 무엇입니까?
배열의 모든 요소를 추가하고 평균화하는 데 문제가 있습니다. 이 작업을 수행하고 현재 보유한 코드로 어떻게 구현합니까? 요소는 아래에있는 것처럼 정의되어야합니다.
<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>
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 );
값은 문자열이므로 먼저 정수로 변환해야하므로 배열을 반복하십시오. 그리고 평균은 값의 합을 값의 수로 나눈 값입니다.
내가 더 우아하다고 생각하는 해결책 :
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 + "<br/>");
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);reduce 및 ES6을 사용하여 평균 (평균) 계산 :
const average = list => list.reduce((prev, curr) => prev + curr) / list.length;
const list = [0, 10, 20, 30]
average(list) // 15
일반적으로 1 라이너 감소를 사용하는 평균은 다음과 같습니다
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-array-reduce
gotofritz가 지적했듯이 Array.reduce는 정의되지 않은 값을 건너 뜁니다. 그래서 여기에 수정이 있습니다.
(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])
다음과 같은 정수 배열이 있다고 상상해 봅시다.
var values = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
평균은 다음 공식으로 구합니다.
A = (1 / n) Σxi (i = 1 ~ n 인 경우) ... 그래서 : x1 / n + x2 / n + ... + xn / n
현재 값을 값 수로 나누고 이전 결과를 반환 된 값에 추가합니다.
축소 메소드 서명은
reduce(callback[,default_previous_value])
콜백 감소 기능은 다음 매개 변수를 사용합니다.
- p : 이전 계산 결과
- c : 현재 값 (현재 색인에서)
- i : 현재 배열 요소의 색인 값
- a : 전류 감소 어레이
두 번째 reduce의 매개 변수는 기본값입니다 (배열이 비어 있는 경우에 사용됨 ).
따라서 평균 감소 방법은 다음과 같습니다.
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);
};
reduce 메소드가 호출 될 때마다 값을 나눌 수 있습니다.
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;
};
그런 다음 범위의 모든 Array 객체에서
[2, 6].avg();// -> 4
[2, 6].sum();// -> 8
NB : NaN 희망을 반환하는 빈 배열은 내 관점에서 0보다 정확하며 특정 사용 사례에서 유용 할 수 있습니다.
당신은 또한 사용할 수 있습니다 lodash (다른 편리한 물건이) 수학 부분에, _.sum (배열)과 _.mean (배열).
_.sum([4, 2, 8, 6]);
// => 20
_.mean([4, 2, 8, 6]);
// => 5
가장 빠르지는 않지만 가장 짧고 한 줄에 map () & reduce ()를 사용하고 있습니다.
var average = [7,14,21].map(function(x,i,arr){return x/arr.length}).reduce(function(a,b){return a + b})
개인 라이브러리에서 이러한 방법을 사용합니다.
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
에서 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
(많이 미워하는) 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/>");
방금 이것을 '외부'옵션 중 하나로 게시한다고 생각했습니다. 교활함이 당신에게 포인트를 줄 수 있습니다.
여기에 "평균"명령을 추가하기 위해 자바 스크립트의 "Math"객체에 대한 빠른 추가가 있습니다!
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”개체에이 추가 기능이 있습니다!
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”
그리고 자리 표시 자 배열을 넣은 위치는 변수에 전달합니다 (숫자 인 경우 입력은 숫자로 구문 분석하기 때문에 문자열 일 수 있습니다!)
for 루프 카운터를 0으로 설정하십시오 .... 요소 9를 얻었으므로 이제 완료했습니다. 다른 답변은 기본 수학입니다. 변수를 사용하여 합계를 저장하고 (문자열을 정수로 캐스트해야 함) 배열 길이로 나눕니다.
사용하려는 모든 변수를 정의하여 시작하십시오. 당신은에 대한 참고하겠습니다 numbers배열, 내가의 문자 표기법을 사용하고 []생성자 메서드에 반대를 array(). 또한 여러 변수를 0으로 설정하기 위해 더 짧은 방법을 사용하고 있습니다.
var numbers = [], count = sum = avg = 0;
다음으로 0에서 11까지의 값으로 빈 숫자 배열을 채 웁니다. 원래 시작점으로 이동합니다. 내가 어떻게 배열을 추진하고 있는지 주목하십시오 count++. 이렇게하면 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에서 확인하십시오.
Abdennour TOUMI의 답변을 기반으로합니다. 이유는 다음과 같습니다.
1.) Brad에 동의합니다. 우리가 만들지 않은 객체를 확장하는 것은 좋은 생각이 아닙니다.
2.) array.length, 내가 선호하는 자바 스크립트에서 완전히 신뢰할 수있다 Array.reducebeacuse을 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;
};
상록 브라우저에서는 화살표 기능을 사용할 수 있습니다 avg = [1,2,3].reduce((a,b) => (a+b);
이를 10 배로 실행하면 for 루프 접근과 감소 간의 시간 차이는 무시할 수 있습니다.
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.
*/발차기만 :
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 ) ;
};
그런 다음 :
[ 1 , 2 , 3].avg() ; //-> OUT : 2
[{age:25},{age:26},{age:27}].avg(function(e){return e.age}); // OUT : 26
우리가 좋아할 수있을 것 같아
var k=elmt.reduce(function(a,b){return parseFloat(a+parseFloat(b));})
var avg=k/elmt.length;
console.log(avg);
1) (a) 9 + b ( "1") 숫자를 추가하면 결과가 "91"이되지만 추가를 원하기 때문에 parseFloat를 두 번 사용하고 있습니다. 그래서 나는 parseFloat를 사용했다.
2) 결과가 "10"이지만 (a) 9 + parseFloat ( "1")의 추가가 발생하지만 다시 원하지 않는 문자열이 될 것이므로 parseFloat를 사용했습니다.
나는 분명하기를 바랍니다. 제안은 환영 받다
다음은 평균을 간단하게 찾는 신인 방법입니다. 이것이 누군가를 돕기를 바랍니다.
function numAvg(num){
var total = 0;
for(var i = 0;i < num.length; i++) {
total+=num[i];
}
return total/num.length;
}
여기 하나의 라이너가 있습니다 :
var average = arr.reduce((sum,item,index,arr)=>index !== arr.length-1?sum+item:sum+item/arr.length,0)
나는 이것이 for 루프와 함수로 평균을 계산하는 직접적인 해결책 일 수 있다고 생각합니다.
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);
이것에 대한 끝없는 수의 솔루션이있는 것 같지만 간결하고 우아하다는 것을 알았습니다.
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);
If you are in need of the average and can skip the requirement of calculating the sum, you can compute the average with a single call of reduce:
// 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
If anyone ever needs it - Here is a recursive average.
In the context of the original question, you may want to use the recursive average if you allowed the user to insert additional values and, without incurring the cost of visiting each element again, wanted to "update" the existing average.
/**
* 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
How:
this works by maintaining the current average and element count. When a new value is to be included you increment count by 1, scale the existing average by (count-1) / count, and add newValue / count to the average.
Benefits:
- you don't sum all the elements, which may result in large number that cannot be stored in a 64-bit float.
- you can "update" an existing average if additional values become available.
- you can perform a rolling average without knowing the sequence length.
Downsides:
- incurs lots more divisions
- not infinite - limited to Number.MAX_SAFE_INTEGER items unless you employ
BigNumber
Average of HTML content itens
With jQuery or Javascript's querySelector you have direct acess to formated data... Example:
<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>
So, with jQuery you have
var A = $('.m')
.map(function(idx) { return parseInt($(this).html()) })
.get();
var AVG = A.reduce(function(a,b){return a+b}) / A5.length;
See other more 4 ways (!) to access itens and average it: 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
This works with strings as numbers or numbers in the array.
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);
I would recommend D3 in this case. It is the most readable (and provides 2 different kinds of averages)
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);
I had exactly 10 elements (like in the example) so I did:
( elmt[0] + elmt[1] + elmt[2] + elmt[3] + elmt[4] +
elmt[5] + elmt[6] + elmt[7] + elmt[8] + elmt[9] ) / 10
'programing tip' 카테고리의 다른 글
| 크기가 0 인 Linux 삭제 파일 (0) | 2020.06.12 |
|---|---|
| 좋아하는 (영리한) 방어 프로그래밍 모범 사례 (0) | 2020.06.12 |
| “while (1);”최적화 (0) | 2020.06.12 |
| 기록 데이터를 저장하는 방법 (0) | 2020.06.12 |
| iframe, 포함 및 객체 요소의 차이점 (0) | 2020.06.12 |