Curso Pr√°ctico de JavaScript

Curso Pr√°ctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Reto: calcula otros tipos de promedio

18/24

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.

Responde las siguientes preguntas en los comentarios:

  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?
  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?
  • ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Espero tu solución en la sección de aportes.

Solución al promedio ponderado

Eleg√≠ trabajar con la media aritm√©tica ponderada. Este es un promedio muy similar a la media aritm√©tica, pero nos permite definir tambi√©n el peso, importancia o relevancia de cada elemento en nuestro conjunto de n√ļmeros.

Un caso de uso de la media ponderada es el c√°lculo de notas acad√©micas cuando cada materia o asignatura otorga diferentes ‚Äúcr√©ditos‚ÄĚ.

Esta es su fórmula:

Promedio ponderado

En espa√Īol: multiplicar cada n√ļmero del conjunto por su respectivo cr√©dito, sumar todos los resultados y dividirlo entre la suma de todos los cr√©ditos.

Recuerda que no tienen que ser √ļnicamente 3 n√ļmeros, pueden ser lo que desees, esto solo fue un ejemplo.

Ahora sí, vamos paso a paso implementando el promedio ponderado en JavaScript:

  • Definir el conjunto de n√ļmeros junto al peso de cada elemento

Para esto vamos a crear un array de objetos llamado notes. Cada objeto tendr√° tres valores: course con el nombre de la materia (aunque en realidad no lo utilizaremos ūüėÖ), note con la nota de la materia y credit con los cr√©ditos de la materia.

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

Ahora vamos paso a paso construyendo nuestra m√°quina para sacar promedios ponderados.

  • Multiplicar cada n√ļmero de la lista por su peso

Vamos a usar de nuevo el m√©todo map de los arrays. Crearemos un nuevo arreglo de solo n√ļmeros a partir de multiplicar cada nota con sus cr√©ditos.

const notesWithCredit = notes.map(function (noteObject) {
    return noteObject.note * noteObject.credit;
});
  • Sumar todos los elementos del arreglo de elementos multiplicados por su peso

Vamos a usar de nuevo el método reduce de los arrays.

Crearemos una nueva variable sumOfNotesWithCredit que tenga como resultado la suma de todos los elementos del arreglo notesWithCredit. Recuerda que la función reduce recibe una función con dos parámetros: el valor acumulado (que para evitar errores debemos inicializar con 0) y el nuevo elemento de los arrays.

const sumOfNotesWithCredit = notesWithCredit.reduce(
    function (sum = 0, newVal) {
        return sum + newVal;
    }
);
  • Sumar todos los pesos (cr√©ditos)

S√≠, otra vez map y reduce. Vamos a crear un nuevo arreglo credits √ļnicamente con los cr√©ditos de cada materia y otra nueva variable sumOfCredits que recorra el arreglo credits y sume sus elementos.

const credits = notes.map(function (noteObject) {
    return noteObject.credit;
});

const sumOfCredits = credits.reduce(
    function (sum = 0, newVal) {
        return sum + newVal;
    }
);
  • Hacer la divisi√≥n entre ambas ‚Äúsumas‚ÄĚ

Lo √ļltimo que nos falta es dividir nuestra variable sumOfNotesWithCredit sobre la variable sumOfCredits.

const promedioPonderadoNotasConCreditos = sumOfNotesWithCredit / sumOfCredits;

En este caso, el promedio ponderado de una nota de 10 con cr√©ditos de 2, otra nota de 8 con un cr√©dito de 5 y una √ļltima nota de 7 con cr√©ditos de 5 nos da como resultado 7.916.

La media aritmética sin tener en cuenta el peso de cada nota habría sido 8.333.


Espero que este √ļltimo ejercicio te haya ayudado a interiorizar un poco m√°s el uso de los m√©todos de los arrays para obtener diferentes resultados con ellos.

Te espero en la siguiente clase para iniciar nuestro √ļltimo y m√°s avanzado taller de este curso.

Aportes 322

Preguntas 9

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Por si quieran interiorizar más en los métodos de los arrays, les dejo un enlace a la documentación oficial.

Array

Demás de un sinfín de videos en YouTube.
Métodos de los arrays

// Media Armonica
// Suele utilizarse principalmente para calcular la media de velocidades, tiempos o en electrónica.
// Esta media es poco efectiva en los valores grandes y los infravalora respecto a la media aritmética, pero muy efectiva a los valores próximos a cero, ya que los inversos o fracciones 1/X son muy altos, por lo que les da más peso que en las medias aritmética y geométrica. Y es la ideal a usar en esos casos.

// Como por ejemplo : Un tren realiza un trayecto de 400km. La v√≠a tiene mal estado que no permit√≠an correr. Los primeros 100 km los recorre a 120km/h, los siguientes 100km la v√≠a est√° en mal estado y va a 20km/h, los terceros 100km a 100km/h y los 100 √ļltimos a 130km/h. Para calcular el promedio de velocidades, calculamos la media arm√≥nica. Asi:

//  Paso 1: Definir el conjunto de distancias junto a sus velocidades.

 const  movement = [
    {
        distanceKm: 100,
        velocity: 120,
    },
    {
        distance: 100,
        velocity: 20,
    },
    {
        distanceKm: 100,
        velocity: 100,
    },
    {
        distanceKm: 100,
        velocity: 130,
    },
];

// Paso 2: Crear un array con la Inversa de las velocidades.

// const velocityInvert = movement.map(function (movementObject) {
//     return (1 / movementObject.velocity);
// });

// Paso 3: Hacer una sumatoria de las Velocidades Invertidas

// const velocityprom = velocityinvert.reduce (
//     function ( sum = 0, newVal) {
//         return sum + newVal;
//     }
// );

// Paso 4: Division de "Promedio de Velocidades Invertidas" entre "cantidad de Velocidades", y almacenarlas en una "variable a reutilizar".

// const mediaArmonica = (velocityInvert.length / velocityprom);

// Paso 5: Creamos una funcion que acepte com parametro cualquier objeto movimiento que incluya distancias y velocidades. Y que ademas permite calcular la media armonica automaticamente.Creamos

function calcularMediaArmonica (dataObject) {
    const velocityInvert = dataObject.map(function (dataObject) {
        return (1 / dataObject.velocity);
    });

    const velocityprom = velocityInvert.reduce (
        function ( sum = 0, newVal) {
            return sum + newVal;
        }
    );

    const mediaArmonica = (velocityInvert.length / velocityprom);

    return mediaArmonica;
}

Espero cumplir el reto ūüėĄ esto es divertido XD

Yo no sabía que había diferentes tipos de promedio. Así que al principio empecé a realizarlo con la desviación estandar. Al revisar los trabajos de los demás me di cuenta de que tenía que hacer algo diferente y empecé a realizar la media geométrica que se utiliza principalmente para calcular la tasa de crecimento porcentual a través del tiempo.

Aquí dejo como realice el calculo de la media geometrica

function calcMediaGeometrica(lista) {
    const multiplicacion = lista.reduce(
        function (a, b) {
            return a * b;
        }
    );
    return multiplicacion ** (1 / lista.length)
}

También dejo como realice mi código para calcular la desviación estandar.

function calcStandardDeviation(lista) {
    const promedio = calcularPromedio(lista);
    const sumatoria = lista.reduce(
        function (a = 0, b) {
            return a + (b - promedio) ** 2;
        }
    );
    return Math.sqrt(sumatoria / lista.length);
}

Les comparto mi proceso.

La verdad que algunas cosas las he sentido complicadas, ya que cuando uno va empezando hay cosas sobre la lógica que no suele tomar en cuenta o suelo perderme, as que empecé a hacer lo siguiente:

Escribo paso a paso lo que quiero que haga y como entiendo que va a funcionar mi código, luego de eso voy intentando que funcione cada uno de los pasos que describí.

El tipo de promedio que elegí calcular fue la Media Cuadrática, la cual sirve para calcular la media de variables que toman valores negativos y positivos. Se suele usar cuando el símbolo de la variable no es importante y lo que interesa es el valor absoluto del elemento.

Ac√° les dejo mi c√≥digo. ūüĎá

const lista = [
    -4,
    5,
    6,
    -10,
    12,
    15,
    29,
    -58,
];

const listaNueva = [];
var sumaLista;

function calcularMediaCuadratica(lista){
    lista.forEach(function(elementos){
        listaNueva.push(Math.pow(elementos, 2));
    })
    
    sumaLista = Math.sqrt(listaNueva.reduce(function(a, b){ return a + b; }) / listaNueva.length).toFixed(2);
    return sumaLista;
}

Así hice el cálculo de la media armónica

<code> const calcularMediaArmonica = (lista1) =>{
    const listaOrdenada = lista1.sort((a,b)=> a-b);
    const cantidadTotal = listaOrdenada.length;
    const valoresInvertidos = listaOrdenada.map((elemento) => 1/elemento);
    const sumaValoresInvertidos = valoresInvertidos.reduce((acc, cur)=> acc + cur);
    const mediaArmonica = cantidadTotal/sumaValoresInvertidos
    console.log(`La Media armónica es ${mediaArmonica}`);
}

ūüéąReto:

  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    Media Cuadr√°tica ūüďĚ
  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Definida como la raíz cuadrada del promedio de los elementos al cuadrado.
    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.
    ūüďĆM√°s informaci√≥n
  • ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
const rootMeanSquare = (list) => {
  const squaredNumbers = (list.map((num) => Math.pow(num, 2)))
  const avg = (squaredNumbers.reduce((a = 0, b) => a + b)) / list.length
  return Math.sqrt(avg).toFixed(3)
}

let result = rootMeanSquare([1, -2, 24, -15, 17, 25, 10])
console.log(result);

Utilize la media geométrica, su uso es obtener medias pero de porcentajes, ya que ofrece unos cálculos más precisos. Mi código fue el siguiente:

function calcular_media_geometrica(lista) {
    const listaPorcentajes = lista.map((numero) => {
        return numero/100
    });
    
    let mediaGeometrica;
    const productoPorcentajes = listaPorcentajes.reduce((a=0, b) => {
        return a * b
    })
    
    return mediaGeometrica = productoPorcentajes**(1/lista.length)
}

const media_geometrica = calcular_media_geometrica([45, 50, 21, 25, 35])

√ćndice Gini




Inventada por Corrado Gini, esta sirve para medir la desigualdad de ingresos, ya sea de algo peque√Īo como una empresa, o todo un pa√≠s. Este coeficiente va del 0 al 1, donde cero ser√≠a la perfecta igualdad y uno con la perfecta desigualdad

Fue interesante este reto, porque tuve que averiguar que otras formas hab√≠a de ingresar html desde javascript. Lo √ļnico que me falta es que al darle el bot√≥n a√Īadir, autom√°ticamente se elimine lo que ingres√© y el cursor se devuelva al primer input.

Dejo mi código de html, css y javascript

Mi reto fue responder mi duda de que pasa cuando hay 2 o m√°s modas, por el momento solo funciona con dos, buscare una manera de hacerlo mas efectivo

 //FUNCION MODA
 
function calcularModa(lista2){
  const lista2Count = {};
  
  lista2.map(
    function (elemento) {
      if (lista2Count[elemento]) {
        lista2Count[elemento] += 1;
      } else {
        lista2Count[elemento] = 1;
      }
    }
  );
  
  const lista2Array = Object.entries(lista2Count).sort(
    function (elementoA, elementoB) {
      return elementoA[1] - elementoB[1];
    }
  );

  let moda;
  
  if(lista2Array[lista2Array.length - 1][1]==lista2Array[lista2Array.length - 2][1]){
    moda = "Las Modas son:  " + lista2Array[lista2Array.length - 1] + " y " + lista2Array[lista2Array.length - 2]
  }
  else {
   moda = "La Moda es: "+lista2Array[lista2Array.length - 1];
  }

  return moda;
}

Yo quise calcular la Media arm√≥nica que es recomendada para promedia velocidades, seg√ļn Wikipedia.
Esto es lo que hice en TypeScript:

const calcularMediaArmonica = (lista: number[]): number => {
  const n = lista.length
  let suma_lista = 0
  for (let index = 0; index < lista.length; index++) {
    suma_lista += (1/lista[index])
  }
  const mediaArmonica = n / suma_lista
  return mediaArmonica
}

console.log(`Media armónica de [1,2,3,4]: ${calcularMediaArmonica([1,2,3,4])}`)

Elegí la media geométrica.
La media geom√©trica es un promedio muy √ļtil en conjuntos de n√ļmeros que son interpretados en orden de su producto, no de su suma (tal y como ocurre con la media aritm√©tica). Por ejemplo, las velocidades de crecimiento.

const calcularMediaGeometrica = (lista) =>{
    let acumulado = 0;
    producto = lista.map((elemento) => {
        if(acumulado == 0){
            acumulado = (elemento);
        } else {
            acumulado *= (elemento);
        }
    });
    const mediageometrica = Math.pow(acumulado,(1/lista.length));
    return mediageometrica;
}

Tome el ejemplo sin usar la solución.

var valores = [10, 15, 20, 12, 13, 10]; 
var ponderadores = [1, 1, 2, 2, 2, 4];

// Si no existe cada valor con una ponderación no se puede realizar el promedio ponderado.
if (valores.length === ponderadores.length) {    
    var sumaPonderacion = 0;
    var sumaPonderados = 0;
    for (let i = 0; i < valores.length; i++) {
        sumaPonderacion = sumaPonderacion + parseInt(valores[i] * ponderadores[i]);
        sumaPonderados = sumaPonderados + ponderadores[i];
    }
    var promedioPonderado = sumaPonderacion / sumaPonderados;
} else {
    alert("No se puede realizar la ponderación");
}

Buen día para todos aqui dejo mi solución para el promedio ponderado en codigo, un poco mas manual sin las funciones de ayuda de JS, sino con los rudimentos manuales de logica de programación en general, la ventaja es que se puede llamar a la función promedioPonderado(cantidadNotasCredito) y pasar por argumento un numero de registros y luego por pantalla con prompt digitar el nombre de la clase, la nota y el credito correspondiente y luego esa función arma el array de objetos y llamo luego a la función calculaPromedioPonderado (arrayObjetos), que calcula el promedio ponderado:

function promedioPonderado(cantidadNotasCredito){ //Pasar por argumento la cantidad de nota/credito a ingresar

    var arrayNotaCredito = [];

    for (let index = 0; index < cantidadNotasCredito; index++) { //Loop para dependiente del valor ingresado como argumento en la función
        let cursoPantalla = prompt("Digita el curso " + (index + 1) + ": ",0) //Captura por patanlla del valor del curso
        let notaPantalla = prompt("Digita la nota " + (index + 1) + ": ",0); //Captura por patanlla del valor de nota
        let creditoPantalla = prompt("Digita el credito " + (index + 1) + ": ",0); //Captura por patanlla del valor de credito
        let nota = parseFloat(notaPantalla); //Parseo a numero con punto flotante de la variable nota
        let credito = parseFloat(creditoPantalla); //Parseo a numero con punto flotante de la variable credito
        let objeto = { //Conversion a variable objeto el par nota/credito capturado por pantalla
            'curso': cursoPantalla,
            'nota': nota,
            'credito': credito
        };
        arrayNotaCredito.push(objeto); //por cada loop adicionamos la variable objeto a la variable array
    }

    console.log(arrayNotaCredito);

    return calculaPromedioPonderado(arrayNotaCredito); //Llamado a la función que calcula el promedio ponderado.

}

/*
    Ejemplo Input: 

    [
        {curso: "Educación Física", nota: 15, credito: 5},
        {curso: "Programación", nota: 11, credito: 4},
        {curso: "Finanzas personales", nota: 5, credito: 2}
    ]

    Valor esperado: 11.727272727272727
*/

function calculaPromedioPonderado (arrayObjetos){

    var sumatoriaNotaXcredito = 0;
    var sumatoriaCredito = 0;

    for (let index = 0; index < arrayObjetos.length; index++) {
        const objeto = arrayObjetos[index]; //En cada loop toma de toda la variable objeto del array segun su indice (ej. {nota: 15, credito: 5})
        let notaXcredito = objeto['nota'] * objeto['credito']; // multiplicación de los valores de las claves 'nota' y 'credito' de la variable objeto recien capturada
        sumatoriaNotaXcredito = sumatoriaNotaXcredito + notaXcredito; //Sumatoria acumulada del resultado de multiplicar la nota x credito
    }

    for (let index2 = 0; index2 < arrayObjetos.length; index2++) {
        const objeto2 = arrayObjetos[index2]; //En cada loop toma de toda la variable objeto del array segun su indice (ej. {nota: 15, credito: 5})
        let credito = objeto2['credito']; //Captura del valor de la clave 'credito' de la variable objeto recien capturada
        sumatoriaCredito = sumatoriaCredito + credito; //Sumatoria acumulada del valor de credito
    }

    console.log("sumatoriaNotaXcredito: " + sumatoriaNotaXcredito);
    console.log("sumatoriaCredito: " + sumatoriaCredito);

    const promedioPonderado = sumatoriaNotaXcredito / sumatoriaCredito;

    return promedioPonderado;
}

Yo elegi usar la Media Armonica

Media arm√≥nica para una colecci√≥n no vac√≠a de n√ļmeros a1, a2, ‚Ķ, an, todos diferentes de 0, se define como el rec√≠proco de la media aritm√©tica de los rec√≠procos de los ai:

Un ejemplo en el que la media arm√≥nica es √ļtil es cuando se examina la velocidad de varios viajes de distancia fija. Por ejemplo, si la velocidad para ir del punto A al B era 60 km/h, y la velocidad para regresar de B a A fue de 40 km/h, entonces la velocidad media arm√≥nica viene dada por

Y la solucion que hice para implementarlo en JS es esta:

function calcularMediaArmonica(lista) {
    let denominador = 0;

    for(let i = 0; i < lista.length; i++) {
        if (lista[i] === 0) {
            console.log('La lista no puede contener ceros');
            return
        } else {
            denominador += 1/lista[i];
        }
    };

    const mediaArmonica = lista.length / denominador;
    console.log(mediaArmonica);
}

Elegí Media Geométrica.
Se usa en Finanzas, por lo que vi
Repositorio
P√°gina

const calcularMediaGeometrica = iterable =>{
    let array = iterable.split(", ")
    let multiplicacion = array.reduce((a, b)=> Number(a) * Number(b));
    console.log(multiplicacion);
    let mediaGeometrica = Math.pow(multiplicacion, 1/array.length).toFixed(2);
    console.log(mediaGeometrica)
    return mediaGeometrica
}


function getMediaGeometrica(){
    let media_geometrica_value = media_geometrica.value;
    let resultado = calcularMediaGeometrica(media_geometrica_value);
    media_geometrica_result.innerHTML = `Media Geométrica: ${resultado}`
}

El tipo de medida que encontré para mi ejercicio es el rango y el rango medio de una lista.

El caso de uso, puede ser practico para seguir el camino de la media aritm√©tica y la mediana, poder tener m√ļltiples datos de una lista y jugar con ellos.

![](

function calcularRangoMedio ()  {
    const inputRango  = document.getElementById("InputRango");
    const rangoValue = inputRango.value;
    const rangos = rangoValue.split(",").map(i=>Number(i));
    
    rangos.sort((a,b) => a-b);
    const valorMinimo =  rangos[0];
    const valorMaximo = rangos[rangos.length - 1];
        
    const rango = (valorMaximo - valorMinimo);
    const resultRango = document.getElementById("ResultRango");
    resultRango.innerText = "El rango de tus ventas es $" + rango;

    
    const rangoMedio =  (valorMinimo + valorMaximo) / 2;
    const resultRangoMedio = document.getElementById("ResultRangoMedio");
    resultRangoMedio.innerText = "El rango medio de tus ventas es $" + rangoMedio;       
}    

Información obtenida de: https://www.montereyinstitute.org/courses/DevelopmentalMath/TEXTGROUP-1-8_RESOURCE/U08_L2_T1_text_final_es.html

Media armónica

Media geométrica

La media geom√©trica es un promedio muy √ļtil en conjuntos de n√ļmeros que son interpretados en orden de su producto, no de su suma (tal y como ocurre con la media aritm√©tica). Por ejemplo, las velocidades de crecimiento. wikipedia

function calcularMediaGeometrica(array) {
    return Math.pow(array.reduce((a, b) => a * b), 1 / array.length);
}

Media cuadr√°tica

const list = [-1,2,-1,-3,4,2]
const rootMeanSquare = (array) => {
    const value = array.reduce((prev, current) => prev + Math.pow(current,2))
    return Math.sqrt(value/array.length)
}
const res = rootMeanSquare(list)

Aqui esta el codigo de un promedio geometrico

const calcularPromedioGeometrico = function (lista) {
    
    const multLista = lista.reduce(
        function (valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado * nuevoElemento;
        }
    );

    const listaWithRoot = Math.sqrt(Math.sqrt(multLista));
    const resultPG = Math.round(listaWithRoot);
    return resultPG;
}

En el siguiente codigo que les voy a mostrar, intente formular el PG de dos maneras. La formula de dos datos y la formula para varios datos pero algo estoy haciendo mal. Asi que porfa espero su comentario.

const calcularPromedioGeometrico = function (lista) {
    
    const multiplicationNumbers = function () {
        lista.reduce(
            function (valorAcumulado = 0, nuevoElemento) {
                return valorAcumulado * nuevoElemento;
            }
        );
    }

    if ( lista.length === 2) {
        doubleElements = multiplicationNumbers(lista);
        let resultBi = Math.sqrt(doubleElements);

        resultPG = resultBi;

    } else {
        
        multLista = multiplicationNumbers();
        const listaWithRoot = Math.sqrt(Math.sqrt(multLista));
        const resultWithRoot = Math.round(listaWithRoot);

        resultPG = resultWithRoot;

    }
    
    return resultPG;
}

El promedio que quise a√Īadir es el promedio geom√©trico, este se suele usar cuando los valores que se tienen corresponden a tasas de incremento. Por lo general se emplea en ventas.

El código es:

function calcularMediaGeometrica(lista) {
  const multiplicacionLista = lista.reduce(function (valorAcumulado = 0, nuevoElemento) {
    return valorAcumulado * nuevoElemento;
  });

  const promedioGeometricoLista = (multiplicacionLista)**(1/lista.length);

  return promedioGeometricoLista;
}

Escogí la media armónica. Esta es mi función, la cual recibe un array como parámetro:

function getHarmonicMean(list) {
  let inverseList = getInverseList(list);
  let sum = inverseList.reduce((acc = 0, el) => acc + el);
  let harmonicMean = (list.length / sum).toFixed(2);
  return Number(harmonicMean);
}

function getInverseList(list) {
  let newList = [];
  newList = list.map(e => Math.pow(e, -1));
  return newList;
}

Realize la Media Geométrica

/**RETO:    encontrar la media geometrica */

//formula  = GM = (x1 * x2 * x3)^1/n 
// donde x es cada uno de los elementos que conforma la lista.
// y n es la cantidad de elementos que conforma la lista.

function calcularMediaGeometrica(lista){
    //ordeno mi lista
    lista.sort( (a,b) => a - b);
    //obtengo la cantidad de elementos de la lista
    const cantidadElementos = lista.length;
    //multiplico cada elemento de mi lista y obtengo el resultado
    const resultMultiplicacion = lista.reduce( (acumulado, elemento) => acumulado * elemento);
    //calculo el resultado de la multiplicacion elevandolo a la potencia Y obtengo la media geometrica(GM)
    const GM = Math.pow(resultMultiplicacion, 1/cantidadElementos).toFixed(3);
    console.log(`La Media Geometrica de este grupo de elementos: '${lista}'.
ES: ${GM}.`) 
}
calcularMediaGeometrica([12,3,5,6,6,7,10,])

//La media geométrica consiste en multiplicar los elementos y calcular la raiz "enésima" de esa multiplicación
// Si tengo una lista de 3 elementos (5,10,3) --> 5 * 10 * 3 = 150 --> R√°iz cubica (3 elementos) de 150
function calcularMediaGeometrica(lista){
    //Al ser una multiplicación el primer valor tiene que ser 1, sino siempre da 0.
    let totalMultiplicado = 1;

    //Transformo la función en función flecha
    //lista.forEach(function (elemento){
    //     total = total * elemento;
    //     return total
    //     } 
    //)

    //Recorro el vector para calcular la multiplicación de sus elementos
    lista.forEach(elemento => totalMultiplicado = totalMultiplicado * elemento);

    //Guardo el n√ļmero de elementos que hay en el vector para la ra√≠z.
    const enesima = lista.length;

    //Para calcular la raíz "enésima" se puede utilizar la potencia con un exponente divido
    //Si necesito la r√°iz octava de 200 => 200 elevado a 1 / 8 
    const mediaGeometrica = Math.pow(totalMultiplicado, 1 / enesima);   
    return mediaGeometrica;
}

Hice la media geom√©trica la cual se suele utilizar en finanzas ūüėĄ

const listaVal = [
    1,
    2,
    3,
    1,
    2,
    3,
    4,
    2,
    2,
    2,
    1,
]

function mediaGeo(lista){

    const listaLong = lista.length

    const valueTotal = lista.reduce( (acum, value)=> {
        return acum * value
    })
    const result = Math.pow(valueTotal, 1/ listaLong)

    return result
}

console.log(mediaGeo(listaVal))

Hola
Yo elegí la Media Armónica
Por lo regular el uso de esta media se limita al análisis de velocidades, y en el campo de la electrónica. Tiene la limitante que cuando uno de sus elementos es igual a cero ya no se puede ser calculada. Así mismo es menos sensible con valores muy altos.
√Čste es mi c√≥digo :3

const myVelocities = [65.8, 66.6, 65.5, 64.9, 66.1];
let grandVel;
let armonic = myArmonicFase(myVelocities);
function myArmonicFase(iterations)
{
grandVel = 0;
for(i = 0; i < iterations.length; i++)
{
opposites = 1 / iterations[i];
console.log(Este es el opuesto de la velocidad ${opposites});
opposites[i] = opposites;
grandVel = grandVel + opposites;
}
let result = iterations.length / grandVel;
return parseFloat(result).toFixed(2) + ’ Km/h’;
}

alert(armonic);

Reto: calcula otros tipos de promedio:

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

El promedio elejido por mi es Esperanza Matem√°tica o Valor Esperado y es igual al sumatorio de las probabilidades de que exista un suceso aleatorio, multiplicado por el valor del suceso aleatorio.

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

Se utiliza en toda disciplina en la que la presencia de sucesos probabilísticos es inherente a las mismas. Disciplinas tales como la estadística teórica, la física cuántica, la econometría, la biología o los mercados financieros

Ejemplo, en una loteria con un maximo de 10 posibles numeros ganadores (del 1 al 10), nuestros numeros ser√°n sorteados en una ruleta y en 10 intentos nos ha arrojado los siguientes numero:

  • 5
  • 8
  • 9
  • 4
  • 2
  • 3
  • 7
  • 1
  • 6
  • 10

La probabilidad de cada uno de ellos es de 1/10 = 0.1, o en porcentajes de un 10%. Con estos sucesos podemos calcular promedio de valor esperado.

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

Para el ejemplo anterior aplicamos la sguiente formula:

Dónde:

  • X = valor del suceso.
  • P = Probabilidad de que ocurra.
  • i = Periodo en el que se da dicho suceso.
  • N = N√ļmero total de periodos u observaciones.

Reemplazamos:

Esperanza = (5 * 0.1) + (8 * 0.1) + (9 * 0.1) +(4 * 0.1) + (2 * 0.1) + (3 * 0.1) + (7 * 0.1) + (1 * 0.1) + (6 * 0.1) + (10 * 0.1)

Esperanza = 0.5 + 0.8 + 0.9 + 0.4 + 0.2 + 0.3 + 0.7 + 0.1 + 0.6 + 1

Esperanza = 5,5

Seg√ļn la respuesta podemos decir que la esperanza de ganar es de 5.5%.

Código

let listaNumeros = [ 5, 8, 9, 4, 2, 3, 7, 1, 6, 10];
const probabilidad = listaNumeros.length/ 100;

const promedioValorEsperado = (lista) => {

  const probabilidadGanar = lista.map(function(numeroLoteria){
    return numeroLoteria * probabilidad;
  });

  const sumatoriaProbabilidadesGanar = probabilidadGanar.reduce((acumulado, nuevoValor) => acumulado + nuevoValor)

  return `La esperanza de ganar es: ${sumatoriaProbabilidadesGanar}`;
}

promedioValorEsperado(listaNumeros);

Si se toman la molestia de leer todo y encuentran un error, por favor me lo hacen saber

Me puse a trabajar en la Tasa de Variación Media:
Espero que alguien me de feedback sobre mi código, por favor.

// Este es mi código

function funcionPlanteada(number, funcion = (number / 2) ** 2 + 1) {
return funcion;
}

function getFTVM(numeroUno, numeroDos, x, a) {
return (x - a) / (numeroDos - numeroUno);
}

function getSTVM(numeroUno, numeroDos, x, a) {
return (x - a) / (numeroDos - numeroUno);
}

function validateTVM(valueOne, valueTwo) {
return valueOne === valueTwo ? true : false;
}

console.log(
validateTVM(
getFTVM(0, 2, funcionPlanteada(2), funcionPlanteada(0)),
getSTVM(2, 4, funcionPlanteada(4), funcionPlanteada(2))
)
);

Para mi reto de calcular otro tipo de promedio elegí trabajar con la Media Armónica, un caso de uso práctico en el cual se usa este formato es:
cuando se examina la velocidad de varios viajes de distancia fija.

Esta es su formula

La media arm√≥nica es igual al n√ļmero de elementos de un grupo de cifras entre la suma de los inversos de cada una de estas cifras (El inverso se refiero al resultado de dividir 1 entre cada elemento).

Debemos tener en cuenta que esta presenta ciertas desventajas, como que no puede calcularse si una de las observaciones es igual a cero. Es decir, ninguno de los elementos puede ser nulo. Por lo tanto en nuestro código de javaScript de existir un elemento con valor 0 o nulo debe dar un error o alerta.

Código HTML

<!DOCTYPE html>
<html lang="en">

<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" />
    <link rel="stylesheet" href="./styles.css" />
    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous" />
    <title>Media Armonica y Porcentajes | Curso Practico de JavaScript</title>
</head>

<body>
    <div class="container">
        <h1>C√°lcula la media √°rmonica</h1>
        <p class="text-muted">
            Supongamos que una persona decide salir a correr 10km. Los primeros 2 km corre a 15 km/h, los siguiente 2km,
            a 17 km/h, los siguientes 2km, a 14 km/h, y los otros dos tramos de 2km, a 13 km/h y 12 km/h,
            respectivamente.
        </p>

        <div class="container">
            <div class="row text-center fw-bold">
                <div class="col text-muted"><label for="valor1">15 Km</label></div>
                <div class="col text-muted"><label for="valor1">17 Km</label></div>
                <div class="col text-muted"><label for="valor1">14 Km</label></div>
                <div class="col text-muted"><label for="valor1">13 Km</label></div>
                <div class="col text-muted"><label for="valor1">12 Km</label></div>
            </div>

            <div class="formularContainer">

                <div class="formulaContainer--resultado">
                    <span class="h4 mx-1">Resultado: </span>
                    <input class="form-control mx-1" type="text" placeholder="Resultado" />
                    <button class="btn btn-outline-success">Calcular</button>
                </div>
                <div class="container formulaContainer--h2">
                    <h2>Formula</h2>
                </div>
                <div class="formulaContainer--img">
                    <img src="https://economipedia.com/wp-content/uploads/media-armonica.png" alt="" />
                </div>
            </div>
        </div>

        <h2 class="display-6">Pruebalo</h2>
        <div class="resultcontainer">
            <div class="resultcontainer__row">
                <input class="resultcontainer__row--input" type="text" placeholder="Introduce el valor..."
                    id="inputAdd" />
                <button class="resultcontainer__row--button" id="btnAddvalue">
                    <img src="./src/assets/addButton.png" alt="" class="buttonImage" />
                    <span class="textButton">
                        Agregar
                    </span>
                </button>

                <button class="resultcontainer__row--reiniciar" id="btnReset">
                    <img src="./src/assets/pngegg.png" alt="" class="buttonImage">
                    <span class="textButton">
                        Reiniciar
                    </span>
                </button>
                <button class="resultcontainer__row--btnCalc" id="btnCalculate">
                    <img src="./src/assets/Calculate free icon 4.png" alt="" class="buttonImage">
                    <span>Calcular</span>
                </button>
            </div>

            <div class="resultcontainer__row">
                <textarea name="" id="textAreaResult" cols="30" rows="10" disabled></textarea>
                <input class="resultcontainer__row--result" type="text" disabled id="resultInput" />
            </div>
        </div>
    </div>

    <script src="./mediaArmonica.js"></script>
</body>

</html>

JavaScript

const listaElementos = [];

const verificarElementos = (elemento) => {
    if (elemento === "" || elemento == 0) {
        return 0;
    }
};

const agregarElemento = (el) => {
    const elAdd = verificarElementos(el);
    if (elAdd == 0) {
        alert("El valor ingresado no puede ser nulo");
        document.getElementById("inputAdd").focus();
        return;
    } else {
        let textAreaActValue = document.getElementById("textAreaResult").value;
        document.getElementById("textAreaResult").value = `${textAreaActValue} 
        ${el}...`;
        listaElementos.push(parseInt(el));
        document.getElementById("inputAdd").value = "";
        document.getElementById("inputAdd").focus();
    }
};

const calcularMediaArmonica = (lista) => {
    const nNumeros = lista.length;
    let valorAcumuladoSuma = 0;
    for (let i = 0; i < lista.length; i++) {
        valorAcumuladoSuma = valorAcumuladoSuma + 1 / lista[i];
    }
    return nNumeros / valorAcumuladoSuma;
};

const resetForm = () => {
    listaElementos.splice(0)
    document.getElementById("inputAdd").value = "";
    document.getElementById('textAreaResult').value = "";
    document.getElementById("inputAdd").focus();
}

document.getElementById("btnCalculate").addEventListener("click", () => {
    if (listaElementos.length === 0) {
        alert("Favor introducir por lo menos dos valores");
        document.getElementById("inputAdd").focus();
        return;
    } else {
        let resultado = calcularMediaArmonica(listaElementos);
        document.getElementById("resultInput").value = parseFloat(resultado);
    }
});

document.getElementById("btnAddvalue").addEventListener("click", () => {
    let valor = document.getElementById("inputAdd").value;
    agregarElemento(valor);
});

document.getElementById('btnReset').addEventListener('click', () => {
    resetForm()
})

document.getElementById("inputAdd").addEventListener("keydown", () => {
    soloNumeros();
});

const soloNumeros = () => {
    let soloNumeros = new RegExp("[0-9]");
    let inputs = document.querySelectorAll("input");

    for (let i = 0; i < inputs.length; i++) {
        inputs[i].addEventListener("keypress", (e) => {
            soloNumeros.exec(e.key);
            console.log(soloNumeros.test(e.key));
            soloNumeros.test(e.key) ?
                (e.returnValue = true) :
                (e.returnValue = false);
        });
    }
};

para mi ejemplo use la media armónica

let velocidades = [60, 70, 80];
let valores_divididos = [];
// Saco el inverso de estas velocidades y las guardo
for (let i = 0; i < velocidades.length; i++) {
    let finales = 1 / velocidades[i];
    valores_divididos.push(parseFloat(finales.toFixed(4)))
}
// Sumo todos los valores inversos
let valores_sumados = valores_divididos.reduce((a,b) => a + b);
// Divido estos valores sumando por la cantidad de valores
let mediana_armonica = (velocidades.length/ (valores_sumados)).toFixed(2);
console.log(`${mediana_armonica} Km/h`);

muchachos, calcule el rango aritemetico de un array.

//   let array = [1, 2, 3, 4, 4, 5,6,2,2,2,3,3];

function CalcularRango(array) {
  const ListCount = {};

  array.map( // agrega al objeto ListCount, los numeros del array, sin repetirse y sus respecticas cantidades
      function(elemento){
        if(ListCount[elemento]) {
            ListCount[elemento] += 1;
        }
        else {
            ListCount[elemento] = 1;
        }
        }
  );



  let listArray = Object.entries(ListCount).sort((a ,b) => a[0] - b[0]);//transforma  en Array este objeto con objectr.entries y con sort ordeno con los primeros valores de menor a mayo

  let entera = listArray.map((elemento)=> Number(elemento[0])); // convierte los valores a enteros
        console.log(entera);
        let Rango = entera[entera.length-1] - entera[0]; 
     console.log("el rango de dispersión es: " + Rango);
}

Media Geométrica
Les comparto mi resolución del challenge.

// Media Geometry
// Se suele utilizarse para encontrar el promedio de porcentajes, razones, índices, porcentajes de interés devengado o tasas de crecimiento, como en ventas por ejemplo. También se utiliza frecuentemente para calcular tazas a través del tiempo.
// this is the formula
const lista1 = [10,20,30,40,50]
// functio for calculating Media Geometry
const mediaGeometry = (lista) => (lista.reduce((multiplier, item) => multiplier *= item))**(1/lista.length) // 26.05171...

Media Armónica

function mediaArmonica(lista){
	let sumaInversos = 0;
	for (let elemento of lista){
		sumaInversos = sumaInversos + (1/elemento);
	};
	return lista.length / sumaInversos;
};

Promedio Geometrico

function promgeo(datos){
productoLista = 1;
for (let i = 0; i < datos.length; i++){
productoLista = productoLista*datos[i];
}
const promedioGeometrico = Math.pow(productoLista,(1/datos.length));
return promedioGeometrico;
}

Hice el promedio ponderado ayudándome con el código del profe, lo coloque en una función y así me quedo.

Ha sido un poco complicado, pero no hay que rendirnos

const PP = [
    {
        curso: "Matematica 1",
        credito: 5,
        nota: 15
    },
    {
        curso: "Fisica 1",
        credito: 5,
        nota: 16
    },
    {
        curso: "Biologia 1",
        credito: 4,
        nota: 11
    },
    {
        curso: "Quimica 1",
        credito: 4,
        nota: 10
    },
    {
        curso: "Lenguaje",
        credito: 2,
        nota: 05
    },
];

function promedioPonderado (PP){
    const notaPorCredito = PP.map(function (noteObject) { // El siguiente código toma un array de objetos y crea un nuevo array que contiene los nuevos objetos formateados.
        return noteObject.nota * noteObject.credito;
    });
    const sumaNotaPorCredito = notaPorCredito.reduce( // Reduce devuelve como resultado su √ļnico valor
        function(valorAcumulado = 0, nuevoElemento){
            return valorAcumulado + nuevoElemento;
        }
    );
    const Credito = PP.map(function (noteObject) { // El siguiente código toma un array de objetos y crea un nuevo array que contiene los nuevos objetos formateados.
        return noteObject.credito;
    });
    const sumaCredito = Credito.reduce( // Reduce devuelve como resultado su √ļnico valor
        function(valorAcumulado = 0, nuevoElemento){
            return valorAcumulado + nuevoElemento;
        }
    );    
    const promedioPonderado = sumaNotaPorCredito / sumaCredito;
    alert(promedioPonderado);
}promedioPonderado(PP);
  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    Elegí el promedio geométrico
  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Se utiliza para aproximar el área de las figuras geométricas a cuadrados en dos dimensiones y a cubos en tres dimensiones, otra aplicación en finanzas para calcular el interés variable en periodos consecutivos
  • ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
function calcularPromedioGeometrico(lista){
    const numeroElementos = lista.length;
    if(numeroElementos >= 0){
        const productoElementos = lista.reduce((acumulador,valor) => acumulador * valor);
        const promedioGeometrico = (productoElementos) ** (1/numeroElementos);
        return promedioGeometrico;
    }else{
        console.log("La lista no contiene elementos");
    }

    
}

Busque para obtener el promedio móvil
Mi código quedo así

const list4 = [10,20, 30,30,560,20,35,27,25,46,3]

const calcPromedioMovil = list =>{
    let promedioMovil = 0

    for (let i = 0; i < list.length; i++){
        if(i == 0){
            promedioMovil = (parseInt(list[i])).toFixed(1)
        }else{
            promedioMovil = ((parseInt(list[i]) + parseInt(list[i-1]))/2).toFixed(1)
        }
        console.log(promedioMovil) 
    } 
    return promedioMovil
}

calcPromedioMovil(list4)

así es como me quedo el ejercicio

function promedioPonerado(cantidad, ponerador) {
    if (cantidad.length === ponerador.length) {
        let valor = 0;
        for (let i = 0; i < cantidad.length; i++) {
            valor = valor + (cantidad[i] * ponerador[i]);
            debugger
        }
        let divicion = ponerador.reduce((suma = 0, siguiente) => suma + siguiente);
        console.log((valor / divicion).toFixed(2));
    }else {
        console.log('la cantidad de datos entre el ponerador y los valores es insuficientes');
    }
}

Yo también realice el calculo de promedio ponderado, pero solamente utilice arrays.

function calcularPromedioPonderado(lista){
    const multiplicacionElementoporPonderacion = lista.map((elemento) => elemento[0] * elemento[1]);
    const sumaMultiplicaciones = multiplicacionElementoporPonderacion.reduce((acum, curr) => acum + curr);
    const ponderaciones = lista.map((elemento) => elemento[1]);
    const sumaPonderaciones = ponderaciones.reduce((acum, curr) => acum + curr);
    const promedioPonderado = sumaMultiplicaciones/sumaPonderaciones;
    return promedioPonderado;
}

Calcule el promedio ponderado pero para multiplicar los arrays no se me ocurrió usar .map() y lo hice con un for por si alguien le causa curiosidad otra forma de hacerlo

const lista1 = [
    {nota:3, relevancia: 30},
    {nota:3.5, relevancia: 30},
    {nota:5, relevancia: 40},
];

function calcularPromedioPonderado (lista) {
    let listaMultiplicacionDenominador = [];
    let listaDenominador = [];

    for (i = 0; i < lista.length; i++) {
        let nota = lista[i].nota;
        let relevancia = lista[i].relevancia;
        let mulplicacion = nota * relevancia;

        let aggElementoDenominador = listaDenominador.push(relevancia);
        let aggElementoMultiplicacion = listaMultiplicacionDenominador.push(mulplicacion);
    }

    const denominador = listaDenominador.reduce(
        function (valorAcumulado = 0, nuevoElemento ){
            return valorAcumulado + nuevoElemento;
        }
    );

    const numerador = listaMultiplicacionDenominador.reduce(
        function (valorAcumulado = 0, nuevoElemento){
            return valorAcumulado + nuevoElemento;
        }
    );

    const promedioPonderado = numerador / denominador;
    return promedioPonderado;
}
calcularPromedioPonderado(lista1);

En mi caso he hecho la media Geométrica y armónica

function CalcularMediaGeometrica (lista) {
    if (lista.indexof(0)==-1) {
        ProductoLista=lista.reduce((Producto=1, elemento)=>{
            return Producto*elemento
        });
        MediaGeo=ProductoLista**(lista.length);
        return MediaGeo;
    }
    else {
        console.error("No se peude Calcular la media geometrica Con un 0");
    }

}

function CalcularMediaArmonica (lista) {
    if (lista.indexof (0) == -1) {
        SumaInversa=lista.reduce((Suma=0, elemento)=>{
            return Producto+(elemento**-1)
        });
        MediaArmonica=lista.length/SumaInversa;
        return MediaArmonica;
    }
    else {
        console.error("No se peude Calcular la media armonica Con un 0");
    }
}

Este es el codigo que use para la media ponderada:

function calcularPonderada() {
    let sumaCredito = 0;
    let sumaNotas = 0;
    let ponderada = 0;
    for(elemento in listaPonderar){
        sumaNotas += (elemento * listaPonderar[elemento]);
        sumaCredito += listaPonderar[elemento];
    };
    ponderada = sumaNotas / sumaCredito;
    resultadoPon.innerHTML = "La media ponderada es de: " + ponderada.toFixed(2);
}

Este es mi codigo para la moda

function moda(lista, mostrar) {
  let listaM = {};
  lista.map(function (elemento) {
    if (listaM[elemento]) {
      listaM[elemento] += 1;
    } else {
      listaM[elemento] = 1;
    }
  });
  let listaModas = Object.entries(listaM).sort(function (elementoA, elementoB) {
    return elementoA[1] - elementoB[1];
  });
  if(listaModas[listaModas.length - 1][1] == 1){
    mostrar.innerHTML = "El resultado es Amodal";
  } else {
      mostrar.innerHTML =
        "La moda es de: " +
        listaModas[listaModas.length - 1][0] +
        " que se repite " +
        listaModas[listaModas.length - 1][1] +
        " veces";
  };
}

Yo escogí la media ponderada. Decidí reutilizar el código de la clase anterior, asique cree la funcion numeroApariciones() para hacer el trabajo mas sencillo.
Les dejo el c√≥digo aqu√≠ abajo ‚úĆ

function numeroApariciones(lista){
    let listaCount ={};
    lista.map((element)=>{
        if(listaCount[element]){
            listaCount[element]++;
        }else{
            listaCount[element]=1;
        }
    });
    let listaCArray = Object.entries(listaCount);

    return listaCArray;
}

function calcularMediaPonderada(lista){
    let lista1 = numeroApariciones(lista);
    let sumaPonderada = 0;
    lista1.map(element => {
        //let valor = parseInt(element[0]);
        sumaPonderada+=(element[0]*element[1]);
    });
    let mediaPonderada = sumaPonderada/lista.length;

    return mediaPonderada;
}

Promedio geométrico

Decidi utilizar el promedio geometrico, principalmente porque nunca habia oido habler de el y me llamo mucho la atencion.

Es la raiz N del producto de un conjunto de numeros, siendo N el numero total de elementos.

Codigo JavaScript:

const geoMeanCalc = (list) => {
  let multList = 1;

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

  const geoMean = Math.round(Math.pow(multList, 1/list.length) * 100) / 100;
  return geoMean;
}

Ejemplo:

geoMeanCalc([5, 8, 9, 6, 7, 2, 1, 3]);
\\ 4.17
const asignaturas = [
    finanzas = {
        nota: 45,
        porcentaje: 10
    },
    matematica = {
        nota: 30,
        porcentaje: 25
    },
    marketing = {
        nota: 65,
        porcentaje: 15
    },
    programacion = {
        nota: 70,
        porcentaje: 50
    }
]

const notasPonderadas = (arr) => arr.map(function(obj) {
    return obj.nota * obj.porcentaje
}); 

const calcularMediaPonderada = (arr) => {
    let suma = notasPonderadas(arr).reduce((accumulator, currentValue) => accumulator + currentValue)
    let totalCreditos = sumarCreditos(arr)
    return suma / totalCreditos
}

const sumarCreditos = (arr) => {
    let listaCreditos = arr.map((obj) => obj.porcentaje)
    let totalCreditos = listaCreditos.reduce((x, y) => x + y)
    return totalCreditos
}

console.log(calcularMediaPonderada(asignaturas))
<code> 

Reto:

  • Media geom√©trica

  • En tasas de porcentajes

//  Media Geométrica 
function calcularMediaGeometrica (lista) {
    const sumaLista = lista.reduce(
        function (valorAcumulado = 1, nuevoElemento) {
            return valorAcumulado * nuevoElemento;
        }
    );
    
    const promedioLista = Math.pow(sumaLista, 1/lista.length);

    return promedioLista;
}

console.log(calcularMediaGeometrica([4,25,100])); // 21.544346900318835

Este es el calculo de la media Armonica, espero que les sirva para algo.


  function calcularMediaArmonica(lista) {
    const sumaLista = lista.reduce(
      function (valorAcumulado = 0, nuevoElemento) {
        return valorAcumulado + nuevoElemento;
      }
    );
    const promedioLista = lista.length / sumaLista ;
    return promedioLista;
  }

Yo decidí trabajar con la media armónica.

function mediaArmonica(array) {
    let den = 0
    array.forEach(element => {
        den += 1 / element
    });
    const media = (array.length / den).toFixed(2)
    return(media)
}

Tarea Resuelta : Calculo de la desviaci√≥n standard (otra forma de utilizar ‚Äúfor‚ÄĚ)

function DesviacionStandard(ArrayUlyses) {
    //--CALCULO DEL PROMEDIO--
    var total = 0;
    for(var key in ArrayUlyses)
    total += ArrayUlyses[key];
    var meanVal = total / ArrayUlyses.length;  
    //--CALCULO DE LA DESVIACI√ďN STANDARD--
    var SDprep = 0;
    for(var key in ArrayUlyses)
    SDprep += Math.pow((parseFloat(ArrayUlyses[key]) - meanVal),2);
    var SDresult = Math.sqrt(SDprep/ArrayUlyses.length);
   
     console.log(SDresult);
    } 
   var ArrayUlyses = [10, 19, 12, 32];
   DesviacionStandard(ArrayUlyses);

Reto 3

Responde las siguientes preguntas en los comentarios:

  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?
    Tipo de promedio que decidí utilizar fue la media geométrica

  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Es una medida de tendencia central que puede utilizarse para mostrar los cambios porcentuales en una serie de n√ļmeros positivos. Como tal, tiene una amplia aplicaci√≥n en los negocios y en la econom√≠a, debido a que con frecuencia se est√° interesado en establecer el cambio porcentual en las ventas en el producto interno bruto o en cualquier serie econ√≥mica. Se define como la ra√≠z √≠ndice n del producto de n t√©rminos. La media geom√©trica 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?
    Si el crecimiento de las ventas en un negocio fue en los tres √ļltimo a√Īos de 26%, 32% y 28%, hallar la media anual del crecimiento.

/**
 *  función que se encarga de cálcular la raíz para cualquier
 *  índice
 * @param {*} number: representa el radicando, de la raíz
 * @param {*} n: representa el índice
 * @returns
 */
function rootForAnyIndex(number, n) {
	let result = 0;
	// si los los par√°metros son distintos de n√ļmero retorna null
	if (typeof number !== 'number' || typeof n !== 'number') {
		return null;
	}
	// c√°lculo para n√ļmeros negativos no est√° definido
	if (number < 0) {
		return undefined;
	}
	result = Math.pow(number, 1 / n);
	return result;
}

/**
 *función encargada de cálcular el factor de crecimiento (growthFactor)
  de un valor porcentual
 * @param {*} p_list: lista porcentuales de ventas
 * @returns
 */
function growthFactor(p_list) {
	let listGrowFactor = p_list.map(function (value) {
		value = 1 + value / 100;
		return value;
	});
	console.group('growthFactor');
	console.log(listGrowFactor);
	console.groupEnd();
	return listGrowFactor;
}

/**
 *
 * @param {*} p_list
 * @returns
 */
function geometricAverage(p_list) {
	console.group('geometricAverage');
	let n = 0;
	let resultMultiplication = 0;
	let resultGeometricAverage = 0;

	//se obtiene el índece  de la raíz
	n = p_list.length;
	// se m√ļltiplca los factores de crecimiento
	resultMultiplication = p_list.reduce(function (
		valueAcumulate,
		currentValue
	) {
		return parseFloat(valueAcumulate * currentValue);
	});

	//se cálcula el valor de la raíz
	resultGeometricAverage = rootForAnyIndex(resultMultiplication, n);

	return resultGeometricAverage;
}

const inputListAnnualPercentageOfSales = document.getElementById(
	'inputListAnnualPercentageOfSales'
);
const inputResulGeometricAverage = document.getElementById(
	'inputResulGeometricAverage'
);

const listSalesPercentageAnual = [26, 32, 28];

const resultGrowFactor = growthFactor(listSalesPercentageAnual);
const resultGeometricAverage = geometricAverage(resultGrowFactor);

// Se muestra los resultados en la p√°gina html
inputListAnnualPercentageOfSales.innerText = `${listSalesPercentageAnual} %`;
inputResulGeometricAverage.innerText = `${resultGeometricAverage}`;

Referencia

Reto a resolver en respuesta en la ruta de la Escuela de JS

Here my solution to calculate the geometrical average:

Me gustó uno de sus casos de uso, es excelente para negocios, ayuda a calcular con mejor exactitud el crecimiento de ventas anuales por ejm.

.
Aprovecho tambien para compartir el front de este taller en mi pagina:

Reto Taller 3
1- Promedio elegido: Media geométrica.
2- Casos de uso media Geom√©trica: Rentabilidad anual de una empresa, crecimiento de las ventas de un negocio, proporci√≥n media de personas en alg√ļn sector.
3-Implementacion en JavaScript

Media Geométrica

function calcularMediaGeometrica(lista){
    const multiplicarLista = lista.reduce(function(valoracumulado = 1,nuevoElemento){
        return valoracumulado * nuevoElemento
    })  
      const mediaGeometrica = Math.pow(multiplicarLista, 1/lista.length);; 
} 

As√≠ me sali√≥ a mi ūüėĄ
Les dejo los links donde saqué info

https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce
método reduce explicado

https://www.youtube.com/watch?v=xnPPCA5OIKc&ab_channel=FelipeDelgado
como sacar la media armónica

function mediaArmonica(lista) {
    const valoresDivididos = lista.map((elemento) => 1/elemento);
    const sumaValoresDivididos = valoresDivididos.reduce((acc, cur) => acc + cur);
    const resultado = lista.length / sumaValoresDivididos
    console.log(`La media armonica es ${resultado}`) 
}
  • ¬ŅCu√°l tipo de promedio elegiste para trabajar?

Para este reto he elegido trabajar con la media arm√≥nica. Se la obtiene de una cantidad definida de n√ļmeros y es igual al inverso de la media aritm√©tica de los rec√≠procos de cada uno de sus valores.

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

La media armónica es una herramienta exclente para realizar un promedio entre velocidades, tiempos, rendiemientos o valores que tengan un comportamiento similar, de esta forma es más representativa que la media aritmética.

Cabe destacar que la media arm√≥nica no existe cuando uno de los n√ļmeros a promediar tiene un valor de 0 o es muy peque√Īo en comparaci√≥n a los otros valores que van a formar parte del promedio.

  • ¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
function calcularMediaArmonica(lista) {
  let sumaDividendo = 0;
  lista.forEach((element) => {
    sumaDividendo += (1/element);
  });
  return lista.length / sumaDividendo;
}

console.info(calcularMediaArmonica([2, 3, 7, 10, 9]));

Elegí trabajar con el promedio ponderado. Este sirve para calcular el promedio en las universidades. siguiento la formula realicé el siguiente codigo:

const calificaciones = [
    {
        materia: "C√°lculo",
        nota: 8,
        credito: 3
    },
    {
        materia: "Química",
        nota: 9,
        credito: 3
    },
    {
        materia: "Física",
        nota: 7,
        credito: 2
    }
]

function promedioPonderado(calificaciones){
    
    /*Extrayendo en arrays independientes los elementos de nota y credito del objeto*/
    const notas = calificaciones.map(({nota}) => nota);
    const creditos = calificaciones.map(({credito}) => credito);

    /*Sumando valores de credito para posteriormente dividir segun formula*/
    const acumulador = (acumulador,creditos) => acumulador + creditos;
    let creditoSuma = creditos.reduce(acumulador);

    /*Recorriendo ambas listas y multiplicando valores uno a uno entre listas segun formula*/
    let ponderadoMultiplicado=0;
    for (let i = 0; i < notas.length; i++) {
        ponderadoMultiplicado = ponderadoMultiplicado + (notas[i]*creditos[i]);
    }
    /*Formula*/
    return ponderadoMultiplicado/creditoSuma;
}

/*Llamado de la función*/
promedioPonderado(calificaciones)

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media Geométrica

¬ŅQu√© casos de uso tiene tu tipo de promedio?
** Se usa en la valoración de porcentajes y frecuencias relativas (finanzas)**
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?

Hay dos formulas para sacarla media geométrica, en mi caso use la segunda que verán en la imagen a continuación

Y así se vería en código

Yo trabajé con la media armónica, la cual es usada para estudiar velocidades o tasas de cambio.
.
Si tenemos un conjunto de datos que representan los valores medidos m para la tasa de cambio de una variable y respecto a otra x, entonces la media armónica es un buen valor representativo de dicho conjunto.
.
La media arm√≥nica de una cantidad finita de n√ļmeros es igual al rec√≠proco de la media aritm√©tica de los rec√≠procos de dichos numeros.
.

.
A continuación mi código para calcularla.

function calcularMediaArmónica(listaDatos){
    let listaReciprocos = []

    for(i = 0; i < listaDatos.length; i++){
        listaReciprocos[i] = 1/listaDatos[i]
    }

    const sumaReciprocos = listaReciprocos.reduce(
        function (elementA = 0, elementB){
            return elementA + elementB
        }
    )

    const mediaArmonica = listaDatos.length/sumaReciprocos

    return mediaArmonica
}
  • Eleg√≠ Media Geom√©trica.

  • formula: (2 * 3 * 14) 1/3 = (84) 1/3 = 4,37952.

  • Caso de uso: frecuencia para calcular la tasa de crecimiento porcentual promedio de algunas series dadas, a trav√©s del tiempo. Ejemplo 1. Si el crecimiento de las ventas en un negocio fue en los tres √ļltimo a√Īos de 26%, 32% y 28%, hallar la media anual del crecimiento.

  • C√≥digo:


function mediaGeometrica(valores) {
  let total = 1;
  for (var f = 0; f < valores.length; f++) {
    if (valores[f] != 0) {
      total = valores[f] * total;
    }
  }
  console.log(Math.pow(total, 1 / valores.length));
  console.log(total);
}

mediaGeometrica([2, 3, 14]);

Hice la media armónica:

const harmonicMeanArray = [120, 20, 100, 130];

function calcHarmonicMean(harmonicMean) {
  const summAllNumbers = harmonicMean
    .map((number) => (1 / number))
    .reduce((accumulator, current) => accumulator + current);
  const result = harmonicMean.length / summAllNumbers;

  return parseFloat(result.toFixed(2));
}

Decidí calcular la media armónica. Es muy utilizada para el cálculo de la velocidad de los viajes de distancia fija.
.
Ventaja: En ciertos casos como el de las velocidades, es más representativo que la media aritmética.
Desventaja: Los valores muy peque√Īos influencian demasiado el resultado, y no se puede aplicar si el array tiene valores iguales a 0.
.
Formula

.
Código

// Sample Array
const sampleArray = [60, 40, 50, 55];

// Main function
function calcularMediaArmonica(lista) {
  const listaLenght = lista.length;

  let divisor = 0;

  for(let i = 0; i < listaLenght; i++) {
    partialResult = 1 / lista[i];
    divisor += partialResult;
  }

  const finalResult = (listaLenght / divisor).toFixed(2);

  console.log(`La media armónica es: ${finalResult}`)

  return finalResult;
}

calcularMediaArmonica(sampleArray);

Reto completado ‚ÄúPonderada‚ÄĚ!!!

Aquí dejo mi ejercicio, aunque vi algunos comentarios y ya la habían elegido jajauja, pero … de todos modos pongo mi versión

// Media geométrica 
// Media geométrica = raiz n(numero de elementos) de la multiplicación de elementos(a*b*...n)  

const prueba2 = [1,3,9,2,2];
const prueba = [1,3,9];
const prueba3 = [1,3,9,32,54,1,2,13,12];
// Conseguimos la multiplicación total
const multiplicacion = prueba.reduce((aux1=0, aux2) => aux1*aux2);
// Sacamos la raiz n
const root = prueba.length;
// Aplicar formula
const resultado = Math.pow(multiplicacion,(1/root));
}

Y pasando a función

function mediaGeometrica(lista) {
    const multiplicacion = lista.reduce((aux1=0, aux2) => aux1*aux2);
    const root = lista.length;
    const resultado = Math.pow(multiplicacion,(1/root));
    return resultado;

Calculando la Media Arm√≥nica ūüĎÄ

function calcularMediaArmonica (lista) {
    
    const newArray = []
    lista.forEach(element => {
        const result = 1 / element;
        newArray.push(result)
    });
    
    const sumarNumeros = newArray.reduce((valorAcumulado = 0, elemento) => {
        return valorAcumulado + elemento;
    })

    const operacion = newArray.length / sumarNumeros;

    return operacion;
}

Elegí trabajar con 2 tipos, Media Geométrica y Media Armónica.

Media Geom√©trica: Tiene muchas aplicaciones en el √°mbito de las finanzas, por ejemplo valoraci√≥n de porcentajes, frecuencia relativa, inter√©s compuesto, n√ļmeros √≠ndice, progresi√≥n geom√©trica, etc. Yo en este caso la us√© para promediar razones:

Utilizaré un ejemplo práctico sacado de internet:
Se muestran ventas anuales de una compa√Ī√≠a de 2014 a 2018. Tambi√©n aparecen las razones de las ventas respecto al a√Īo anterior.
La raz√≥n es la venta del a√Īo actual dividido las ventas del a√Īo anterior. Son √©stas las que utilizar√© para calcular la media geom√©trica.

Lo primero ser√≠a agregar los valores de la raz√≥n de cada a√Īo. Se debe verificar que sean positivos, ya que estaremos usando ra√≠z cuadrada.

const razones = [];
let mult = 1;
function agregarRazones (num) {
    if (num < 0) {
        console.log("Los datos tienen que ser positivos!");
    }else {
        return razones.push(num);
    }
}

Luego de tener la lista completa, calculamos la media geométrica:

function calcularMediaGeometrica (razones) {
    for (let i = 0; i < razones.length; i++) {
        mult = mult * razones[i];
    }
    let mediaGeometrica = Math.pow(mult, 1/razones.length);
    return mediaGeometrica;
}

La Media Armónica tiene diversas aplicaciones en cuanto a velocidades, rendimientos y tiempos.

const lista = [];
let sumatoria = 0;
function crearLista(valor) {
    return lista.push(valor);
}
function calcularMediaArmonica (lista) {
    for (let i = 0; i < lista.length; i++) {
        sumatoria += 1/lista[i];
    }
    let mediaArmonica = lista.length/sumatoria;
    return mediaArmonica;
}

Ingreso mi reto con todas las funciones estadísticas que pude resolver

function calcularMediaAritmetica(lista) {
  const sumaLista = lista.reduce(function (valorAcumulado = 0, nuevoElemento) {
    return valorAcumulado + nuevoElemento;
  });

  const promedioLista = sumaLista / lista.length;

  return promedioLista;
}

function calcularMediaGeometrica(lista) {
  const sumaLista = lista.reduce(function (valorAcumulado = 0, nuevoElemento) {
    return valorAcumulado * nuevoElemento;
  });

  const promedioLista = Math.pow(sumaLista, 1 / lista.length);

  return promedioLista;
}

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

  const mitadLista = parseInt(listaOrdenada.length / 2);

  let mediana;

  if (esPar(listaOrdenada.length)) {
    const elemento1 = listaOrdenada[mitadLista - 1];
    const elemento2 = listaOrdenada[mitadLista];

    const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);

    mediana = promedioElemento1y2;
  } else {
    mediana = listaOrdenada[mitadLista];
  }

  return mediana;
}

function esPar(numerito) {
  if (numerito % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

function calcularModa(lista) {
  const listaCount = {};

  lista.map(function (elemento) {
    if (listaCount[elemento]) {
      listaCount[elemento] += 1;
    } else {
      listaCount[elemento] = 1;
    }
  });

  const listaArray = Object.entries(listaCount).sort(function (
    elementoA,
    elementoB
  ) {
    return elementoA[1] - elementoB[1];
  });

  const moda = listaArray[listaArray.length - 1];

  return moda;
}

function calcularVarianza(lista) {
  const media = calcularMediaAritmetica(lista);

  const difCuadradoValorMedia = lista.reduce(function (
    valorAcumulado = 0,
    nuevoElemento
  ) {
    return valorAcumulado + Math.pow(nuevoElemento - media, 2);
  });

  const varianza = difCuadradoValorMedia / lista.length;

  return varianza;
}

function calcularDesviacionEstandar(lista) {
  const varianza = calcularVarianza(lista);
  const desvEst = Math.sqrt(varianza);
  return desvEst;
}

function calcularCoeficienteDeVariacion(lista) {
  const media = calcularMediaAritmetica(lista);
  const desEst = calcularDesviacionEstandar(lista);

  const coefVar = (desEst / media) * 100;

  return coefVar;
}

Reto completado:

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

      Promedio Geométrico
    
  • ¬ŅQu√© casos de uso tiene tu tipo de promedio?

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

const lista05 = [
    4,9,8,6,5,4,2,
];

//----Promedio Geometrico

function calcularPromedioGeometrico(lista){

    const multiLista = lista.reduce(
        function(valorAcumulado=0, nuevoElemento){
            return valorAcumulado * nuevoElemento;
        }
    );

    const promedioLista = Math.pow(multiLista, 1 / (lista.length))

    return promedioLista;

}
// Función calcular promedio
const calcularPromedio = cantidades => {
  return cantidades.reduce((acumulado = 0, nuevo) => {
    return acumulado + nuevo
  }) / cantidades.length
}

// Función calcular mediana
const calcularMediana = cantidades => {
  const mitadLista = cantidades.length / 2
  cantidades.sort((anterior, siguiente) => {
    return anterior - siguiente
  })
  if (cantidades.length % 2 === 0) {
    return calcularPromedio([cantidades[mitadLista - 1], cantidades[mitadLista]])
  } else {
    return cantidades[parseInt(mitadLista)]
  }
}

// Función calcular moda
const calcularModa = cantidades => {
  const listaValores = {}

  cantidades.forEach((elemento) => {
    if (listaValores[elemento]) {
      listaValores[elemento] += 1
    } else {
      listaValores[elemento] = 1
    }
  })

  const valoresOrdenados = Object.entries(listaValores).sort(
    (anterior, siguiente) => {
      return anterior[1] - siguiente[1]
    })

  return valoresOrdenados[valoresOrdenados.length - 1]
}

Solución al Media geométrica

Eleg√≠ trabajar con la media geom√©trica: es recomendada para datos de progresi√≥n geom√©trica, para promediar razones, inter√©s compuesto y n√ļmeros √≠ndice.

Esta es su fórmula:

En espa√Īol: Multiplicar todos los elementos del conjunto y hacer la ra√≠z correspondiente al n√ļmero de elementos del conjunto (2 -> ra√≠z cuadrara, 3 -> ra√≠z c√ļbica, etc)
LIsta de ejemplo:

const  lista = [1,3,9];

Función en Javascript:

lista.reduce ((a,b) => {return a*b;}) **(1/lista.length)

Para este reto se tomó en cuenta la Media Armónica.
Se utiliza para obtener promedios de velocidad, temperatura y en la m√ļsica.
La fórmula de la Media Armónica es:

Donde nos dice que la MA se representa con la letra H y esto es igual a la cantidad total de elementos entre la sumatoria del inverso de cada elemento.
Hay que tener en cuenta que esta media no aplica si uno de sus elementos es 0, esto por la división que se realiza en sus inversos.

Solución:
Se dividió el código en tres partes
1.- El numerador: que en nuestro caso sería la longitud del arreglo.
2.- El denominador: en este caso la suma de los inversos de cada elemento
3.- El resultado: en este caso la formula aplicada.
Entonces primero sacamos la longitud del arreglo, es decir, cuantos elementos tiene, posteriormente sacaremos el cálculo de la sumatorio de los inversos de cada elemento y al final solo aplicaremos la división de estos quedando la función de la siguiente manera:


function mediaArmonica(lista){
    const listaOrdenada=lista.sort(function(a,b){return a - b;});
    for(let i=0;i<=listaOrdenada.length;i++){
        if(lista[i]==0){
            alert("Este arreglo no es valido para la Media Armónica");
        }else{            
            const numeradorArmonico=listaOrdenada.length;
            const denominadorArmonico=listaOrdenada.map((numeros)=>1/numeros);
            const mediaArmonica= numeradorArmonico/(denominadorArmonico.reduce((acumulado=0,nuevoValor)=> acumulado+nuevoValor));
            return mediaArmonica;
        }
    }  
}

Promedio Geométrico

.
La fórmula del promedio geometrico es:

La raíz N (siendo N la cantidad total de elementos) del producto de todos sus elementos.

.
Código en javascript:

function promedioGeometrico(array) {
  let promedioG = 1;
  for (i of array) {
    console.log(`${promedioG} x ${i} = ${promedioG * i}`);
    promedioG *= i;
  }
  console.log(`La multiplicacion de los numeros es ${promedioG}`);
  promedioG = Math.pow(promedioG, 1 / array.length);
  promedioG = Math.round((promedioG + Number.EPSILON) * 100) / 100; // Redondeo al centésimo
  return promedioG;
}

En el reto realice el promedio ponderado, se puede utilizar para caso de sacar promedios de notas o calculos de promedios que son parte de otro valor, la formula la trabaje por partes:

  1. primero recogi la informacion de valores y datos de ponderacion desde mi pantalla.
  2. realizo la validacion que cada dato tenga una ponderacion correspondiente.
  3. la suma de los valores de ponderacion sumen 1 o 100 .
  4. converti las ponderaciones en su valor equivalente en porcentaje.
  5. luego si multiplique los datos por sus ponderaciones.
  6. sume los resultados anteriores.

¬ŅCu√°l tipo de promedio elegiste para trabajar?
R= Elegí la promedio geométrico
**
¬ŅQu√© casos de uso tiene tu tipo de promedio?**
R=Es √ļtil para obtener promedios de porcentajes o √≠ndices.
Ejemplo: Si se mide la rentabilidad de una empresa cada a√Īo
y se quiere obtener el promedio de rentabilidad a lo l√Īargo de 5 a√Īos.

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

function mediaGeometrica(lista) {
    listaRentabilidad = lista.map(function (object) {
        return object.rentabilidad;
    })

    let productoRentabilidad = 1;

    for(let i = 0; i < listaRentabilidad.length; i++) {
        productoRentabilidad = listaRentabilidad[i] * productoRentabilidad;
    }
    const mediaGeometrica = Math.pow(productoRentabilidad, 1 / listaRentabilidad.length);

    return mediaGeometrica;
};

Este reto me E N C A N T √ď ! Pude hacer semejante c√≥digo y me funcion√≥ y lo entend√≠. El curso toma forma cuando te das cuenta que empiezas a saber como manipular el c√≥digo.

Dejo link al repo en Github : https://github.com/Ibraturk/platzi-curso-basico-javascript/blob/main/PIC.js

Media Intercuartil.
El promedio intercuartil (PIC) es una medida estadística de la tendencia central basada en el promedio truncado del rango intercuartil .

El PIC es muy similar al método de puntuación utilizado en los deportes que son evaluados por un grupo de jueces: descartar el puntaje inferior y el superior; calcular el valor promedio de los puntajes remanentes

Cómo encontrar el PIC?

En el c√°lculo del PIC, solo se utilizan los datos del segundo y del tercer cuartil, y el 25% de los datos inferiores y el 25% de los datos superiores se descartan. suponiendo que los datos se encuentran ordenados.

Entonces como ejemplo definimos una lista de puntajes de salto acrob√°tico en las olimpiadas

Definimos lista // Caso PAR
let lista = [
80,
30,
10,
40,
26,
1,
26,
30,

];
Como se basa en dividir por cuartos la lista primero comenzamos ordenandola

const listaCount = lista.sort(function (a, b) {
return a - b;
}
);
Tenemos ahora 2 opciones , debemos ver si es divisible o no por 4. (25%, 25%, 25%, 25%) Cuartil.

// Si es divisible por 4
if (lista.length % 4 === 0){
while (lista.length > 4){
lista.shift();
lista.pop();
}
const sumaLista = lista.reduce(
function (valorAcumulado = 0, nuevoElemento) {
return valorAcumulado + nuevoElemento

    }
);

const promedioLista = sumaLista / lista.length;


const display = document.getElementById("display");
 display.innerText = "La edad promedio es de " + promedioLista;

}
Si es par lo que haremos es que si la longitud de la lista divisible por 4, mientras ese numero sea mayor a 4 (Los cuartos) Vamos a eliminar el primer y el ultimo numero.

En este caso al cumplir el condicional la lista queda así.

Captura de pantalla 2022-07-15 a la(s) 23.59.58.png
Habiendo ya quitado el cuarto inferior y superior nos disponemos a calcular la media aritmetica

function calcularMediaAritmetica(lista) {

const sumaLista = lista.reduce(
    function (valorAcumulado = 0, nuevoElemento) {
        return valorAcumulado + nuevoElemento

    }
);

const promedioLista = sumaLista / lista.length;


const display = document.getElementById("display");
 display.innerText = "La edad promedio es de " + promedioLista;

};

// Resultado Esperado = 28;

Caso IMPAR

Definimos lista
let lista = [
80,
30,
10,
40,
26,
1,
26,
30,
20,
];
Organizada
0: 1
1: 10
2: 20
3: 26
4: 26
5: 30
6: 30
7: 40
8: 80
Definimos en este caso el Rango intercuartil , que no es mas que la longitud de la lista / 2. Esto nos servir√° mas adelante.

const rangoIntercuartil = lista.length / 2;
Reducimos al minimo la lista mientras sea mayor a 5 (impar)

else {
while (lista.length > 5){
lista.shift();
lista.pop();
}
Captura de pantalla 2022-07-16 a la(s) 00.09.00.png
Al tener una lista de 5 vamos a tener por lo tanto, hay 3 datos completos en el rango intercuartil, y dos datos fraccionarios.

Dado que se tiene un total de 4.5 datos en el rango intercuartil, cada uno de los dos datos fraccionarios cuenta como 0.75

(y por lo tanto 3√ó1 + 2√ó0.75 = 4.5 datos).

Separamos los datos fraccionarios con el metodo .splice

const datoFraccionario = Number(lista.splice(0, 1)) + Number(lista.splice(3, 1));

Ahora si, definimos la variable para el Promedio intercuartil de este caso.

const PIC = ((sumaLista) + 0.75 * (datoFraccionario)) / rangoIntercuartil;

Y aplicamos al final el método .toFixed(2) para que solo tenga 2 decimales.

const display = document.getElementById(‚Äúdisplay‚ÄĚ);
display.innerText = "La edad promedio es de " + PIC.toFixed(2);

Medio rango

¬ŅCu√°l tipo de promedio elegiste para trabajar?
Media Ponderada
¬ŅQu√© casos de uso tiene tu tipo de promedio?
La media ponderada tiene numerosas aplicaciones, por ejemplo, la nota de una asignatura donde el examen final tiene un peso mayor al de un trabajo. O en el c√°lculo del IPC (√ćndice de Precios de Consumo). El IPC es un indicador de los precios de los bienes y servicios b√°sicos que consume la poblaci√≥n. Para calcularlo, se otorga pesos a los diferentes bienes (pan, fruta, vivienda,‚Ķ) y se calcula la media ponderada.
¬ŅC√≥mo traduces su f√≥rmula a c√≥digo JavaScript?
Para calcular la media ponderada hay que asignar un peso a los distintos valores que se van a tomar para obtener dicha media. La suma de todos los valores por sus pesos se divide finalmente por la suma de todos los pesos y se obtiene la media ponderada.
Ejemplo grafico:

Aplicación en código JS:


//creo la función
function CalcularMediaPonderada(elementos, pesos) {
//creo variables para almacenar los primeros resultados
    let resulEle= 0.0;
    let resulPeso= 0;
//utilizo "for" para realizar la primera parte de la operación
    for (let i = 0; i < elementos.length; i++) {
        resulEle = resulEle+(elementos[i]*pesos[i]);
        resulPeso = resulPeso + pesos[i];
    }
//Divido los resultados de ambas variables para obtener el resultado final
    mediaPonderada= resulEle/resulPeso;
//retorno la respuesta acortando los decimales a 2 d√≠gitos y lo vuelvo n√ļmero 
//(porque con .tofixed() se convierte en string)
    return parseFloat(mediaPonderada.toFixed(2));
}```

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

  • Media Geom√©trica.

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

  • La media geom√©trica se utiliza con m√°s frecuencia para calcular la tasa de crecimiento porcentual promedio de algunas series dadas de ventas , a trav√©s del tiempo.

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


    function calcularMediaAritmetica(lista){
        const productoLista = lista.reduce(
            function (valorAcumulado = 0, nuevoElemento){
                return valorAcumulado * nuevoElemento;
            } 
            
        );
        promedio= Math.pow(productoLista,(1/lista.length));
        return promedio;
    }

Observación Para calcular la raíz de n numero, intente usar la función Math.sqrt que recibe dos parámetros pero en realidad no me arrojaba la raíz esperada.

Yo escogi la media geometrica, y aqui esta la sol, saludos ūüėČ

function calcularMediaGeometrica(lista){
    return Math.pow(lista.reduce((a,b)=>a*b),1/lista.length);
}

Decidí emplear el promedio geométrico.
.
Se emplea para calcular los promedios sobre porcentajes más cercanos a la realidad. Por ejemplo el crecimiento porcentual en promedio en ventas, producción u otras actividades económicas.
.
Dentro de sus ventajas se encuentra que no es tan afectado por valores elevados, como sí sucede con la media aritmética.
,
.
Fórmula:

.
N = n√ļmero de elementos del conjunto
X = n√ļmero del elemento en el conjunto
n√ļmero sub√≠ndice = per√≠odo donde se evalu√≥ tal porcentaje o n√ļmero

.
Es un promedio conjunto, es decir que los valores del conjunto se multiplican entre ellos adem√°s de que deben ser n√ļmeros estr√≠ctamente positivos, ya que en caso de valer 0 un elemento el promedio ser√≠a 0 y si hay n√ļmeros negativos se obtendr√≠an valores negativos.
.
¬ŅQu√© hacer en casos de n√ļmeros negativos para porcentajes?
.
Se resta a 100 el n√ļmero:

  • -20% = 0.80
  • -15% = 0.85
  • -40% = 0.60
    Y se toma en la ecuación el valor de 0.80, 0.85 y 0.60 respectivamente
    .
    .
    .
    JS
const geoValues = [];
function geometricAverage(geoValues) {
    let y = Number(prompt("insert length of array"));
    let x = 0;
    while (x <= (y -1) ) {
        geoValues.push(Number(prompt("insert number")));
        x += 1;
        console.log(geoValues);
    }

    const valuesTotal = geoValues.reduce( function(previous = geoValues[0], current) {
        const sequence = previous * current;
        return sequence
    });

    const geometricV = Math.pow(valuesTotal, 1 / y);

    return Math.round(geometricV);

}
geometricAverage(geoValues);

Media Cuadr√°tica:

Resulta √ļ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, se utiliza para analizar aquellas variables en las que el signo no es importante, sino su valor absoluto.

function calucularMediaCuadratica(lista) {
// let sumaLista = 0;
// for (let i = 0; i < lista.length; i++) {
//     sumaLista = sumaLista + lista[i];   
// }

//ARRAY.REDUCE ()
// arr.reduce(callback(acumulador, valorActual[, índice[, array]])[, valorInicial])
  
const sumaLista = lista.reduce(     //metodo del ARRAY para recorrer los elementos del listado
    function (valorAcumulado = 0, valorActual) { // valorAcumulado = 0: si el valorAcumulado esta vacio pone 0, sino deja el valor que tiene
        return valorAcumulado + Math.pow(valorActual, 2);
    }
); 
const mediaCuadraticaLista = Math.sqrt(sumaLista / lista.length);
return(mediaCuadraticaLista);
}

Mi aporte al reto:

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

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

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

function calcularMediaArmonica(lista){

    let sumaLista = 0;

    lista.forEach(
        function sumatoria(elemento){
            sumaLista += 1 / elemento;
        }
    );
        
    const mediaArmonica = lista.length / sumaLista;

    return mediaArmonica;
}

Comparto mi solución para calcular promedios ponderados a partir de la implementación de los métodos reduce, map y push.

const notes = [];

//* Funcion constructora de estudiantes
function Student(course, note, credit) {
  this.course = course;
  this.note = note;
  this.credit = credit;
}

//TODO: funcion para insertar estudiantes al objeto 'notes'
const addStudent = (course, note, credit) => {
  let newStudent = new Student(course, note, credit);
  return notes.push(newStudent);
};

addStudent("Chemical", 9, 3);
addStudent("Mathematics", 8, 4);
addStudent("English", 7, 2);

//TODO: inserta datos de la multiplicacion entre 'note' y 'credit' en el array
let arrayNotes = [];
notes.map(function (obj) {
  const multNotes = obj.note * obj.credit;
  arrayNotes.push(multNotes);
});
console.log(arrayNotes);

//TODO: inserta datos de sumatoria de 'credit' en el array
let arrayCredits = [];
notes.map(function (objCredit) {
  const credits = objCredit.credit;
  arrayCredits.push(credits);
});
console.log(arrayCredits);

//TODO: suma de cada uno de los array en el dividendo y divisor
const add = arrayNotes.reduce((value1, value2) => value1 + value2);
const addCredits = arrayCredits.reduce((value3, value4) => value3 + value4);
console.log(`The average of notes is: ${add / addCredits}`);

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

Medio rango

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

Estas medidas de centro utilizan el menor y mayor valor para aproximar y entender un ‚Äúvalor medio‚ÄĚ o ‚Äúpromedio‚ÄĚ de un conjunto de datos.

rangoMedio = min(X)+max(X)/2

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

function findMidRange(list){
    list.sort(
        function(a,b){
            return a -b;
        }
    )
    
    const firstList = list.shift();
    const lastList = list.pop();
    
    const midRange = (firstList + lastList) /2;
    
    return midRange;
}

Para el reto yo hice una función de Promedios Geométricos o Media Geométrica.

Se define como la raíz índice n del producto de n términos. La media geométrica se utiliza con más frecuencia para calcular la tasa de crecimiento porcentual promedio de algunas series dadas, a través del tiempo.

function promedioGeometrico(numeros) {
    var suma = 0;
    var producto = 1;
    for (var i = 0; i < numeros.length; i++) {
        suma += numeros[i];
        producto *= numeros[i];
    }
    console.log("Suma de n√ļmeros: " + suma);
    console.log("Producto de n√ļmeros: " + producto);
    return Math.pow(producto / suma, 1 / numeros.length);
}

listaNumeros = [1, 2, 3, 4, 5];
console.log("Lista de n√ļmeros: " + listaNumeros);
console.log("Promedio Geométrico: ", promedioGeometrico(listaNumeros));

Decidí hacer la Media Cuadratica para el reto:

reto_media_cuadratica.js

function calcularMediaCuadratica(lista){
    // Suma de los elementos al cuadrado de la lista con el metodo reduce
    const sumaListaCuadrado = lista.reduce(
        function(valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado + nuevoElemento**2;
        }
    );

    const RMS = Math.sqrt(sumaListaCuadrado/lista.length);

    return RMS
}

Yo decidí calcular la desviación estandar, esta es una medida de dispersión, esto quiere decir que los ayuda a saber y entender que tan dispersos estan nuestros datos entorno al promedio.

function calcularDesviacionEstandar(muestra) {
    const promedio = calcularPromedio(muestra);
    let desviacionTotal = 0;
    
    muestra.forEach(element => {
        desviacionTotal += (element-promedio) ** 2;
    });

    let varianza = desviacionTotal/muestra.length;
    
    return varianza ** (1/2);
}

El promedio lo calcule como lo vimos en clase. ūüėč

Aquí mi app, en la cual encapsulé los 3 talleres hasta ahora.


‚Äď
‚Äď No tiene dise√Īo responsive, est√° dise√Īada desde mobile first!

‚Äď

P√°gina - Repositorio

Bueno , considero que hice una facil o entiendo mas hahahaha.

Elegi la media aritmerica pero algo resumida y la media geometrica.

La media aritmetica es para sacar un promedio de x valores. Y la geometrica para promediar razones, intereses compuestos etc.

//Hallar la media aritmetica

function mediaAritmetica(arr){

    const suma= arr.reduce((a,b) =>  a + b)/arr.length;
    
    return console.log("Tu media aritmerica es: " + suma);
}

//Media Geometrica

function mediaGeometrica(lista){

let mGeometrica = lista.reduce((a, b) => a * b);

const resultado = mGeometrica ** (1/lista.length);
return resultado;
}


Elegí la media Armónica : 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.

formula: https://economipedia.com/wp-content/uploads/media-armonica.png
código en JS:

//Media armónica

function calcularMediaArmonica(lista){
var divisor = 0;
for (var i = 0; i < lista.length;i++){
divisor = divisor + (1/lista[i]);
};
const mediaArmonica = lista.length/divisor;
return mediaArmonica;
};

calcularMediaArmonica(lista1);

Les comparto mis soluciones:
Media geométrica

function mediaGeometrica(lista){
    let producto = lista.reduce((a,b) => parseInt(a) * parseInt(b));
    let resultado = Math.round((producto ** (1/lista.length))*100) /100;
    return resultado;
}

Media armónica

function mediaArmonica(lista){
    let numerador = lista.length;
    let denominador = 0;
    for(var l = 0; l < lista.length; l++){
        let division = (1/lista[l]);
        denominador = denominador + division
    }
    let respuesta = Math.round((numerador / denominador) * 100) /100;
    console.log(respuesta);
    return respuesta
}

Promedio Ponderado

function promedioPonderado(lista)
{
    let numerador =  lista.map(elemento => elemento.note * elemento.credit).reduce((a,b) => a + b);
    let denominador = lista.map(elemento => elemento.credit).reduce((a,b) => a + b);
    let respuesta = Math.round((numerador / denominador)* 100) /100;
    console.log('El promedio pondenderados es: ' + respuesta);
}

BUENO PARA ESTE RETO YO ELEGI LA MEDIA PONDERADA

espero que salga la formula xd
BUENO EL CODIGO ES

// DATOS


var test1 = [
    [400,23],
    [400,25]
]


var media_pon = function(datos){
    var numerador = 0;
    for(let i=0;i<datos.length;i++){
        //ARRAY
        var dato1 = datos[i]   
        //DATOS ESPECIFICOS
        var w = dato1[0] 
        var x = dato1[1]       
        //MULTI     
        var wx = (w*x);      
        //CONCATENAR 
        numerador += wx      
    }
    var denominador = 0;
    for(let i=0;i<datos.length;i++){
        var dato1 = datos[i]   
        var w = dato1[0]       
        denominador += w   
    }

    var resultado = numerador/denominador
    return console.log(resultado)
}

los datos son asi en posicion 0 son digamos las personas = w dentro del codigo y en la posicion 1 estan digamos las personas con tal peso que yo lo puse como x dentro del codigo

Este sitio tiene muy buena documentación sobre JavaScript y otros lenguajes.

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

  2. ¬ŅQu√© casos de uso tiene tu tipo de promedio?
    Suele utilizarse para encontrar el promedio de la velocidad usada para recorrer una misma distancia. Un dato a tener en cuenta es que la colecci√≥n de n√ļmeros con la que se va a trabajar no debe incluir el cero.
    Mas información: https://es.wikipedia.org/wiki/Media_armónica

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

let lista = [1,3,8,2,7,2,9];

function calcularPromedioArmonico(lista){

    let promedioArmonico;

    //Verificar si hay ceros en la lista
    if(lista.some(x => x===0)){
        promedioArmonico = "No es posible calcular el promedio Aritmetico.";
    }else{
        //Hallar el inverso de cada elemento de la lista
        const inversos = lista.map(function (x){
            return 1/x;
        });
        
        //Sumar los inversos
        const sumaInversos = inversos.reduce(function(valorAcumulado,valorNuevo){
            return valorAcumulado + valorNuevo;
        });
        
        //Calcular el promedio
        promedioArmonico = (lista.length/sumaInversos);
    }
    return promedioArmonico;
}
console.log(`El Promedio Armonico es: ${calcularPromedioArmonico(lista)}`);

Mi aporte:

Prototipo funcional
Repositorio



Código JS:

/* Creo el Array */
const arrayCalificacion = [];

function loadArray() {
    /* Leo los datos escritos en el input y los cargo */
    const materias = document.getElementById("selectMaterias");
    const listaMaterias = materias.selectedOptions[0].text;
    const listaNumbers = document.getElementById("inputNumber").value;
    const listaCredits = document.getElementById("inputCredits").value;
    
    /* Creo el objeto */
    const calificacionPonderada = new Object();
    calificacionPonderada.materia = listaMaterias;
    calificacionPonderada.nota = Number(listaNumbers);
    calificacionPonderada.creditos = Number(listaCredits);

    /* Empujo los datos convertidos en n√ļmero (incluido decimal) al final del array */
    arrayCalificacion.push(calificacionPonderada);

    console.log(arrayCalificacion);
}

function calculatePonderado() {
    /* Multiplicar cada nota por su peso en créditos */
    const notesWithCredit = arrayCalificacion.map(
        function (noteObject) {
            return noteObject.nota * noteObject.creditos;
        }
    );

    /* Sumo todos los elementos de las notas multiplicadas por su peso en créditos */
    const sumOfNotesWithCredit = notesWithCredit.reduce(
        function (sum = 0, newVal) {
            return sum + newVal;
        }
    );

    /* Creamos un arreglo solo con los créditos */
    const credits = arrayCalificacion.map(
        function (noteObject) {
            return noteObject.creditos;
        }
    );

    /* Sumamos los créditos */
    const sumOfCredits = credits.reduce(
        function (sum = 0, newVal) {
            return sum + newVal;
        }
    );

    /* Dividimos ambas sumas */
    const promedioPonderado = (sumOfNotesWithCredit / sumOfCredits).toFixed(2);
    
    /* Publicamos el resultado */
    const finalResult = document.getElementById("FinalValue");
    finalResult.innerText = "El promedio ponderado es: " + promedioPonderado;
}
  1. Elegí calcular la media geométrica
  2. Se utiliza para calcular las tasas de crecimiento de una muestra
  3. Primero entendemos que la fómula de la media geométrica es:

    Por ende tenemos que transformarle a su forma de potencia siguiendo las leyes de los radicales:

Esta forma ya es mas clara para programarla en JavaScript, el código queda de la siguiente forma:

const lista = [200, 305, 503, 332, 241, 45, 123, 553, 122, 553, 664];

function calcularMediaGeometrica(lista) {
    let media = 1;

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

    const mediaGeometrica = Math.pow(media, 1 / lista.length);
    return mediaGeometrica;
}

Hice el de la media armónica.

let mediaArmonica =
            (lista)=>{
                let elementGroup = lista.length;
                const invers = lista.map((element)=>{
                    return 1 / element;
                });
                const sumInvers= invers.reduce((valorAnterior,valorActual)=>{
                    return valorAnterior + valorActual;
                },0);
                let resultado = elementGroup / sumInvers;
                return resultado.toFixed(4);