Reto: calcula otros tipos de promedio

20/30

Lectura

En las clases pr√°cticas de este taller aprendimos a calcular el promedio (media aritm√©tica), la mediana y la moda con JavaScript. En este reto debes encontrar la f√≥rmula de alg√ļn otro tipo de promedio, trabajar con alguno de sus casos de uso √ļtiles y traducirlo a c√≥digo JavaScript.

...

Regístrate o inicia sesión para leer el resto del contenido.

Aportes 90

Preguntas 1

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

Rta1: Utilicé la media armónica
Rta2: Este tipo de media suele utilizarse, principalmente, en velocidades, tiempos, o en el área de la electrónica. Sin embargo, su uso no está muy extendido en otras disciplinas. Ninguno de los elementos puede ser nulo. fuente: Media Armónica.
Rta3: Aquí el código:

const arr5 = [2, 5, 6];
function mediaH(array) {
    if (array.includes(0)) {
        return 'Number must be different from zero.'
    } else {
        let mh = array.length / array.reduce((acc, elem) => acc + (1 / elem), 0);
        return mh;
    }
}
console.log(`Media Armonica: ${mediaH(arr5)}`); 
//Expected output => Media Armonica: 3.4615384615384617


Use Rango y Rango Medio:
Se usan para encontrar la brecha entre los extremos de un conjunto de valores, para verificar que tan separados o juntos se encuentran. Es de mucha utilidad para medir el desempe√Īo de grupos bas√°ndose en resultados lineales e intentar llevarlo lo m√°s cercano a 0 para una igualdad dentro del conjunto.

const valores = [5, 9, 16, 21, 8, 91, 23, 45, 36, 3, 1, 72, 84, 12, 54]

valores.sort((a,b) => a - b) // Ahora tenemos que valores = [1, 3, 5, 8, 9, 12, 16, 21, 23, 36, 45, 54, 72, 84, 91]

const maxNum = valores.length - 1 // 14
const minNum = 0
const rango = valores[maxNum] - valores[minNum] // rango = valores[14] - valores[0] = 91 - 1 = 90
const rangoMedio = (valores[maxNum] + valores[minNum]) / 2 // rango = (valores[14] + valores[0]) / 2 = (91 + 1) / 2 = 92 / 2 = 46

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Promedio geométrico o media geométrica.
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Existen dos usos principales de la media geométrica:

  1. Para promediar porcentajes, indices y cifras relativas y
  2. Para determinar el incremento porcentual promedio en ventas, producción u otras actividades o series económicas de un periodo a otro.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

/* Calculando el promedio geométrico */
// Calcula el promedio geométrico de [2, 3, 8, 27]

const array = [2, 3, 8, 27];
function calcularPromedioGeometrico(array) {
    // raizN(a1*a2*a3*...*aN)
    const multArray = (valorAcumulado, nuevoValor) => {
        return valorAcumulado*nuevoValor;
    }
    const multArrayTotal = array.reduce(multArray);
    
    const promedioGeometrico = Math.pow(multArrayTotal, (1/array.length));
    
    console.log("El promedio geométrico es " + promedioGeometrico);
}
calcularPromedioGeometrico(array); // El promedio geométrico es 6.

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Promedio Ponderado
¬ŅQu√© casos de uso tiene tu tipo de promedio?
se utiliza cuando dentro de una serie de datos, uno de los valores tiene una mayor importancia o hay un dato con mayor peso que el resto. Se puede utlizar por ejemplo en las universidades o escuelas donde cada parcial tiene un valor diferente.
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

function calcularMediaPonderada(arr){
    
    let sumaCredit = 0;
    let noteCredit = 0;

    for (let i = 0; i < arr.length; i++) {
        const element = arr[i];

        noteCredit += element['result'] * element['credit'];
        sumaCredit += element['credit'];
    }

    const mediaPonderada = noteCredit / sumaCredit;
    return mediaPonderada;
}

Media cuadratica

En matemáticas, la media cuadrática, valor cuadrático medio, raíz de la media cuadrática o RMS (del inglés root mean square) es una medida estadística de la magnitud de una cantidad variable. Puede calcularse para una serie de valores discretos o para una función matemática de variable continua por ejemplo movimiento helicoidal. El nombre deriva del hecho de que es la raíz cuadrada de la media aritmética de los cuadrados de los valores.

A veces la variable toma valores positivos y negativos, como ocurre, por ejemplo, en los errores de medida. En tal caso se puede estar interesado en obtener un promedio que no recoja los efectos del signo. Este problema se resuelve, mediante la denominada media cuadrática. Consiste en elevar al cuadrado todas las observaciones (así los signos negativos desaparecen), en obtener después su media aritmética y en extraer, finalmente, la raíz cuadrada de dicha media para volver a la unidad de medida original. La desviación estándar es una media cuadrática.


function mediaCuadratica(lista) {
    var listUpTwo = lista.map((x) => x ** 2)
    console.log(listUpTwo)
    var sum = listUpTwo.reduce(
        (sum = 0, newVal)=>{
            return sum + newVal
        }
    )
    console.log(sum)
    var result = Math.sqrt(sum / lista.length)
    return result
}

¬ŅCu√°l tipo de promedio elegiste para trabajar?
He usado la media geométrica.
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Se usa cuando nuestros datos son porcentajes, indices o medidas que no son exactas sino relativas. Un ejemplo de esto es si quisieramos saber la rentabilidad de una empresa a lo largo de ‚Äún‚ÄĚ a√Īos o si quisieramos saber cu√°nto a mejorado nuestro promedio de calificaciones en comparacion a otros a√Īos.
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
Esta es la formula

Y la he traducido a javascript de la siguiente manera:

const r_array = [20, 10, 12, 14.6, 22.36, 33];

function geomtricMean(array){
    let result = 0;

    result = array.reduce(function(prevValue, currentValue){
        
        return currentValue *= prevValue;
    });
    
    return result ** (1/array.length) ;
}

console.log( geomtricMean(r_array) );
  1. utilicé el rango medio para traducirlo a código
  2. el rango medio funciona tomando el mayor y menor valor de una lista y se obtiene el promedio entre estos dos valores, sirve para definir la extensión del rango de datos
const vector = [20, 30, 10, 5, 50, 40];
ordenarLista(vector);

function ordenarLista(listaDesordenada) {
    function ordenarListaSort(valorAcumulado, nuevoValor) {
      return valorAcumulado - nuevoValor;
    }
    
    const lista = listaDesordenada.sort(ordenarListaSort);

    rangoMedio(lista);

    return lista;
}

function rangoMedio(array) {
    let rangoProm = (array[0] + array[array.length-1]) / 2;
    console.log(rangoProm);
    return rangoProm;    
}
  1. utilicé una array de ejemplo y me dio el resultado, se resuelve usando el método .sort para ordenar el array y luego se saca el promedio de los valores en la primera y ultima posición de este
  1. Promedio o media truncada.

  2. Este promedio elimina entre 5% al 25% de los elementos de mi lista seg√ļn sea el requerimiento, y la eliminaci√≥n se hace en ambos entremos.

    Entonces el uso mas practico es eliminar esos valores atípicos en los extremos que tienden a estar muy distantes de la media real.

    Como en el ejemplo de los salarios, podemos eliminar los salarios de los extremos (como el de Bill Gates).

  3. Necesitamos una lista de valores y el % de elementos a eliminar de mi lista:
    Ejemplo: lista [2,3,5,1,4,25] 10% de eliminación es decir 0.6, redondeamos a 1.
    Vamos a eliminar eliminar entonces el 1er elemento y el ultimo, PERO primero debemos organizar la lista y luego los elementos que quedan le aplicamos una media aritmética como ya la vimos en clases pasada, y esa seria una media truncada.
    Media Truncada = 3.5

Vamos al código.

// Calcular media truncada
// De una lista de valores, vamos a eliminar entre el 5% al 25% (tanto del extremo mas alto como del mas bajo)
// y se calcula una media aritmetica de los valores que queden.

const score = [90,40,70,50,60,80]

function calcularMediaTruncada (array, recorte){
    /* Vamos a calcular segun el recorte requerido, cuantos
    elementos vamos a retirar de nuestro array, desde ambos extremos */
    let lengthFinal = Math.round(array.length * (recorte/100));

    // Condicional por si length es < 1 sea 1
    if(lengthFinal >= 1){
        lengthFinal=lengthFinal
    } else (
        lengthFinal = 1
    )
    // Ordenar array
    array.sort((a , b) => {
        if(a > b) return 1;
        if(a < b) return -1;
        return 0;
        });

    // Ciclo para aplicar metodo segun la cantidad de veces requeridas por el recorte
    for(let i=0; i < lengthFinal; i++){
        array.shift();
        array.pop();
    }
    // A los elementos que quedaron en mi array, aplico media aritmetica
    let sumaArray = array.reduce( (valorAcumulado, valorNuevo) => valorAcumulado + valorNuevo)
    let promedio = sumaArray / array.length;
    console.log(promedio);
    return promedio.toFixed(2);
}
// Colocar como argumento array y porcentaje de recorte segun la norma entre 5% - 25%
calcularMediaTruncada(score, 25);
// 65

// Vamos a calcular la media truncada de la siguiente lista y eliminando primero el 10% de la lista
calcularMediaTruncada([20,2,10,5,22,20,100,43,45,33,95,3], 10);
// 29.60

Pregunta 1: La media aritmética simple
Pregunta 2: Su simplicidad y facilidad de interpretaci√≥n la hacen esencial en diversas √°reas, como an√°lisis de datos, finanzas personales, estad√≠stica descriptiva, evaluaci√≥n de desempe√Īo, predicciones, investigaci√≥n cient√≠fica, gesti√≥n de recursos, evaluaci√≥n de encuestas, proyecciones poblacionales y dise√Īo de pol√≠ticas p√ļblicas.
Pregunta 3: Código:

function promedioNumeros(arrayNP) {

    function sumarTodosElementos(currentValue, initialValue) {
        return currentValue + initialValue;
    }
    const cantidadNumeros = arrayNP.length;
    const sumaN = arrayNP.reduce(sumarTodosElementos);
    const promedio = sumaN / cantidadNumeros;

    return promedio;
}

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media geometrica:La media geom√©trica de n n√ļmeros positivos se obtiene por ellos multiplicando todos juntos y luego tomar la en√©sima ra√≠z

¬ŅQu√© casos de uso tiene tu tipo de promedio?
El peso w de una sustancia que tiene pesos hallados por dos balanzas u y v , resulta w = sqrt( u*v)

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

function calcularMdiaGeometrica(listaNumerosPositivos){
    //La media geom√©trica de n n√ļmeros positivos se obtiene por ellos multiplicando todos juntos y luego tomar la en√©sima ra√≠z

    // primera opccion mediante un ciclo for 
    let productoDeElementos = 1;
    for (let index = 0; index < listaNumerosPositivos.length; index++) {
        const element = listaNumerosPositivos[index];
        productoDeElementos *=element;
    } 

    // segunda opccion mediante metodos de array, en este caso usamos el metodo de reduce
    function productoElement( valorAcumulado, nuevoValor){
        return valorAcumulado * nuevoValor;
    }
    const productoDeElementos2 = listaNumerosPositivos.reduce(productoElement);

    // tercera opccion mediante metodos de array, en este caso usamos el metodo de reduce y arrow function 
    const productoDeElementos3 = listaNumerosPositivos.reduce( ( valorAcumulado, nuevoValor) =>valorAcumulado * nuevoValor);


    const raiz = 1/ listaNumerosPositivos.length;
    const mediaGeometrica = Math.pow(productoDeElementos, raiz);
    console.log({ productoDeElementos, productoDeElementos2, productoDeElementos3, raiz, mediaGeometrica});
    return mediaGeometrica;
}

yo lo hice de esta manera

<code>
let creditos = [];
let productoNotasCreditos = [];

for (let i = 0; i < notes.length; i++) {
    creditos.push(notes[i].credit);
    productoNotasCreditos.push(notes[i].note * notes[i].credit);
}

const sumaCreditos = creditos.reduce((acum, elem) => acum + elem, 0);
const sumaProducto = productoNotasCreditos.reduce((acum, elem) => acum + elem, 0);

const ponderado = sumaProducto / sumaCreditos;
console.log("Tu ponderado es: " + ponderado.toFixed(1)); 

Yo hize la media geometrica, donde la media geometrica de los n√ļmeros 2, 3 y 14 es igual a (2 * 3 * 14) 1/3 = (84) 1/3 = 4,37952. Me quedo asi:

const numbers = [2, 3, 14];

let mediaGeometrica = list => {
let productResult = list.reduce((a,b) => a * b);
let result = Math.pow(productResult, (1/list.length));
console.log(productResult);
return console.log(result);
};

mediaGeometrica(numbers)

Promedio geométrico

Se utiliza para calcular el crecimiento o la tasa de retorno promedio en una serie de valores. Se obtiene multiplicando todos los valores y luego tomando la ra√≠z n-√©sima del producto, donde n es el n√ļmero de valores.

const nums = [1, 3, 9];

function geometricAverage(array) {
    const product = array.reduce(
        (accumulator, currentValue) => accumulator * currentValue
    )
    const average = Math.pow(product, 1/array.length);
    return average
}
geometricAverage(nums)

Promedio Ponderado

  1. ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    Promedio ponderado

  2. ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Las notas de un alumno a lo largo de un semestre universitario tienen distintos pesos, y el promedio final del curso se calcula en función a las notas y pesos.

  3. ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

  • C√≥digo:
  • Test en el navegador:

Definición

En estad√≠stica, el t√©rmino ‚Äúrango medio‚ÄĚ se refiere a la mitad de la amplitud de un conjunto de datos. Es decir, es la diferencia entre el valor m√°ximo y el valor m√≠nimo dividido por dos.

El rango medio puede ser √ļtil para resumir la variabilidad de un conjunto de datos, es importante tener en cuenta que el rango medio es una medida muy sensible a los valores extremos o at√≠picos, ya que se basa en la amplitud del conjunto de datos completo. Por lo tanto, puede ser √ļtil considerar otras medidas de dispersi√≥n, como la desviaci√≥n est√°ndar o el rango intercuartil, para tener una idea m√°s completa de la variabilidad en los datos.

Fórmula

Ejemplo

Para una muestra de valores (3, 5, 8, 6,3), el dato de menor valor Min= 3 y el dato de mayor valor Max= 8.

En código quedaría tal que así:


function ordenarLista(lista){
    const listaOrdenada = lista.sort((a,b)=>a-b); // (3, 3, 5, 6, 8)
    calcularRangoMedio(listaOrdenada); // llamar a la funcion rangoMedio
   
}

function calcularRangoMedio(lista){
   const rangoMedio = (lista[0]+lista[lista.length-1])/2; // con lista[0], obtenemos el elemento menor (3). Y con lista[lista.length-1], el elemento mayot (8)
/*Aplicando la formula quedaría asi: (3+8)2 = 5.5 */
   return rangoMedio;
}

Representación del medio rango:

  • Eleg√≠ la media geom√©trica

  • Lo eleg√≠ porque me pareci√≥ interasante su formulaci√≥n matem√°tica dado que es la ra√≠z n-√©sima del producto de todos los n√ļmeros; es recomendada para datos de progresi√≥n geom√©trica, para promediar razones, inter√©s compuesto y n√ļmeros √≠ndice.

yo utilice la media cuadr√°tica:

<code> 
function mediaCuadratica(lista){
  
 const sumaElementos = lista.reduce((acumulado, item) =>{
    return acumulado += Math.pow(item, 2);
 }, 0); 
 
const res = Math.sqrt((sumaElementos/lista.length));
return res;

};

mediaCuadratica(lista);

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media armónica

¬ŅQu√© casos de uso tiene tu tipo de promedio?
Sirve para calcular promedios de velocidades, tiempos o cálculos en electrónica.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

La fórmula es


Datos:
Una persona sale a correr 10km. Los primeros 2km correa a 15 km/h,
los siguientes 2km a 17km/h,
Los siguientes 2km a 14km/h,
Los siguientes 2km a 13km/h
Y finalmente los √ļltimos 2km a 12km/h

Lo primero que haría es tomar los datos de las velocidades x1,x2,x3,x4,x5 en una array
Luego dividir array.length / (1/15)+(1/17)+(1/14)+(1/13)+(1/12)


const arrayDatos =[15,17,14,13,12]
function mediaArmonica(arrayDatos){
const N = arrayDatos.length
let sumatoriaX = 0;
for(let i=0; i< arrayDatos.length;i++){
    sumatoriaX =  sumatoriaX + (1/(arrayDatos[i]))
}
console.log('Sumatoria: ' + sumatoriaX);
const resultado= N/ sumatoriaX;
console.log('Resultado: '+resultado);
}

mediaArmonica(arrayDatos);

Ya había realizado este reto en un curso pasado, justamente la media ponderada.
Acá comparto mi código.

//((n1*p1)+(n2+p2)+(n3+p3))/(p1+p2+p3)


const mis_notas = [
    {
        course: "Matem√°tica",
        note: 5.2,
        porcent: 3
    },
    {
        course: "Física",
        note: 8.2,
        porcent: 1
    },
    {
        course: "Estadística",
        note: 7.4,
        porcent: 2
    },
    {
        course: "Química",
        note: 5.7,
        porcent: 4
    }
]

const mediaPonderada = notes =>{
    let sumaNotasCreditos=0;
    let sumaCreditos =0;

    notes.forEach(x => {
        sumaNotasCreditos += x.note * x.porcent;
        sumaCreditos += x.porcent;
    });

    let mediaPonderada = (sumaNotasCreditos/sumaCreditos).toFixed(2);

    return mediaPonderada
}

console.log(`Media Ponderada: ${mediaPonderada(mis_notas)}`)
 

Hola a todos.

Para el reto yo utilicé la Media Cuadrática. Este tipo de medida se utiliza cuando se quiere calcular la media de variables que toman valores negativos y positivos. Se suele utilizar cuando el símbolo de la variable no es importante y lo que interesa es el valor absoluto del elemento. Por ejemplo, para calcular la media de errores de medida.
La fórmula que se usa para calcular dicha media está expresada por la ecuación:

En mi caso, el código en JavaScript que utilicé para calcular dicha medida fue el siguiente:

function calculateRMS(list) {
  list = list.map((item) => Math.pow(item, 2));
  const accList = list.reduce((a, b) => a + b);
  return parseFloat(Number.parseFloat(Math.sqrt(accList / list.length)).toFixed(3));
}

En d√≥nde la primera l√≠nea dentro de la funci√≥n se utiliza para elevar al cuadrado cada elemento del arreglo. La segunda l√≠nea es la que calcula la sumatoria de los cuadrados. Y en la √ļltima l√≠nea se calcula la ra√≠z cuadrada de dividir la sumatoria de los cuadrados entre la cantidad de elementos. En esa misma l√≠nea se trunca la salida a mostrar solamente tres d√≠gitos significativos del resultado.
Pueden observar la página desplegada en este enlace y pueden mirar el código en GitHub.

Saludos y nunca paren de aprender ūüíö

Eleg√≠ trabajar con el ‚Äúmedio rango‚ÄĚ, es un tipo de promedio que relaciona el √ļltimo elemento de un conjunto con el primero, los suma y divide a ambos, devolviendonos as√≠ un n√ļmero el cual representa el promedio tomando en cuenta esa relac√≠on, lo considero parecido a la mediana.

//Calcular medio rango 

function RangoMedio(arr) {
    arr.sort((a,b)=>a-b);
    Number(arr);
    Max= arr[arr.length-1];
    Min= arr[0];
    MedioRango= (Max+Min)/2;
    return MedioRango;
}
  1. He usado la MEDIA CUADR√ĀTICA.
  2. La media cuadr√°tica es igual a la ra√≠z cuadrada de la media aritm√©tica de los cuadrados de los datos. Resulta especialmente √ļtil cuando la variable estad√≠stica toma valores positivos y negativos, ya que al hacer el cuadrado de cada dato todos los valores se convierten en positivo.
    He utilizado un ejemplo pr√°ctico de una web de matem√°ticas y lo he traducido a Javascript.!

![](

Y mi código con comentarios de cada paso es:

// Convierto la tabla del ejemplo en un array de objetos
const students = [
  {
    name: 'student1',
    value: 3.94,
    error: 0.94,
  },
  {
    name: 'student2',
    value: 2.58,
    error: -0.42,
  },
  {
    name: 'student3',
    value: 3.51,
    error: 0.51,
  },
  {
    name: 'student4',
    value: 4.29,
    error: 1.29,
  },
  {
    name: 'student5',
    value: 2.05,
    error: -0.95,
  },
];

function rootMeanSquare(array) {
  // 1. Calcular el cuadrado de cada dato estadístico.

  const squareError = array.map((eachStudent) =>
    Math.pow(eachStudent.error, 2)
  );

  // 2. Sumar todos los cuadrados calculados en el paso anterior.
  // 3. Dividir el resultado entre el n√ļmero de datos de la muestra.

  const sumDivSquareError =
    squareError.reduce((total, item) => total + item) / squareError.length;

  // 4. Hallar la raíz cuadrada del valor anterior.

  const squareRootTotal = Number(Math.sqrt(sumDivSquareError).toFixed(2));
  
// 5. El resultado obtenido es la media cuadrática de la muestra estadística.
  return squareRootTotal;
}

rootMeanSquare(students);

Media Aritmética:

const notas=[2,6,8,10,7,5,3]
const number_cuadrado=notas.map((note=>note**2))
const sum_numers=number_cuadrado.reduce((a,b)=>a+b)
const media_aritmetica=Math.sqrt(sum_numers/notas.length)
console.log(sum_numers)
console.log(media_aritmetica) 

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Rango medio.

¬ŅQu√© casos de uso tiene tu tipo de promedio?
El rango medio es el promedio del valor mayor y el valor menor.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

function calcularRangoMedio (lista) {
    const listaO = lista.sort((a, b) => a - b);

    const nElementos = listaO.length;
    const sumaN = (listaO[0] + listaO[1] + listaO[nElementos - 1] + listaO[nElementos - 2]) / 2;

    return 'El rango medio es: ' + sumaN;          
};

Dije que no iba a hacer nada…

PERO AL FINAL TERMINE HACIENOLA!!!

let notas = [
    {nota:80,credito: 5},
    {nota:96,credito: 3},
    {nota:85,credito: 4}
]

function cacularPondarada (listaNotas){
    let sumaNotaCreito = 0;
    let sumaNotas = 0;
    listaNotas.forEach(notas=>{
        sumaNotaCreito += (notas.nota * notas.credito);
        sumaNotas += notas.nota; 
    })
    let resultado = sumaNotaCreito / sumaNotas
    return resultado;
}

Este es el codigo que utilice para hacer la ponderadad.

Espero que les sirva de algo


¬ŅCu√°l tipo de promedio elegiste para trabajar?

  • Eleg√≠ Rango medio para desarrollar el reto

¬ŅQu√© casos de uso tiene tu tipo de promedio?

  • El rango es un valor num√©rico que indica la diferencia entre el valor m√°ximo y el m√≠nimo de una poblaci√≥n o muestra estad√≠stica. Sobre todo en finanzas, el rango es muy √ļtil para observar cu√°n grande podr√≠a llegar a ser una variaci√≥n o cambio.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

const arr = [1,1,2,3,4,9,];

function calcularRango(arr) {
  const suma = arr[0] + arr[arr.length -1];
  const finalResul = suma / 2;
  return finalResul;
}

console.log(`El rango medio es: ${calcularRango(arr)}`)

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Varianza y Desviación Estandar
¬ŅQu√© casos de uso tiene tu tipo de promedio?
**La varianza y la desviación estándar son medidas de dispersión o variabilidad, es decir, indican la dispersión o separación de un conjunto de datos. **
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Reto logrado!!! ūüöÄūüíĽūüí™ūüíö

Tipo de promedio elegido: Rango medio
Caso de uso: Los aparatos electr√≥nicos a veces se clasifican como de ¬ęrango medio¬Ľ, lo que significa que est√°n en el rango de precio medio.
Fórmula: (alto + bajo) / 2

Traducción de la fórmula a código JavaScript:

// Calculando el rango medio

const mobilesPrices = [
	{
		brand: "Samsung",
		price: 50 
	},
	{
		brand: "Samsung",
		price: 150 
	},
	{
		brand: "Samsung",
		price: 550
	},
	{
		brand: "Samsung",
		price: 40 
	},
	{
		brand: "Samsung",
		price: 230
	},
	{
		brand: "Samsung",
		price: 50
	}
];

function calcularRangoMedio(objetcList) {
	const mobilePriceList = objetcList.map(function (mobilesPricesObject) {
		return mobilesPricesObject.price;
	});
	
	const mobilePriceOrderedList = ordenarLista(mobilePriceList);
	const highValue = mobilePriceOrderedList[mobilePriceOrderedList.length - 1];
	const lowValue = mobilePriceOrderedList[0];
	const sumOfHighValueWithLowValue = highValue + lowValue;
	const rangoMedio = sumOfHighValueWithLowValue / 2;

	// console.log({
	// 	mobilePriceList,
	// 	mobilePriceOrderedList,
	// 	highValue,
	// 	lowValue,
	// 	sumOfHighValueWithLowValue,
	// 	rangoMedio
	// });
	return `Los teléfonos de precio medio tendrían un precio de alrededor de $${rangoMedio}`;
}

calcularRangoMedio(mobilesPrices); // 'Los teléfonos de precio medio tendrían un precio de alrededor de $295'
console.log(calcularRangoMedio(mobilesPrices)); // Los teléfonos de precio medio tendrían un precio de alrededor de $295

Rango medio
Se utiliza para encontrar el valor medio entre el numero mínimo y máximo de un conjunto de datos.

let conjunto = [2,5,1,10,11,3,8,7];

function medioRango(conjunto){
    conjunto.sort((a,b)=> a-b);
    let medioRang = (conjunto[0] + conjunto[conjunto.length-1])/ 2;
    return medioRang;
}
medioRango(conjunto)

¬ŅCu√°l tipo de promedio elegiste para trabajar?

El rango medio

¬ŅQu√© casos de uso tiene tu tipo de promedio?

El rango medio está estrechamente relacionado con el rango, una medida de dispersión estadística definida como la diferencia entre los valores máximo y mínimo. Las dos medidas son complementarias en el sentido de que si uno conoce el rango medio y el rango, puede encontrar los valores máximo y mínimo de la muestra.

El rango medio rara vez se usa en el an√°lisis estad√≠stico pr√°ctico, ya que carece de eficiencia como estimador para la mayor√≠a de las distribuciones de inter√©s, porque ignora todos los puntos intermedios y carece de robustez, ya que los valores at√≠picos lo cambian significativamente. De hecho, para muchas distribuciones es una de las estad√≠sticas menos eficientes y menos robustas. Sin embargo, encuentra alg√ļn uso en casos especiales: es el estimador de m√°xima eficiencia para el centro de una distribuci√≥n uniforme, los rangos medios recortados abordan la robustez y, como estimador L, es f√°cil de entender y calcular.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Reto ūüíÄ

¬ŅCu√°l tipo de promedio elegiste para trabajar?

  • Utilice la media cuadr√°tica
    ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    -para calcular la media de variables que toman valores negativos y positivos.
    ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
function mediaCuadratica(array) {
    const sumarArray = array.reduce((valorAcumulado,valorNuevo) => valorAcumulado + Math.pow(valorNuevo,2));

    const valor = sumarArray.toFixed(1)
    const elementos = array.length;
    const total = Math.sqrt(valor / elementos);
    return total;
    
}

Buenas tardes, decidí hacer el cálculo del interés simple:

Le tienes que poner un signo de interrogación para obtener el valor que gustes: ?, ejemplo:

El proyecto:
https://filedn.com/lifwNOcrilRFAvqCvInrtRY/Platzi/Interés_simple_HTML/

Yo utilicé el promedio ponderado con lista de calificaciones y porcentajes.
Ejemplo:
Materia: Ciencias.
La calificación se obtiene mediante estos porcentajes:

  • 70 % Actividades.
  • 10 % Participaci√≥n.
  • 20 % Examen.
    Las calificaciones de un alumno fueron:
  • 8 en el examen.
  • 10 en participaci√≥n.
  • 9 en el examen.

La función acepta dos listas:
Lista de porcentajes:
porc = [70, 10, 20];
Lista de calificaciones:
cal = [8, 10, 9];

let porc = [70, 10, 20];
let cal = [8, 10, 9];

function promedioPonderado(cali, porc) {
    let final = 0;
    let haveSameSize = porc.length === cali.length;
    if (haveSameSize){
        porc = porc.map(item => item/100);
        for (let i = 0; i < porc.length; i++) {
            final = final + (porc[i]*cal[i]);
        }
        return final;

    } else {
        console.log("Las calificaciones y los promedios\ndeben conicidir");
    }

}
console.log(promedioPonderado(cal, porc));

**Me decidí por la media geometrica **
Es recomendada para datos de progresi√≥n geom√©trica, para promediar razones, inter√©s compuesto y n√ļmeros √≠ndice.
fuente: Media geométrica

const setOfElements = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const numberN = setOfElements.length;
console.log(numberN);

const productOfElements = setOfElements.reduce(function (acumulador,valoractual) {
    acumulador = acumulador * valoractual;
    return acumulador;
});
console.log(productOfElements);

const geometricMain = Math.pow(productOfElements, (1/(numberN)));
console.log(geometricMain);

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media armónica
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Para la medición de velocidades ya que tiene mayor sensibilidad a los datos con menor valor
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

//! Calculation of the harmonic average.

const arrayTest4 = [1,2,3,5,8,13,21,34,55];

function harmonicAverage(array) {
    // * Reduce method to obtain a final sum.
    function reduceEngineHarmonicAverage(a, b) {
        return (a) + (1/b);
    };
    const reducedArray = array.reduce(reduceEngineHarmonicAverage);
    console.log('reduced Array is: ' + reducedArray)
    // * Calculation of the length for the N value.
    const NValue = array.length - 1 ;
    // * Final phormula.
    const productHarmonicAverage = NValue / reducedArray ;
    console.log(`El valor de la media armónica es de: ${productHarmonicAverage}`);
}

harmonicAverage(arrayTest4);

//! End of Calculation of the harmonic average.

Para este ejercicio, decidí incluir el percentil. Es una medida estrechamente relacionada con el porcentaje, con una diferencia: el porcentaje se centra siempre en dividir una serie de datos en cien grupos de igual valor, mientras que el percentil realiza la misma operación pero para cualquier otro valor (del 1 al 99). Para esto creé la siguiente función

function calcularPercentil(lista) {
    const inputPercentil = prompt('Introduce el percentil que deseas calcular (Un n√ļmero del 1 al 99):');
    const sumatoria = sumatoriaArray(lista);
    const percentil = (sumatoria * inputPercentil) / 100;

    console.log('El percentil ' + inputPercentil + 'de tu lista es: ' + percentil);
}

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media geométrica.
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Considera todos los valores de la distribución, es menos sensible que la media aritmética a los valores extremos
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

PARA PROMEDIO ARM√ďNICO:


Sus aplicaciones se ven en la obtención de la velocidad media, densidad, óptica, resistencias en paralelo, media aritmética ponderada en finanzas, recuperación de información con machine learning, entre otras ramas.

Se usa principalmente para la tasa del promedio, en otras palabras la media arm√≥nica se utiliza cuando existe la necesidad de dar mayor peso a los elementos m√°s peque√Īos. Se aplica en el caso de tiempos y tarifas medias.

Véase también este enlace

function harmonicMean (list) {
    const nthIndex = list.length;
    let sum = 0;
    const inverseSumArr =  list.map(element => sum += 1/element);
    const inverseSum = inverseSumArr[nthIndex - 1]
    const hMean = nthIndex / inverseSum;
    return hMean;
}

PROMEDIO GEOM√ČTRICO:


‚Äú Se llama promedio geom√©trico porque su interpretaci√≥n tiene que ver con la geometr√≠a. Al calcular un √°rea de un rect√°ngulo como a x b con a‚Ȇb, al encontrar el promedio ¬ęgeom√©trico¬Ľ de los dos lados encontrar√≠amos un rect√°ngulo de lados iguales (un cuadrado) equivalente; es decir, que ese cuadrado tendr√≠a un √°rea igual que la del rect√°ngulo inicial.‚ÄĚ.-Matematicas Empresariales

function geometricMean (list) {
    const nthRoot = list.length;
    const elementsProduct = list.reduce((previousValue, nextValue) => previousValue * nextValue);
    const gMean = Math.pow(elementsProduct, (1/nthRoot));
    return gMean;
}

Realice la Media Geometrica ingresando como parametro el ingreso de ventas por periodo dentro de un array y de hay se obtiene las variaciones que seran nuestra variable x de la formula de la media geometrica que se observa abajo:

'use strict'
console.log(`Ingrese dentro de un array las ventas de cada periodo en el que esten ordenados con la formula MGeometrica`)
function MGeometrica(array){
    const x = []
    let n=0;
    for (let index in array){
    const dato = array[Number(index)+1]/array[index];
    x.push(dato);}
    x.pop();
    n=x.length;
    (n<1)?console.log("No has ingreso el array con los numeros pedidos"):console.log(`El total es: `+Math.pow(x.reduce((a,b)=>a*b),(1/n)));
};

Media aritmética ponderada

const notasEstudiantes = [[10, 10],[6, 5],[10, 8],[3, 1]]

function calcularMediaPonderada(numeros){

    let numerador = 0;
    let denominador = 0;
    
    /*
    [a1*b1]+[a2*b2]+[a3*b3]
    -----------------------
            (b1+b2+b3)
    */

    for(i=0; i < numeros.length; i++){
        numerador += numeros[i][0] * numeros[i][1];
        denominador += numeros[i][1];
    }
    

    return numerador/denominador;

}

console.log(`La Media aritmetica ponderada es es: `, calcularMediaPonderada(notasEstudiantes));

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media Armonica
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Principalmente tiempos, distancias etc.
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Para el ejemplo me base en este que encontre en internet

1. También escogí la media armónica
2. Leí que se utiliza cuando la variable abarca un campo de fluctuación grande, como por ejemplo:
- Porcentaje de contaminación de productos químicos.
- Velocidades.
- Tiempos.
3. Código:

const velocidades = [15, 17, 14, 13, 12];
const promArmVel = calcVel(velocidades);
function calcVel(arr) {
	if (arr.includes(0)) {
		console.log(
			"Para calcular la media armonica ninguno de los elementos puede ser nulo."
		);
	} else {
		let sumVel = 0;
		for (vel of arr) {
			let partialVel = 1 / vel;
			sumVel += partialVel;
		}
		const resultadoVel = Math.round(arr.length / sumVel);
		console.log(
			"La media armonica de las velocidades ingresadas es: " +
				resultadoVel +
				" km/h."
		);
		return resultadoVel;
	}
}

Responde las siguientes preguntas en los comentarios:

  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    La media geométrica
    es un tipo de media que se calcula como la ra√≠z del producto de un conjunto de n√ļmeros estrictamente positivos.
    .
    Formula

  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    se utiliza con más frecuencia para calcular la tasa de crecimiento porcentual promedio de algunas series dadas, a través del tiempo.

  • ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

let list = [2, 7, 4, 7, 2, 4, 1, 7, 3, 8, 4];

function calcularMediaGeometrica(lista){
  let ValoresAcumulados = lista.reduce((acc, elem) => acc * elem, 1);
  let MediaGeometrica = Math.pow(ValoresAcumulados,1/lista.length);
  return MediaGeometrica;
}

console.log(calcularMediaGeometrica(list));
  1. Utilicé la media Armonica
  2. La media armonica suele ser empleada en velocidades,tiempo ,rendimiento etc.c
/**

 Una fabrica de juguetes se asigno a un grupo de 4 trabajadores
 para completar una orden de 700 jugetes y la productividad de
 cada trabajador es diferente segun se muestra en la siguiente tabla:

 ------------------------------------------------
 | Trabajador   |   A   |   B   |   C    |  D   |
 |-----------------------------------------------
 | Productividad| 10min | 6 min |  16min | 4min |
 -------------------------------------------------   
 */
const productividad = [10,6,16,4];

function calcularMediaArmonica(arrayProducti){
    let sum = 0;
    for(let i = 0 ; i<arrayProducti.length;i++){
        sum += 1/arrayProducti[i];;
    }
    const mediaArmonica = arrayProducti.length/sum;
    console.log(`El promedio Armonico de los juguetes es de:${Math.round(mediaArmonica)} juguetes x min`);
}

calcularMediaArmonica(productividad);

media armónica: H = N / (1/x1 + 1/x2 + 1/x3 + 1/x4 + 1/xn)
¬ŅCu√°l tipo de promedio elegiste para trabajar?
media aritmética

¬ŅQu√© casos de uso tiene tu tipo de promedio?
la media armónica suele utilizarse en velocidades, tiempos o medidas electrónicas

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

let arrayVelocidades = [41, 52, 35, 52, 10, 52, 12, 1, 52, 85]

let arrayVelocidadesDividido1 = arrayVelocidades.map(velocidades => 1 / velocidades)

let sumaVelocidades = arrayVelocidadesDividido1.reduce((a, b) => a + b)

console.log(`la media aritmetica de ${arrayVelocidades} es ${arrayVelocidades.length / sumaVelocidades}`);

quiz√°s existan mejores formas de hacerlo, pero lo logre, y eso me hace muy feliz!!ūüėĀūüėĀ

Respuesta: Yo utilicé la media cuadratica.
se la puede usar en el cálculo de la velocidad promedio de un gas…

function MediaCuadratica (array){
    const sumArrayC = array.reduce(function(a , b){
        return (a + b**2);
    },0);
    
    return (Math.sqrt(sumArrayC/array.length)).toFixed(2);
}

Media armónica

1 - Calcula la media armónica.
2 - Evalua que ninguno de los elementos sea igual a 0.

1. Use la media armónica.
2. La media arm√≥nica se calcula dividiendo el n√ļmero total de datos estad√≠sticos entre la suma de los inversos de cada valor.

La media armónica sirve para calcular promedios de velocidades, tiempos o hacer cálculos en electrónica. Esta característica diferencia la media armónica de los otros tipos de medias, que se utilizan frecuentemente en el cálculo medio de precios o porcentajes.
Fuente.

3. Mi código:

function calcularInversaDeDatos(list) {
  const listaInversa = [];

  list.map((item) => listaInversa.push(1 / item));

  return listaInversa;
}

function sumarDatosListaInversa(listaInversa) {
  let sumaDatos;

  sumaDatos = listaInversa.reduce((a, b) => a + b, 0);

  return sumaDatos;
}

function calcularMediaArmonica(list) {
  if (list.includes(0)) {
    return 'Number must be different than 0';    
  }
  
  const listaInversa = calcularInversaDeDatos(list);
  const sumaDatos = sumarDatosListaInversa(listaInversa);
  const mediaArmonica = list.length / sumaDatos;

  return mediaArmonica;
}

// ¬ŅCu√°l tipo de promedio elegiste para trabajar?
Empleé la media armónica
.
.

// ¬ŅQu√© casos de uso tiene tu tipo de promedio?
Es empleado para promediar velocidades, rendimientos y en electr√≥nica. Es sensible a valores muy peque√Īos y no pueden haber valores nulos. Es usualmente menor o igual a la media aritm√©tica. Se define como el cociente entre la cantidad de datos y la suma de los rec√≠procos de cada valor.
.
.
// ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
.
.
.

const listValues = [
    {
        viaje: "Ciudad A",
        velocidad: 80,
    },
    {
        viaje: "Ciudad C",
        velocidad: 110,
    },
    {
        viaje: "Ciudad B",
        velocidad: 90,
    }, 
    {
        viaje: "Ciudad D",
        velocidad: 60,
    }
];

function harmonicMean(array) {
    
    const arrayList = listValues.map( (obj) => obj.velocidad);
    const arrayListReciprocal = arrayList.map( (element) => Number((1 / element).toFixed(3)));
    const denominator = arrayListReciprocal.reduce((a, b) => a + b);
    const harmonic = array.length / denominator;
    
    return harmonic;
}

harmonicMean(listValues);

Media geométrica

  • F√≥rmula matem√°tica

  • C√≥digo JavaScript

Media armónica

  • F√≥rmula matem√°tica

  • C√≥digo JavaScript

Calcule Rango

function calcularRango(lista){

    function comprobacionSort(a, b){
        return a - b;
    }
    const listaOrdenada = lista.sort(comprobacionSort);

    const minNumber = listaOrdenada[0];
    const maxNumber = listaOrdenada[listaOrdenada.length - 1];

    const rango = maxNumber - minNumber;


    console.log({
        listaOrdenada,
        maxNumber,
        minNumber,
        rango
    });

}

<code> 

¬ŅCu√°l tipo de promedio elegiste para trabajar?
En mi caso eleg√≠ la Media Cuadratica que soluciona un problema en caso de que el array posea n√ļmeros negativos
¬ŅQu√© casos de uso tiene tu tipo de promedio?
Se aplica en casos de acciones con reditos e intereses entre otros
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

const lista = [1,-2,3,-4,5]

calcularMediaCuadratica(lista)

function calcularMediaCuadratica(lista) {
    const listaCuadrado = []
    const sumatoria = 0
    const elementoCuadrado = 0

    for (let i = 0; i < lista.length; i++) {
        listaCuadrado.push(Math.pow(lista[i],2))
    }

    calcularPromedio(listaCuadrado)
}

function calcularPromedio(listaCuadrado) {
    function sumarTodosElementos(valorAcumulado, nuevoValor) {
        return valorAcumulado + nuevoValor
    }
    const sumaLista = listaCuadrado.reduce(sumarTodosElementos)
    const promedio = sumaLista / listaCuadrado.length

    const raizCuadradaPromedio = Math.sqrt(promedio)

    console.log(raizCuadradaPromedio);
    return promedio
}

La media arm√≥nica es una medida de posici√≥n central de la estad√≠stica descriptiva. La media arm√≥nica se calcula dividiendo el n√ļmero total de datos estad√≠sticos entre la suma de los inversos de cada valor.

La media armónica sirve para calcular promedios de velocidades, tiempos o hacer cálculos en electrónica. Esta característica diferencia la media armónica de los otros tipos de medias, que se utilizan frecuentemente en el cálculo medio de precios o porcentajes.

Para calcular la media armónica se deben hacer los siguientes pasos:

  • Calcular el inverso de cada dato estad√≠stico de la muestra.
  • Sumar todos los inversos calculados.
  • Dividir el n√ļmero total de datos entre la suma hallada en el paso anterior.
  • El resultado obtenido es la media arm√≥nica de la muestra estad√≠stica.

Enlace de referencia

Código:

const calculateArithmeticAverage = (arr) => {
	return arr.length / arr.map((el) => 1 / el).reduce((a, b) => a + b);
};

hice el de la media geometrica

let listaArray = [1, 5, 3, 4, 5, 6, 7, 8, 9];

function calculoMediaGeometica(lista){
    let multiplicacionElemento = 1;
    for (let index = 0; index < lista.length; index++) {
    const element = lista[index];
    multiplicacionElemento *= element;
    }
    console.log(multiplicacionElemento);

    const mediaGeometica = Math.pow(multiplicacionElemento, -(lista.length));
    console.log(mediaGeometica);
    return mediaGeometica;
}
En el caso mio escogi la media ponderada, este tiene el uso para calcular promedios finales en calificaciones, la forma en que traduje a codigo Javascript es el siguiente: function calcularmediaponderada(lista){    let sumatotalpesos=0;    let sumapesos=0;    for(let i=0;i\

Mi reto es:
Media Geometrica
Definida por

Algunos de sus usos son:

  • Para promediar porcentajes, indices y cifras relativas y.
  • Para determinar el incremento porcentual promedio en ventas, producci√≥n u otras actividades o series econ√≥micas de un periodo a otro.
    Mi traducción a JS
//! Reto -> Media geometrica

function calcularMediaGeometrica(datos) {
  if (datos.some((dato) => dato <= 0)) {
    return "Solo utiliza numeros positivos";
  } else {
    const multiplicacionInterna = datos.reduce(
      (acumulador, nuevoValor) => acumulador * nuevoValor
    );
    const resultado = multiplicacionInterna ** (1 / datos.length);
    return resultado;
  }
}

Si tienen alguna duda no duden en preguntarme!

1.¬ŅCu√°l tipo de promedio elegiste para trabajar?
Promedio Armónico
2.¬ŅQu√© casos de uso tiene tu tipo de promedio?
Algunos caso de uso:
ejemplo, si tienes diferentes velocidades promedio para diferentes segmentos de un recorrido, puedes utilizar el promedio armónico para calcular la velocidad promedio total del recorrido.
Por ejemplo, en sistemas mecánicos o eléctricos, el promedio armónico se utiliza para calcular la frecuencia natural o resonante de un sistema.
otro ejemplo seria en la electrónica, el promedio armónico se utiliza para calcular la resistencia eléctrica equivalente de circuitos.

3.¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

const elementos = [9,6,5,2,7,8,9,4,3,6];
const sumaElementos = elementos.reduce((a, b) => a + 1 / b, 0);
const promedioArm = Math.round(elementos.length / sumaElementos);

console.log("El promedio armónico es: " +  promedioArm);

¬ŅCu√°l tipo de promedio elegiste para trabajar?
La media geométrica

¬ŅQu√© casos de uso tiene tu tipo de promedio?
Es √ļtil para encontrar el promedio de porcentajes, razones, √≠ndices o tasas de crecimiento.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

const arrNum = [65,65,34,875,213,654,34];

function geometricMean(arr) {
  const multiplyNum = arr.reduce((acc, curr) => acc * curr)
  const result = Math.sqrt(Math.pow(multiplyNum, 1/arr.length))
  return result
}

console.log(geometricMean(arrNum))
  • Media geom√©trica.
  • Usos:
    • cuando los valores de la distribuci√≥n de datos cambian de
      forma multiplicativa, y no aditiva.
    • Para promediar porcentajes, indices y cifras relativas.
    • Para determinar el incremento porcentual promedio en ventas, producci√≥n u otras actividades o series econ√≥micas de un periodo a otro.
  • FORMULA:
    n‚ąön1n2n3*‚Ķ < ‚Äď Las cantidade en el promedio geometrico se multiplican y se saca la raiz enesima de su valor.
  • TRADUCCION A JS:
function mediaGeometrica(lista){
  const listaOrdenada = lista.sort((a,b)=>a-b);
  const multiplicacion = listaOrdenada.reduce((a,b)=>a*b); 
  const media = Math.pow(multiplicacion / lista.length)
  return media
}
  1. Promedio geométrico.
  2. Este promedio es √ļtil cuando se trabaja con tasas de crecimiento, rendimientos o cualquier medida que se pueda expresar como una relaci√≥n o proporci√≥n.
  3. Código
// Promedio Geom√©trico = ‚ąö(valor1 * valor2 * ... * valorn)

// Creamos una función que recibirá como parametro una lista de valores de los cuales sacaremos el promedio geométrico.

function promedioGeometrico(listaValores) {

    // Creamos un reduce que nos ayudar√° a multiplicar todos los valores de la lista recibida.

    let multiplicacionTotal = listaValores.reduce((valorAcumulativo, valorNuevo) => {
        return valorAcumulativo * valorNuevo;
    })

    // Dado que con Math.sqrt solo se puede obtener una ra√≠z cuadrada, haremos uso de Math.pow que nos permite sacar la raiz elevando nuestro resultado a una fracci√≥n que ser√° igual a 1 entre el n√ļmero de elementos que est√°n en la lista.

    let resultadoFinal = Math.pow(multiplicacionTotal, (1/listaValores.length))

    // Retornamos el resultado.
    
    return resultadoFinal;
}

Respuesta 1: El promedio geométrico
Respuesta 2: Este tipo de promedio se utiliza para calcular caídas o ascenso en porcentajes

const numbers = [9,16];
function getPromedioGeometrico(array) {
	let cantidad = array.length;
	let valorMult = array.reduce((cons,num) => cons * num);
	let promedio = Math.pow(valorMult, 1 / cantidad);
	return promedio
}

Esta fue mi solucion:

const notes = [
    {
        course: "Educación Física",
        note: 10,
        credit: 2,
    },
    {
        course: "Programación",
        note: 8,
        credit: 5,
    },
    {
        course: "Finanzas personales",
        note: 7,
        credit: 5,
    },
];

let mira = notes.map(item =>{
    let coco = item.note * item.credit
    return coco
})

let ahora = mira.reduce((item1, item2) => item2 += item1)

let denominador = notes.map(item=> item.credit).reduce((item1,item2)=> item2 += item1)

let promedioPonderado = ahora / denominador

console.log(promedioPonderado) 
const matematica = [
    {
        name: 'PC1',
        pc: 15,
        peso: 0.15
    },
    {
        name: 'PC2',
        pc: 11,
        peso: 0.25
    },
    {
        name: 'PC3',
        pc: 12,
        peso: 0.30
    },
    {
        name: 'EF',
        pc: 11,
        peso: 0.30
    }
]

const notasConPeso = matematica.map((n)=>n.pc*n.peso);
const sumaDeNotasConPeso = Math.round(notasConPeso.reduce((a,b)=>a+b));
console.log(sumaDeNotasConPeso);

Usé el promedio ponderado:

       let noteArray = [10, 8, 7];
    let creditArray = [2, 5, 5];

     function sumElements (noteArray, creditArray){
        let result = 0 ;
        for(var i = 0 ; i < noteArray.length; i++){
            result+= (creditArray[i] * noteArray[i]);
        }
        return result;
     }

     function sumDenominator (creditArray){
        let result = 0 ;
        for(var i = 0 ; i < creditArray.length; i++){
            result+= creditArray[i];
        }
        return result;
     }

     const resultO = sumElements(creditArray, noteArray);
     const resultD = sumDenominator(creditArray);
     const result = resultO / resultD;
     return console.log(`resultado: ${result}`  );

const calcMediaArmonica=(...valores)=>{

    const inversos=valores.map(elem=>{
        return 1/elem
    })

   const sumInversos= inversos.reduce((acum, valor)=>{
        return acum + valor
   })

   return valores.length/sumInversos
}


console.log(calcMediaArmonica(15,17,14,13,12));

Yo lo hice con la media cuadr√°tica ūüėÉ

function calcularMediaCuadratica(lista){
    const listaAlCuadrado = lista.map(item => Math.pow(item,2));
    const sumOfCuadrados = listaAlCuadrado.reduce((a,b)=> a + b);
    const mediaCuadratica = Math.sqrt(sumOfCuadrados/lista.length);
    console.log('La media cuadratica es '+ mediaCuadratica);
}

  1. ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    En mi caso, utilicé la media armónica.

  1. ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Es utilizado para el calcular promedio en velocidades, en el campo de la electrónica más que nada. Ya que estas se encuentran relacionadas con el tiempo.

  1. ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
    Aquí les muestro mi ejemplo:

function calcularMediaArmonica(salarios){
  const cantidadSalarios = salarios.length;

  let sumaDenominador = sumaInversos(salarios)

  let mediaArmonica = cantidadSalarios / sumaDenominador;
  debugger
  return mediaArmonica;
}

function sumaInversos(salaries){
  let suma = 0;

  salaries.forEach(sal => suma += 1/sal)

  return suma;
}

Hago mi aporte con media aritmetica

function mediaCuadratica(lista){
    let total=lista.reduce(function(acumulado,valor){
        return acumulado+Math.pow(valor,2);
    });

    return Math.sqrt(total/lista.length).toFixed(2);
}

mediaCuadratica([2,4,5,6]);

Media cuadr√°tica

const muestra = [
  {
    valor: 3.94,
    error: 0.94,
  },
  {
    valor: 2.58,
    error: -0.42,
  },
  {
    valor: 3.51,
    error: 0.51,
  },
  {
    valor: 4.29,
    error: 1.29,
  },
  {
    valor: 2.05,
    error: -0.95,
  },
];
function mediaCuadratica(muestra) {
  const num = muestra.map((obMuestra) => obMuestra.error);
  const sumNum = num.reduce((a, b) => a + Math.pow(b, 2));

  return Math.sqrt(sumNum / num.length);
}

console.log(mediaCuadratica(muestra));

Yo lo resolví así con arrow functions

const notes = [
    {
        course: "Educación Física",
        note: 10,
        credit: 2,
    },
    {
        course: "Programación",
        note: 8,
        credit: 5,
    },
    {
        course: "Finanzas personales",
        note: 7,
        credit: 5,
    },
];
const notesWithCredits = notes.map(noteObject => { //Guardamos en un array los valores multiplicados de note * credit. para despues sumarlo
    return noteObject.note * noteObject.credit;
});
const sumOfNotesWithCredit = notesWithCredits.reduce((suma, newVal) => suma + newVal); //sumamos los valores del array notesWithCredits.
const sacarCredits = notes.map(creditObj => {//ahora sacaremos los creditos para despues sumarlos
    return creditObj.credit;
});
const sumaCredits = sacarCredits.reduce((sum, newValue) => sum + newValue); //Ya que tenemos el array solo con los creditos, sumamos estos creditos

console.log("El promedio ponderado es: " + sumOfNotesWithCredit/sumaCredits) //Solo queda dividir para imprimir el resultado
  1. el promedio ponderado

  2. calcula la calificacion final de un alumno a lo largo del a;o

  3. aca mi codigo

HTML:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Notas finales</title>
</head>
<body>
<form action="">
    <label for="calif">Nota</label>
    <input type="number" id="calif" min="0" max="10">
    <label for="weight">Porcentaje del curso cubierto</label>
    <input type="number" id="power">
    
    <input type="button" id="addNewCalif" value="Archivar nota">
    <input type="button" id="killCalif" value="Borrar notas">
    <input type="button" id="calcAverage" value="Promediar nota Anual">
</form>

<p>Total de Porcentaje: <span id="percent">100</span></p>

<table>
    <thead>
    <tr>
        <th>Numero de Examen</th>
        <th>Nota</th>
        <th>Ponderacion</th>
    </tr>
</thead>
<tbody id="tableBody">
    
</tbody>
</table>

<p id="msg"></p>

<script src="function.js"></script>
</body>
</html>

Y mi JS

const addNewCalifBtn = document.getElementById('addNewCalif');
const killCalifBtn = document.getElementById('killCalif');
const calcAverageBtn = document.getElementById('calcAverage');
const totalPower = document.getElementById('percent');
let counter = 0;
let allCalif = [];



const addNewCalif = (event) => {
    event.preventDefault();

    const califInput = document.getElementById('calif');
    const powerInput = document.getElementById('power');
    let calif = califInput.value;
    let power = powerInput.value;
    let table = document.getElementById('tableBody');

    if(0 <= calif && calif <= 10 ){

        msg.innerHTML = '';

        if(0 <= (Number(totalPower.innerText) - power) && (Number(totalPower.innerText) - power) <= 100){

            counter++;

            

            allCalif.push({
                'number': counter,
                'calif': calif,
                'power': power,
            });

            let newRow = document.createElement('tr')
            let testNumCol = document.createElement('td')
            let califCol = document.createElement('td')
            let powerCol = document.createElement('td')

            testNumCol.textContent = `N¬į ${counter}`;
            califCol.textContent = calif;
            powerCol.textContent = `${power} %`;
            
            newRow.appendChild(testNumCol);
            newRow.appendChild(califCol);
            newRow.appendChild(powerCol);

            table.appendChild(newRow);

            califInput.value = '';
            powerInput.value = '';

            totalPower.innerHTML = Number(totalPower.innerText) - power;

        } else {
            let msg = document.getElementById('msg');

            msg.innerHTML = 'ERROR: TU EXAMEN SUPERA LA CURRICULA ESCOLAR'

        }
    } else {
        msg.innerHTML = 'ERROR: TU NOTA NO CONCUERDA CON LA ESCALA CALIFICATORIA'
    }
}

const killCalif = (event) => {
    event.preventDefault();

    let table = document.getElementById('tableBody');
    let msg = document.getElementById('msg'); 

    while(table.firstChild){
        table.removeChild(table.firstChild)
    }

    totalPower.innerHTML = '100'
    counter = 0;
    allCalif.length = 0;
    msg.textContent = '';
}

const calcAverage = (event) => {
    event.preventDefault();

    let numerador = 0;
    let denominador = 0;
    let msg = document.getElementById('msg');
    
    allCalif.map(calification => {
        numerador = numerador + (Number(calification.calif) * Number(calification.power))
        denominador = denominador + Number(calification.power)
    })

    const average = numerador / denominador;

    msg.innerHTML = `El promedio de edad de los miembros es de ${average}`
}


addNewCalifBtn.addEventListener('click', addNewCalif);
killCalifBtn.addEventListener('click', killCalif);
calcAverageBtn.addEventListener('click', calcAverage);


 

MEDIA ARMONICA

 function mediaPonderada(lista) {
  let listaModificada = lista.map(function(element){
    return 1 / element;
  })
  
  const listaFinal = listaModificada

  const total = listaFinal.reduce((a, b) => a + b, 0);
  const promedio = lista.length / total;
  const  promedioFinal = promedio.toFixed(4);
  return promedioFinal;
}

mediaPonderada([15, 17, 14, 13, 12]) 

PROMEDIO GEOMETRICO

  1. Para promediar porcentajes, índices y cifras relativas

  2. Para determinar el incremento porcentual promedio en ventas, producción u otras actividades o series económicas de un periodo a otro.

dos maneras de resolverlo

const arrayNumeros = [3, 2, 4, 6]

function calcularPromedioGeometrico (lista){
    let multi = 1 ;
    let promedio;

    for (let i = 0; i< lista.length; i++){
        multi = (lista[i] * multi);
    }

    promedio = Math.pow(multi, (1/arrayNumeros.length))

    console.log({multi, promedio});
    return promedio
}

calcularPromedioGeometrico(arrayNumeros)


function calcularPromedioGeometrico2 (lista){
    function multiElement (valorAcomulado, nuevoValor){
        return valorAcomulado * nuevoValor
    }

    const multip = lista.reduce(multiElement)
    const promedio = Math.pow(multip, (1/arrayNumeros.length))

    console.log({multip, promedio});

}
calcularPromedioGeometrico2(arrayNumeros)

¬ŅCu√°l tipo de promedio elegiste para trabajar?
// Utilice la media ponderada
¬ŅQu√© casos de uso tiene tu tipo de promedio?
// La media ponderada es √ļtil en una variedad de casos de uso en los que se necesite dar mayor importancia a ciertos valores en una serie de datos. Por ejemplo, calificaciones, finanzas, investigaci√≥n cient√≠fica, encuestas. etc‚Ķ
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
//

const fechas = [ 
    {
        mes: "abril",
        diasDelMes: 31,
        diasFestivos: 5,
    },
    {
        mes: "agosto",
        diasDelMes: 30,
        diasFestivos: 10,
    },
    {
        mes: "febrero",
        diasDelMes: 28,
        diasFestivos: 3,
    },
];

const diasMesConDiasFestivos = fechas.map(function(diasObject) {
    return diasObject.diasDelMes * diasObject.diasFestivos;
});

const sumaDeDiasMesConDiasFestivos = diasMesConDiasFestivos.reduce(function(suma, nuevoValor) {
    return suma + nuevoValor;
}, 0);

const festivos = fechas.map(function(diasObject) {
    return diasObject.diasFestivos;
});

const sumaDeFestivos = festivos.reduce(function(suma, nuevoValor) {
    return suma + nuevoValor;
}, 0);

const PromedioPonderadoDiasMesConDiasFestivos = sumaDeDiasMesConDiasFestivos / sumaDeFestivos;

console.log(PromedioPonderadoDiasMesConDiasFestivos);

Aprovechando el array entregado, esto fue lo que hice ūüėõ

let notesCredit = 0;
let sumCredit = 0;
let sumnotesCredit = 0;
let promedio = 0;


for (let i = 0; i < notes.length ; i++){
	notesCredit = notes[i].note * notes[i].credit;
	sumCredit +=  notes[i].credit;
	sumnotesCredit += notesCredit;
}

promedio = sumnotesCredit / sumCredit
console.log(promedio)

RPTA1: Media cuadr√°tica
RPTA2: La media cuadrática es una medida de posición central de la estadística descriptiva. La media cuadrática es igual a la raíz cuadrada de la media aritmética de los cuadrados de los datos. La principal ventaja de la media cuadrática es que con ella conseguimos una muy buena aproximación del valor medio de una variable discreta.

RPT3:

arrayCuadratica = [0.94,-0.42,0.51,1.29,-0.95];

function mediaCuadr√°tica(array){
    let sumatoria = array.reduce((acumulado,element) => acumulado + (element**2));
    let media = sumatoria/array.length;
    let mediaCuadr√°tica = Math.sqrt(media).toFixed(2);
    return Number(mediaCuadr√°tica);
}

¬ŅQu√© tipo de promedio se eligi√≥ para trabajar?

Se eligió trabajar con el promedio geométrico.

¬ŅQu√© casos de uso tiene?

Es una medida de tendencia central que se utiliza para indicar cambios porcentuales. Tiene aplicación en negocios y economía, por lo que es importante establecer el cambio porcentual en las ventas en el producto interno bruto o en cualquier serie económica.

¬ŅC√≥mo traducir la formula a JavaScript?

Si el crecimiento de las ventas en un negocio fue en los tres √ļltimos a√Īos de 26%, 32% y 28%, hallar la media anual del crecimiento.

Factor de crecimiento:

  • FC = 1 + (porcentaje de crecimiento / 100)
const courses = [
    {
        name: 'Crecimiento Empresa # 1',
        date: 'Mes 1',
        percent: 26,  
    },

    {
        name: 'Crecimiento Empresa # 2',
        date: 'Mes 2',
        percent: 32,
    },

    {
        name: 'Crecimiento Empresa # 3',
        date: 'Mes 3',
        percent: 28,
    },
];

const averageCourses = courses.map( function(testsObject){
    return 1 + (testsObject.percent/100);
});



const multiplyAverage = averageCourses.reduce(
    function (mult = 1, newVal){
        return  mult * newVal
    }
);


const root = 1 / (averageCourses.length);
const resultRoot = Math.pow(multiplyAverage, root);
const promedioGeometrico = resultRoot;


console.log(promedioGeometrico);

Decidi que el array con los datos, me los iba a mandar el usuario, a partir de crear los 3 input, salio esto.

const datos1 = [];
function enviarDato (){
    datos1.push([[asignatura.value], [nota.value], [credito.value]]);
    p.innerText += `${datos1}
   `;
}
function calcularPromedioPonderado1(){
    let arrayCreditos = [];
    datos1.map(element=> arrayCreditos.push(parseInt(element[2])));
    const notasXcreditos = datos1.map(element => element[1]*element[2]);
    const creditosReduce = arrayCreditos.reduce((a,b)=> a + b);
    console.log(creditosReduce, arrayCreditos)
return promedioPonderadoResult.innerText = notasXcreditos.reduce((a,b)=> a + b) / creditosReduce;
}

Buenas, busque otro tipo de promedio llamado media truncada en el cual extraemos un porcentaje de valores en el minimo y maximo de un conjunto para combatir posibles valores atipicos en un conjunto de elementos.

Aqui seteo un sort numerico para facilitar el ordenamiento de un array y dejo un array de prueba:

Array.prototype.sortNormal = function(){return this.sort(function(a,b){return a - b})}

arrayNumericoEjemplo = [44347,12445,26880,23366,42464,15480,21562,11625,39402,47699,44315,29581,44320,35264,10124,43520,26360,19534,30755,37327,15832,33919,29498,46136,18007,36339,27696,47413,47636,20978,49079,40668,45932,40454,46132,35054,11906,22532,43045,45074,16505,27336,37831,29757,37765,22237,38601]

Esta funcion realiza el descarte de los ‚Äúbordes‚ÄĚ del array para depurarlo y poder trabajar la media del conjunto restante:

function filtrarBorders (array, porcentaje) {
numeroDeElementos = array.length + 1
removeArr = []
porcentajeArray  = Math.round((numeroDeElementos * porcentaje) / 100); 

for(let i = 0; i < porcentajeArray;i++){
    removeArr.push(i) 
}

for(let i = (array.length - porcentajeArray); i < array.length;i++){
    removeArr.push(i) 
}

const arrayDepurado = array.filter(function(value, index) {
    return removeArr.indexOf(index) == -1;
})
return arrayDepurado
}

Aqui calculamos el promedio del conjunto depurado:

function calcularPromedioFor(array) {
    let sumaArray = 0;
    for (let i = 0; i < array.length; i++) {
        sumaArray = sumaArray + array[i];
    }
    
    const promedio = sumaArray / array.length;
    return promedio
}

Y por ultimo en esta funcion encapsulamos las funciones previas dentro de una funcion llamada ‚Äúmedia truncada‚ÄĚ donde proporcionamos un array y el porcentaje que queremos descartar como borde para que nos proporcione el valor final:

function mediaTruncada (array, porcentaje) {
    array.sortNormal();
    const arrayDepurado = filtrarBorders(array, porcentaje)
    console.log(arrayDepurado)
    const resultadoFinal = Math.trunc(calcularPromedioFor(arrayDepurado))
    return resultadoFinal
}

¬ŅCu√°l tipo de promedio elegiste para trabajar?
RTA: Desarrolle el ejercicio con la Media Cuadr√°tica.

¬ŅQu√© casos de uso tiene tu tipo de promedio?
RTA: Este tipo de media es muy √ļtil en los casos
que la variable estadística toma valores negativos y
positivos, ya que al hacer al cuadrado de todos los
valores toman valores positivos.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

<const lista = [2,4,5,4]

function calcularMediaCuadratica(list){
    let sumaTotal = 0
    for (let i = 0; i < list.length; i++) {
        let valor = list[i];
        valor = valor**2
        sumaTotal =+ valor;
    };
    sumaTotal /= list.length
    const result = Math.sqrt(sumaTotal);
    console.log(result);
} > 
  1. Escogí el Promedio Truncado.
  2. Se usa para quitar valores atípicos en un conjunto de datos.
  3. Mi código es:
function calPromedio(array, atipico){
    let cantProv = array.length;
    atipico = Math.trunc(cantProv * (atipico/100));
    array.splice(cantProv-atipico,atipico);
    array.splice(0,atipico);
    let suma = array.reduce((sum, item) => sum + item);
    let cant = array.length;
    let prom = suma / cant;
    return prom;
}

// calPromedio([25,15,68,7,8,91,5,10,45,41,3,6,56,4],25)

lo hice de na manera un poco diferente

function mediaPonderada(list){
    let totalMat = 0;
    let totalCredit = 0;
    for(let i = 0; i < list.length; i++){
        let element = list[i];
        let credit = element.credito;
        let nota = element.nota;
        totalMat += credit * nota;
        totalCredit += credit;
    }
    return totalMat / totalCredit;
}

Respuesta 1: Media geométrica
Respuesta 2: La media geom√©trica de una cantidad arbitraria de n n√ļmeros, es la ra√≠z n-√©sima del producto de todos los n√ļmeros y es recomendada para datos de progresi√≥n geom√©trica, para promediar razones, intereses compuestos y n√ļmeros √≠ndice

Respuesta 3:

function mediaGeometric(lista) {
const listaMultiplicada = (valorAcumulado, nuevoValor) => {
return valorAcumulado * nuevoValor;
}
const listaTotal = lista.reduce(listaMultiplicada);

const promedioGeometric = Math.pow(listaTotal, (1/lista.length));
const promedioGeoFinal = promedioGeometric.toFixed(2);

return ('El promedio geométrico es: ' + promedioGeoFinal);

}

  1. Utilicé el promedio ponderado que se utiliza cuando se quiere calcular el promedio de algo pero teniendo en cuenta la importancia de un elemento sobre otro.
  2. Uno de los ejemplo m√°s comunes son cuando se sacan los promedios ponderados de unas notas, seg√ļn la cantidad de cr√©ditos de una materia.
function calcularPromedioPonderado(notas){
    let creditosTotales = 0 , sumaParcial = 0;
    notas.forEach(function(elem){
        sumaParcial +=  elem.creditos * elem.nota;
        creditosTotales += elem.creditos;
    })
    return sumaParcial / creditosTotales;
}

¬ŅCu√°l tipo de promedio elegiste para trabajar?

Utilicé el Rango medio:

  • En estad√≠stica, el rango medio de un conjunto de valores de datos estad√≠sticos es la media aritm√©tica de los valores m√°ximos y m√≠nimos de un conjunto de datos. Es una medida de tendencia central. Tambi√©n se le llama extremo medio. La formual para calcularlo es: M = (max + min) / 2 donde M es el rango medio, max el valor m√°ximo del conjunto de datos y min el valor m√≠nimo en el conjunto de datos,

¬ŅQu√© casos de uso tiene tu tipo de promedio?

El calculo del rango medio puede ser util en casos en donde necesito saber un rango intermedio de las edades de personas que visitan una tienda online para poder enfocar hacia las personas de esa edad que obtuve, una nueva publicidad que se va a lanzar en los proximos meses. Entonces, decido hacer una breve encuesta a las personas que visitan la tienda y les pregunto su edad; al finalizar la encuenta, obtengo la menor de las edades y la mayor y con ello podre hacer un estudio de la mejor manera de enfocar mi publicidad a las personas que se encuentre en el rango de edad que obtuve.

¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Utilic√© los metodos Math.min y Math.max para encontrar los valores minimo y maximo dentro del array, lo importante al utilizar estos metodos con arrays es utilizar el operador spread (‚Ķ) antes de llamar al array dentro del metodo para que pueda calcularlo correctamente. Luego de encontrar ambos n√ļmeros, se suman y se divide el resultado entre 2, para finalmente retornar el resultado de esta operaci√≥n.

const array = [50, 1000, 60, 130, 200, 93, 420];

function calcularRangoMedio(array) {
  
		// Ordenar array:
		const arrayOrdenado = array.sort((a, b) => a - b);
		console.log(arrayOrdenado);
		//Obtener mayor numero
    const numeroMayor = Math.max(...arrayOrdenado);
    console.log(numeroMayor);
    //Obtener menor numero
    const numeroMenor = Math.min(...arrayOrdenado);
    console.log(numeroMenor);
	
		// Calcular rango medio:
		const rangoMedio = (numeroMayor + numeroMenor) / 2;
    console.log(rangoMedio);
		return rangoMedio;

}

calcularRangoMedio(array);

Notas:

  1. Debido a que los m√©todos Math.mix() y Math.max() originalmente solo trabajan con conjuntos de n√ļmeros y no con arrays, la funcionalidad que cumple el operador spread es la de expandir los valores del array dentro de los argumentos de la funci√≥n min() y max() respectivamente para de este modo realizar la operaci√≥n de manera correcta.
  2. No es necesario ordenar el array con el metodo sort antes de calcular los numeros mayor y menor dentro del array, porque los metodos Math.mix() y Math.max() no necesitan tener el conjunto de numeros ordenados para devolver el resultado. Sin embargo, ordenar el array puede ser de ayuda en casos en los que se necesite visualizar mejor el conjunto de n√ļmeros dentro del array.

Rta1:Yo use la media geometrica
Rta2: Usos en finanzas


 Tasa de rentabilidad geométrica
Suponemos que un Fondo de inversi√≥n ha obtenido una rentabilidad del 20% el primer a√Īo, 15% el segundo, 33% el tercer y 25% el cuarto a√Īo. Calcula la tasa geom√©trica de rentabilidad que ha obtenido nuestro capital depositado en el fondo de inversi√≥n.
n=4
r1= 0,20
r2= 0,15
r3= 0,33
r3= 0,25


const rentabilidad = [
    {
        a√Īo:2019,
        renta:'20%'
    },
    {
        a√Īo:2020,
        renta:'15%'
    },
    {
        a√Īo:2021,
        renta:'33%'
    },
    {
        a√Īo:2022,
        renta:'25%'
    }
]
let x = []
rentabilidad.forEach(a=>x.push(a.renta))


let producto = (x.map(str => parseFloat(str.slice(0,-1)/100)+1)).reduce((a,b) => a*b)

let mediaGeometrica = Math.pow(producto,1/4)-1

let rentabilidadPorcentaje= (mediaGeometrica * 100).toPrecision(2) + '%';
console.log(rentabilidadPorcentaje);

Hola, yo use el promedio movil simple para calcular el pronostico de ventas por un periodo de meses. El método de pronóstico móvil simple se utiliza cuando se quiere dar más importancia a conjuntos de datos más recientes para obtener la previsión del otro. El periodo debe ser mayor a 1 mes para obtener un buen pronostico

const datosVentasReales = [
    {
        mes: 'Enero',
        venta: 80
    },
    {
        mes: 'Febrero',
        venta: 90
    },
    {
        mes: 'Marzo',
        venta: 85
    },
    {
        mes: 'Abril',
        venta: 70
    },
    {
        mes: 'Mayo',
        venta: 80
    },
    
]

function sumaVentasReales(periodo){

    const element = []
    const invertirLista = datosVentasReales.reverse()
    if(periodo > 1){

        for (let index = 0; index < periodo; index++) {
             element.push(invertirLista[index].venta)
        }
        const obtenerPromedioMovilSimple = element.reduce((total, actual)=> total + actual, 0) / periodo
        
        return `Se estima que las ventas del Mes de Junio, ser√°n de ${obtenerPromedioMovilSimple.toFixed(1)}`
    }else{
        console.log('Debe ser un periodo igual o mayor a 3 para tener un buen pronostico');
    }
}

¬ŅCual tipo de promedio elegiste para trabajar?

Decidi utilizar el Rango

¬ŅQue casos de uso tiene tu tipo de promedio?

Nos da el valor dentro de los cuales se encuentra un conjunto de numeros, cual es el valor mayor y cual es el menor.

¬ŅComo traduces su formula a codigo JavaScript?

En primer lugar, se utiliza el m√©todo Math.max(‚Ķarr) para obtener el n√ļmero m√°ximo del conjunto, se utiliza el operador ‚Äú‚Ķ‚ÄĚ para desglosar el arreglo y pasar cada elemento como argumento del metodo Math.max, de esta manera se obtiene el maximo valor del arreglo.
A continuaci√≥n, se utiliza el m√©todo Math.min(‚Ķarr) para obtener el n√ļmero m√≠nimo del conjunto, igual que en el caso anterior se utiliza el operador ‚Äú‚Ķ‚ÄĚ para desglosar el arreglo y pasar cada elemento como argumento del metodo Math.min, de esta manera se obtiene el minimo valor del arreglo.
Finalmente se resta el valor maximo con el valor minimo y se devuelve el rango.

function range(arr) {
    return Math.max(...arr) - Math.min(...arr)
}

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(range(numbers));
  1. Elegí el promedio armonico.

  2. El promedio armonico se suele utilizar cuando se desea dar más peso a las observaciones con valores más bajos, ya que se realiza una inversión de los valores a promediar (1/valor) y se suma al cálculo del promedio armonico.

function calcular_promedio_armonico(valores){
    const n = valores.length;
    let suma_inversos = 0;

    for (let i = 0; i < valores.length; i++) {
        suma_inversos += 1/valores[i];
    }
    return n / suma_inversos;
}

1-. En estadística, el rango medio de un conjunto de valores de datos estadísticos es la media aritmética de los valores máximos y mínimos de un conjunto de datos. Es una medida de tendencia central. También se le llama extremo medio.

2-. encuentra alg√ļn uso en casos especiales: es el estimador de m√°xima eficiencia para el centro de una distribuci√≥n uniforme

3-. formula: M = (max + min) / 2

const array = [3,6,1,5];

function rangoMedio(arr) {
  const orderedArray = arr.sort( (a,b) => a - b);
  const max = orderedArray[orderedArray.length-1];
  const min = orderedArray[0];
  
  return (max-min)/2;
}

rangoMedio(array);