Reto: calcula otros tipos de promedio

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

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