No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

脷ltima oportunidad para asegurar tu aprendizaje por 1 a帽o a precio especial

Antes: $249

Currency
$189/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

0D
15H
21M
42S

Calculando la mediana en una lista par

15/30
Recursos

Aportes 58

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Utilic茅 el m茅todo Array.prototype.sort() para ordenar el array:

const arr = [5, 6, 2, 4, 1, 3];
function average(array) {
    return (array.reduce((acc, elem) => acc + elem, 0)) / array.length;
}
/**Mediana */
function mediana(array) {
    array.sort((a, b) => a - b);
    if (array.length % 2 !== 0) {
        return array[Math.floor(array.length / 2)];
    } else {
        let mid = array.length / 2;
        return average([array[mid - 1], array[mid]]);
    }
}

Mi soluci贸n al reto, gracias a la compa帽era @eliezer_sam93 que en sus comentario me hizo caer en cuenta que tocaba ordenar la lista jaajja.

Con el m茅todo .sort()

let array = [5,10,1,15,2,13];

function esPar(array) {
    let elements = array.length % 2;
    return elements == 0;
}

function calcularMediana (array){
    array.sort((a , b) => {
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
    });
// se puede simplificar array.sort((a,b) => a - b);
    let mitad = array.length / 2;
    if (esPar(array)){
        let mediana = (array[mitad-1] + array[mitad]) / 2
        return mediana;
    } else {
        let mediana = (array[(mitad-1).toFixed(0)]);
        return mediana
    }
}

calcularMediana(array);
// 7.5

Mi codigo con cada una de las funciones a parte y en la consola me muestra cada uno de los resultados de cada tipo de resultado.

// const lista = [12, 11, 13, 10, 4, 10000, 5, 6, 8, 7, 9, 3, 1, 2];
const lista = [12, 11, 13, 10, 4, 10000, 5, 6, 8, 7, 9, 3, 1, 2, 14];
const copyOfLista = [...lista];
let sortedList = [];
let sumaPromedio = 0;
let sumaSorted = 0;
let promedio = 0;
let promedioSorted = 0;
let medianaConIfCiclo = 0;
let medianaConPromedioCiclo = 0;

function calcularPromedio(lista) {
    sumaPromedio = 0;
    for (let index = 0; index < lista.length; index++) {
        sumaPromedio += lista[index];    
    }
    promedio = sumaPromedio / lista.length;
    return promedio;
}

function calcularPromedioSorted(lista) {
    sortedList = lista.sort((a, b) => a - b);
    calculoMediana(sortedList);

    sumaSorted = lista.reduce(sumarTodosElementos);

    promedioSorted = sumaSorted / lista.length;
    return promedioSorted;
}

function sumarTodosElementos(valorAcumulado, nuevoValor) {
    return valorAcumulado + nuevoValor
}

function calculoMediana(list) {
    if (list.length % 2) {
        medianaConIfCiclo = list[Math.floor(list.length / 2)];
    } else {
        medianaConIfCiclo = (Number(list[list.length / 2] + Number(list[(list.length / 2) - 1]))) / 2;
    }
    return medianaConIfCiclo;
}

function calculoMedianaConPromedio(list) {
    if (list.length % 2) {
        medianaConPromedioCiclo = list[Math.floor(list.length / 2)];
    } else {
        medianaConPromedioCiclo = calcularPromedio([list[(list.length / 2) - 1], list[list.length / 2]]);
    }
    return medianaConPromedioCiclo;
}

console.group('Promedio y Mediana');    
let promedioConCicloFor = calcularPromedio(lista);
let promedioConSorted = calcularPromedioSorted(lista);
let medianaConIf = calculoMediana(lista);
let medianaConPromedio = calculoMedianaConPromedio(sortedList);

console.log({
    '1-Lista Original: ': copyOfLista,
    '2-Lista Ordenada: ': sortedList,
    '3-Promedio con ciclo For: ': promedioConCicloFor,
    '4-Promedio con Sorted: ': promedioConSorted,
    '5-Mediana: ': medianaConIf,
    '6-Mediana(Calculando con promedio): ': medianaConPromedio
});
console.groupEnd('Promedio y Mediana')

Recibo cualquier tipo de sugerencia o correccion les agradezco.

Mi f贸rmula de mediana鈥sando la funci贸n de parImpar()

Mi soluci贸n. 馃挌

const list = [
  10,
  20, 
  400,
  300,
  50,
  1000, 
  700, 
  600,
  1000, 
  2500,
  6000,
  10000,
  10000000,
  500, 
  3000,
  200,
];

function calcularPromedio(list) {
  const totalSalaries = list.reduce((acumulator, num) => acumulator + num);
  console.log(totalSalaries);

  const promedio = totalSalaries / list.length;
  console.log(promedio);
}

function calcularMediana(list) {
  const listaEsPar = isPar(list);

  if (listaEsPar) {
    const primerIndexMitadPar = Math.floor(list.length / 2) - 1;
    const segundaIndexMitadPar = Math.floor(list.length / 2);

    const primerMitadPar = list[primerIndexMitadPar];
    const segundaMitadPar = list[segundaIndexMitadPar];

    console.log(
      primerMitadPar,
      segundaMitadPar
    );

    return calcularPromedio([primerMitadPar, segundaMitadPar]);
  } else {
    const indexMitadListaImpar = Math.floor(list.length / 2); 
    const medianaListaImpar = list[indexMitadListaImpar];
    console.log(medianaListaImpar);
  }
}

function isPar(lista) {
  return !(lista.length % 2);
}
  
calcularMediana(list);

Esta vez si segu铆 el concejo de Juan.

////Funci贸n para hallar el Promedio
function average(array){
    console.log('Los datos que ingreso fueron: ',array)
    const suma= array.reduce((sum,item)=>item+sum,0);
    return averageResult=suma/(array.length)
}

/// Funci贸n para saber si es par o impar 
function median(array){
    const number=(array.length)%2; 
    if(number==0){
        //es par
        let iUno= Math.floor((array.length/2));
        let iDos= Math.floor((array.length/2)+1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }else{
        //es impar
        let iUno=Math.floor((array.length/2));
        let iDos=Math.floor((array.length/2)-1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }
};
median([1,2,3,4,5,6,7]);

Hice el ejercicio con un input para que el usuario ingrese los valores que quiera (valida si son n煤meros), y dos botones, uno para agregar n煤meros y otro para realizar el c谩lculo.

Imprimimos en el DOM:

  1. Los valores agregados.
  2. Los valores agregados en orden ascendente
  3. La media calculada si es par o impar.

El codigo JS queda as铆:

const numsMedia = [];
const btnAddMedia = document.querySelector('.addMedia');
const btnCalcularMedia = document.querySelector('.calcularMedia');
const resultadoMedia = document.querySelector('.resultadoMedia');

btnAddMedia.addEventListener('click', function () {
  const inputNumsMedia = document.querySelector('#numsMedia');
  const nums = Number(inputNumsMedia.value);

  if (!isNaN(nums)) {
    numsMedia.push(nums);
    inputNumsMedia.value = ''; // Limpiar el campo de entrada
  }
});

btnCalcularMedia.addEventListener('click', function () {
  if (numsMedia.length === 0) {
    resultadoMedia.innerText = 'No hay n煤meros para calcular la media.';
    return;
  }

  const sortedNums = [...numsMedia].sort((a, b) => a - b);
  const mediana = calcularMediana(sortedNums);

  resultadoMedia.innerText = `Valores: ${numsMedia.join(', ')}
Valores ordenados: ${sortedNums.join(', ')}
Mediana: ${mediana}`;
});

function calcularMediana(nums) {
  const mitad = Math.floor(nums.length / 2);

  if (nums.length % 2 === 1) {
    return nums[mitad];
  } else {
    return (nums[mitad - 1] + nums[mitad]) / 2;
  }
}

El c贸digo HTML queda as铆:

<section class="media">
    <h2>Calculadora de Media</h2>
    <label for="numsMedia">Ingresa los valores para obtener la Media</label>
    <input type="number" id="numsMedia">
    <button type="submit" class="addMedia">Agregar</button>
    <button type="submit" class="calcularMedia">Calcular</button>
    <h3>Resultado</h3>
    <p class="resultadoMedia"></p>
</section>

Asi fue como lo hice, ya que tenia en una sola funci贸n el identificar si al lista era par o impar.-

Mi solucion:

function esPar(lista){
  return lista.length % 2 === 0;
}

function calcularMediana(lista){
  //Acomoda los numeros de menor a mayor
  const listaOrdenada = [...lista].sort((a,b)=>a-b);
  if(esPar(lista)){
    const inicioListaPar = listaOrdenada[(listaOrdenada.length/2)-1];
    const finalListaPar = listaOrdenada[(listaOrdenada.length/2)];
    const promedioListaPar = (listaOrdenada[inicioListaPar]+listaOrdenada[finalListaPar])/2;
    return promedioListaPar;
  }else{
    const medioListaPar = Math.floor(listaOrdenada.length/2); 
    return listaOrdenada[medioListaPar];
  }
}
function calcularMediana(lista) {
  // Primero, ordenamos la lista
  lista.sort(function(a, b) {
    return a - b;
  });
  
  // Obtenemos la longitud de la lista
  var longitud = lista.length;
  
  // Calculamos la posici贸n del valor central
  var mitad = Math.floor(longitud / 2);
  
  // Si la lista tiene un n煤mero impar de elementos, la mediana es el valor central
  if (longitud % 2 !== 0) {
    return lista[mitad];
  }
  // Si la lista tiene un n煤mero par de elementos, la mediana es la media aritm茅tica de los dos valores centrales
  else {
    return (lista[mitad - 1] + lista[mitad]) / 2;
  }
}

Mi soluci贸n

'use strict';
const numbers = [12, 56, 56, 78, 23, 56, 12, 23, 24, 71, 55, 20, 41, 46]
const numbers2 = [9, 10, 12, 3, 1, 6, 8]

function average(array) {
    const sum = array.reduce(
        (accumulator, currentValue) => accumulator + currentValue
    )
    const average = sum / array.length
    return average
}
average(numbers) // 44.13
average(numbers2) // 3

// saber si un array es par o no
const isEven = array => array.length % 2 == 0 ? true : false
isEven(numbers)

function mediana(array) {
    let median
    const arrayB  = array.sort((a, b) => a - b);
    
    if (isEven(array)) {
        const index1 = arrayB.length / 2;
        const index2 = (arrayB.length / 2) - 1;
        const list = [arrayB[index1], arrayB[index2]]
        median = average(list)
    } else {
        let indexMediana = Math.floor(arrayB.length / 2);
        median = arrayB[indexMediana]
    }
    console.log(arrayB);
    console.log(median);
}
mediana(numbers)
mediana(numbers2)

Aqu铆 mi c贸digo:

function calcularPromedio(array) {
    let sumaLista = array.reduce((count, number) => count + number, 1);
    const promedio = sumaLista / array.length;
    return promedio;
}

function listaEsPar(lista) {
    return !(lista.length % 2) ? true : false;
}

function calcularMediana(lista) {
    if (listaEsPar(lista)) {
        let mediumValues = []
        mediumValues.push(lista[Math.ceil(lista.length / 2) - 1]);
        mediumValues.push(lista[Math.floor(lista.length / 2) - 1]);
        return calcularPromedio(mediumValues)
    } else {
        return lista[Math.ceil(lista.length / 2) - 1]
    }
}

let arraySalarios = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];

console.log(calcularMediana(arraySalarios));

when metodo array.sort()

Recordemos la definici贸n de mediana

  • 馃摃Definici贸n: 鈥淢edida de tendencia centrar que es igual al valor que divide a la mitad a los datos cuando son ordenados de menor a mayor.鈥

  • Fuente: Libro Control estad铆stico de la calidad y seis sigma - tercera edici贸n

function calcularMediana(lista){
    const listaPar = esPar(lista);
    if (listaPar){
        const priemerValorMedianaPar = lista[(lista.length / 2) - 1];
        const segundoValorMedianaPar = lista[(lista.length / 2)];
        const medianaListaPar = calcularPromedio([priemerValorMedianaPar, segundoValorMedianaPar]);
        console.log(priemerValorMedianaPar);
        console.log(segundoValorMedianaPar);
        console.log(medianaListaPar);
        return medianaListaPar;

    }else {
        const indiceMedianaImpar = Math.floor(lista.length / 2);
        const medianaListaImpar = lista [indiceMedianaImpar]
        console.log (indiceMedianaImpar);
        console.log (medianaListaImpar);
        return medianaListaImpar;
    }
}

creo que existe el m茅todo sort en javaScript, pero me dieron ganas de aplicar el m茅todo de ordenamiento por inserci贸n.

let desordenedList = [5,7,6,2,9,1,8,2,3];

const insertionSort = (arr) => {
    let position = 0;
    let aux ;

    for (let i = 0; i < arr.length; i++) {
        position = i; 
        aux = arr[i];
        while((aux < arr[position-1]) && (position > 0)){
            arr[position] = arr[position-1];
            position--;
        }
        arr[position] = aux;
    }
    return arr;
}

console.log(insertionSort(desordenedList));

Aca mi Solucion :

Saludos 馃憢

Llegue al mismo metodo que todos pero encontre algo copado para agilizarlo un en futuras funciones que necesitemos ordenar un array de numeros.
Si al inicio de nuestro seteamos esto

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

De ahi en adelante ya no tenemos que reescribir una y otra vez esta funcionan para hacer sort con numeros, los llamamos de la siguiente manera

function calcularMediana(lista) {
    lista.sortNormal(); //Aqui ya estamos ordenando el array
    console.log(lista)
    const listaEsPar = esPar(lista);
    if (listaEsPar) {
        const Mitad1ListaPar = lista[(lista.length / 2) - 1];
        const Mitad2ListaPar = lista[lista.length / 2];

        // lista[index]
        const medianalistaPar = calcularPromedioReduce([Mitad1ListaPar,Mitad2ListaPar])
        return medianalistaPar
    } else {
        const indexMitadListaImpar = Math.floor(lista.length / 2);
        const medianaListaImpar = lista[indexMitadListaImpar];
        console.log(indexMitadListaImpar);
        console.log(lista[medianaListaImpar]);
        return lista[medianaListaImpar];
    }
}

Mi soluci贸n

 const mediana  = (array) =>{
    let orden = array.sort((a,b) => a-b);
    let datos = array.length%2;

    if (datos == 0) {
        let position = (orden.length)/2;
        let mediana = (orden[position-1]+orden[position])/2;
        return mediana.toFixed(2);
    }else{
        let position = (orden.length + 1)/2;
        let mediana =orden[position-1]
        return mediana.toFixed(2);
    }
}

function generarMediana(){
    const response = document.getElementById("response");

    console.log("el promedio es: "+mediana(numeros));
    response.textContent = "La mediana de: ["+numeros+"] es: "+mediana(numeros);
}

Calculando la Media

function calcularMedina (lista) {
    if (lista.length % 2) {
        //logica cuando la lista es impar
        return lista[Math.floor(lista.length / 2)] 
    }else {
        //Logica cuando la lista es par
        return ((lista[Math.floor(lista.length / 2)]) + (lista[Math.floor(lista.length / 2) -1])) /2
    }
}

Lo hice un poco m谩s sencillo:

function media(list) {
    const newList = list.sort();
    if (!(newList.length % 2)) {        
        console.log(((newList[newList.length / 2] - 1) + (newList[newList.length / 2])) / 2);
    } else {
        console.log(newList[Math.floor(newList.length / 2)]);
    }
};

Mi soluci贸n final ordenando el array.

parOinpar = (array2) => { 
  /* el metodo .sort() nos permite ordenar los elementos de un array, 
  si es un string lo ordena en orden alfabetico de acuerdo a unicode, 
  si es n煤mero se requiere comparar los dos parametros establecidos de 
  a y b restandolos para que as铆 devuelva el orden correcto,
   array2.sort(function(a, b){return a - b}); */

  array2.sort(function(a, b){return a - b}); 

  let cantidadDeArray = array2.length;
  let redondear = Math.round((array2.length / 2)) ;
  console.log(cantidadDeArray/redondear);
  if (cantidadDeArray/redondear == 2 ){
    const indexMediana = Math.floor(array2.length /2) ;
    const mediana1 = array2[indexMediana];
    const mediana2 = array2[indexMediana -1] ;
    const promedioMedianaFInal = (mediana1 + mediana2) / 2;
    let medianaFinal = p.innerHTML= "la mediana del array es " + promedioMedianaFInal;
  }else{
      const indexMediana = Math.floor(array2.length /2) ;
      const mediana = array2[indexMediana];
      console.log("la mediana del array es " + mediana);
      let medianaFinal = p.innerHTML= "la mediana del array es " + mediana;
    }
};

parOinpar([1,2,3,4,5,10,6,7,8,9]);

no entend铆a muy bien el m茅todo .sort() para rdenar los n煤meros, pero este art铆culo me ayud贸 a comprender com es que lo ordena https://www.freecodecamp.org/espanol/news/ordenar-arreglos-en-javascript-como-usar-el-metodo-sort/.

Logre hacerlo de esta forma

function medianaListaPar(lista){
  lista.sort()
  for (let numero of lista) {
    console.log(((lista[lista.length / 2 ] + lista[lista.length / 2 - 1])/2))
  }
}

jjaja DOS COSAS 馃馃槄

Mi l贸gica est谩 mejorando creo, porque ANTES DE EMPEZAR EL CURSO comenc茅 a hacer el ejercicio de la lista par y mi l贸gica fue la misma que el profe, solo tuve un par de detalles, pero me emociona mucho eso 馃き馃槏

y segundo, me pas贸 algo muy gracioso que me hizo ir a regresarme que estaba pasando鈥 puse como argumento de la funci贸n un arreglo de n煤meros hechos string jajaja entonces no me sumaba nada, pero me gust贸 mucho este ejercicio 馃き馃ぃ

Le arregl茅 un peque帽o problema de calculo que ten铆a desde la clase pasada.

JS

// media

document.getElementById("middle").addEventListener("click", function() {

    let media = allnumbers.map(function (x){return parseInt(x, 10)});
    
        if (allnumbers.length % 2 === 0) {
            const medianapar1 = Math.floor(media.length / 2);
            const medianapar2 = Math.floor(media.length / 2) + 1;
            const medianaListapar = (media[medianapar1 - 1] + media[medianapar2 -1]) / 2;
            console.log("La mediana es: " + medianapar1 +", "+ medianapar2);
            console.log("Y su valor es: " + medianaListapar);
            return medianaListapar;
        } else {
          const medianaImpar = Math.floor(media.length / 2) + 1;
          const medianaListaImpar = media[medianaImpar - 1];
          console.log("La mediana es: " + medianaImpar);
          console.log("Y su valor es: " + medianaListaImpar);
          return medianaListaImpar;
        }
    });
const ordenarArreglo = (arr) => {
  return arr.sort();
}
const mediana = (arr) => {
  const arregloOrdenado = ordenarArreglo(arr);
  if(arregloOrdenado.length %2 !== 0){
    return arregloOrdenado[Math.floor(arregloOrdenado.length / 2)]
  }else{
    const arrParcial = arregloOrdenado.slice
    ( 
      Math.floor(arregloOrdenado.length / 2) - 1,
      Math.floor(arregloOrdenado.length / 2) + 1
    )
    return arrParcial.reduce((a,b) => a+b) / arrParcial.length
  }
}
console.log(ordenarArreglo([5, 9, 3, 0, 1, 6]))
console.log(mediana([5, 9, 3, 0, 1, 6]))

Para poder ordenar la lista us茅 el m茅todo .sort()

S茅 que se podr铆a ahorrar varias l铆neas de c贸digo en mi soluci贸n pero prefiero que sea lo m谩s entendible posible para m铆 (cuando vuelva a revisar mi c贸digo en el futuro) y otras personas.

       function mediana (){

    lista1 =[0,1,2,4,8,4,8,7,9,3];
    listaOrdenada= lista1.sort()

    if (lista1.length %2 ==0){

        let listaPar = (lista1.length/2)
        let medianaListaPar = (lista1[listaPar] + lista1[listaPar - 1 ])/2
        
        return medianaListaPar;
    
        
    } 

    else{

        let listaImpar= Math.floor (lista1.length/2)

        let medianaListaImpar = lista1[listaImpar]
       
        return medianaListaImpar
    }

    
}

console.log(mediana());

Yo lo hice mas corto, y despues vi la solucion de Juan David

const notas = [2, 3, 4, 5];

function calcMediana(arr) {
	if (esimPar(arr)) {
		const indiceMed = Math.floor(notas.length / 2);
		const mediana = arr[indiceMed];
		console.log("impar" + mediana);
	} else {
		const indiceMed = arr.length / 2;
		const mediana = (arr[indiceMed] + arr[indiceMed - 1]) / 2;
		console.log("par" + mediana);
	}
	function esimPar(lista) {
		return lista.length % 2;
	}
}

calcMediana(notas);

Ordenando con Sort y aplicando Math.floor

function runMedian(array) {
    const sortArray = array.sort((a, b) => {return a - b});
    
    if(sortArray.length % 2) {
        return sortArray[Math.floor(sortArray.length/2)];
    } else {
        return (myArray[(myArray.length/2)-1] + myArray[myArray.length/2]) / 2;
    }
}

const myArray = [10, 201, 25, 200, 65, 89, 45, 14];
console.log(runMedian(myArray));
```js // Mi soluci贸n. const lista = []; const cantidadDeElemntos = lista.length; function esImparPar (cantidadDeElemntos) { if (cantidadDeElemntos % 2 === 1){ return "Impar"; } else{ return "Par"; }; }; //::::::::Calcular la mediana de un Array:::: function calcularMediana (lista) { const cantidadDeElemntos = lista.length; if(esImparPar(cantidadDeElemntos) === "Impar"){ const indexMedianaArray = Math.floor(cantidadDeElemntos / 2); const mediana = lista[indexMedianaArray]; console.log("La mediana es: " + mediana); } else if (esImparPar(cantidadDeElemntos) === "Par") { const indexMedianaArray1 = Math.floor((cantidadDeElemntos / 2) -1); const indexMedianaArray2 = Math.floor(cantidadDeElemntos / 2); const mediana1 = lista[indexMedianaArray1]; const mediana2 = lista[indexMedianaArray2]; console.log("La mediana es: " + mediana1 + " y " + mediana2); } }; ```
Yo lo hab铆a hecho as铆: ```js let ratings = [10, 10, 10, 10, 10, 5, 7, 7, 7, 7, 3, 3, 2]; //Mediana const calculateMedian = () => { let centerNumber; let median; let orderNumbers = ratings.sort((a, b) => { return a - b; }) if(ratings.length % 2 === 0) { centerNumber = orderNumbers.length / 2; median = (orderNumbers[centerNumber] + orderNumbers[centerNumber - 1]) / 2; console.log(median); return median; } else { centerNumber = orderNumbers.length / 2; median = orderNumbers[Math.floor(centerNumber)] console.log(median); return median; } } calculateMedian(ratings); ```

Mi codigo para calcular la mediana si es par

if(listaEsPar){ //Va a entrar si la variable listaEsPar guardo un true 
        const indexPar1 = arr.length/2;
        const indexPar2 = indexPar1 -1;
        const medianaListaPar = (arr[indexPar1] + arr[indexPar2])/2;
        return medianaListaPar;
    }

nose si es el mejor codigo pero鈥

//Calcula si un numero es par
function esPar(lista){
    return !(lista.length % 2);
}
//Calcula si un numero es impar 
function esImpar(lista){
    return lista.length % 2;
}

function calcularPromedio(lista){

    function sumarTodosElementos(valorAcumulado, nuevoValor){
        return valorAcumulado + nuevoValor;
    }

    const  sumaLista = lista.reduce(sumarTodosElementos);
    const promedio = sumaLista/ lista.length;
    return promedio;
}

function calcularMediana(lista){
    const listaEsPar = esPar(lista);
    const indexListaMit = Math.floor (lista.length / 2);
    if(listaEsPar){
        //..
        const listaPar = [(lista[indexListaMit-1]), (lista[indexListaMit])];
        return calcularPromedio( listaPar)
    } else {
        //...
       return lista[indexListaMit]
    }
}

Sera que esto esta bien??

let pillo = ['maria','juana','miriam','jose','ira','polo','mira','holo','pera','pusha']
let polo = 0


function medio(lista){
    if(lista.length % 2 === 0){
        return  polo = [lista[(Math.round(lista.length / 2)-1)], lista[Math.round(lista.length / 2)]]
    } else {
      return  polo = lista[Math.round(lista.length / 2 ) -1]
    }
}

console.log(medio(pillo))

        const mitadListaImpar = lista.length / 2
     
        const primerValor = lista[mitadListaImpar - 1]
        const segundoValor = lista[mitadListaImpar ]

        const mediaListaPar = (primerValor + segundoValor) / 2

        return mediaListaPar```

Siempre sera mejor usar los metodos de Array !!.
Me quedo con el .push

Ac谩 mi soluci贸n al ejercicio de la clase

<
const getMediana=(array)=>{

    if(Array.isArray(array) && array.every(elem=> typeof elem === "number")){

        if(array.length%2===0){

            const sortedArr= array.sort()
            const mitad=sortedArr.length/2
            const mediana=(sortedArr[(mitad-1)] + sortedArr[mitad])/2

            return mediana

        }

         else if(!(array.length%2===0)){

            const sortedArr= array.sort();
            const  mitad= Math.floor(sortedArr.length/2);

            return sortedArr[mitad];

        } 
        
    }

    else if(!Array.isArray(array)){
        throw new Error("La entrada debe ser un arreglo");
    }

    else if(array.every(elem=> typeof elem!=="number")){
        throw new Error("La entrada debe ser un arreglo numerico")
    }
    
}
> 

Yo logre otra solucion, con el metodo slice, que crea una nueva lista con los dos numeros

function calcularMediana(listaMediana) {
  const listaEsPar = esPar(listaMediana)

  if (listaEsPar) {
    const numerosMitadLista = listaMediana.slice((listaMediana.length / 2) - 1, (listaMediana.length / 2) + 1).map(Number)
    const indexMitadListaPar = calcularPromedio(numerosMitadLista)
    console.log(indexMitadListaPar);
  } else {
    const indexMitadListaImpar =  Math.floor(listaMediana.length / 2)
    const medianaImpar = listaMediana[indexMitadListaImpar]
    console.log(medianaImpar);
  }
}
<code> 
 function esPar(lista){
    return!(lista.length%2);
}
  function esImpar(lista){
    return(lista.length%2);
}

function calcularMediana(lista) {
    const listaEsPar=esPar(lista);
    if(listaEsPar){
        const indice1=Math.floor(lista.length/2)-1;
        const indice2=Math.floor(lista.length/2);
        let medianaPar=(lista[indice1]+lista[indice2])/2;
        console.log(medianaPar);
    }else{
        const medianaImpar=Math.floor(lista.length/2)+1;
        let imparMediana=lista[medianaImpar - 1];
        console.log(imparMediana);
    }
}

Mi Humilde aporte :麓)

// 1,4,6,7 => par     mediana =4+6/2
// 1,3,5,6,8=> impar  median  =5

function isPar(num){
    return num%2==0;
}

function mediana(lista){
    if(isPar(lista.length)){
        //Par
        const listOrder=lista.sort((a,b)=>{
            return a-b;
        });

        il=listOrder.length/2-1;
        im=il+1;
        console.log(listOrder);
        return (listOrder[il]+listOrder[im])/2;

    }else{
        //Impar
        const index=Math.floor(lista.length/2);
        return lista[index];
    }
}

const numeros=[10,2,3,4,5,6,7,9,10,45];
//console.log(mediana(numeros));
console.log(mediana(numeros));

Asi me quedo mi codigo, en la parte del promedio del par, para no enredar el codigo llame a cada media de cada lado y los sume y dividi para no enredar el codigo, y con los aportes de anteriores clases organize el codigo de manera ascendente, asi:

const calcularMediana = lista => {

    listaOrganizada = lista.sort((a,b) => a - b);
    console.log(listaOrganizada);
    
    if (esParOImpar(listaOrganizada) === true) {
        const indexMitadListaparIzquierda = (listaOrganizada.length / 2) - 1;
        const indexMitadListaparDerecha = listaOrganizada.length / 2;
        const mediaListaparIzquierda = listaOrganizada[indexMitadListaparIzquierda];
        const mediaListaparDerecha = listaOrganizada[indexMitadListaparDerecha];
        const mediaListapar = (mediaListaparDerecha + mediaListaparIzquierda) / 2;
        return mediaListapar;
    } else{
        //Para encontrar los numeros
        const indexMitadListaImpar = Math.floor(listaOrganizada.length / 2);
        const mediaListaImpar = listaOrganizada[indexMitadListaImpar];
        return mediaListaImpar;
    }
}

no siempre conviene modificar una lista dada, por lo que antes de hacer el sort() copi茅 la lista a una nueva

let listaOrdenada = [...lista]; 
listaOrdenada.sort((a,b)=> a-b);

Aca mi 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>Promedios</title>
</head>
<body>
<form action="">
    <label for="name">Agregar un nuevo Integrante</label>
    <input type="text" id="name">
    <input type="number" id="age">
    <input type="button" id="addNewMember" value="Agregar miembro">
    <input type="button" id="killMembers" value="Borrar a todos">
    <input type="button" id="calcAverage" value="Hacer promedio de edad">
    <input type="button" id="calcMid" value="Conseguir Mediana de edad">
</form>

<h3>Integrantes:</h3>
<ul id="memberList">
</ul>

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

y mi JS

const addNewMemberBtn = document.getElementById('addNewMember');
const killMembersBtn = document.getElementById('killMembers');
const calcAverageBtn = document.getElementById('calcAverage');
const calcMidBtn = document.getElementById('calcMid');
let allMembers = [];



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

    const nameInput = document.getElementById('name');
    const ageInput = document.getElementById('age');
    let name = nameInput.value;
    let age = ageInput.value;
    let list = document.getElementById('memberList');

    allMembers.push({
        'name': name,
        'age': age,
    });

    let newMember = document.createElement('li')
    
    newMember.textContent = `Nombre: ${name}, Edad:${age}.`
    list.appendChild(newMember);

    nameInput.value = '';
    ageInput.value = '';
}

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

    let list = document.getElementById('memberList');
    let msg = document.getElementById('msg'); 

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

    allMembers.length = 0;
    msg.textContent = '';
}

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

    let msg = document.getElementById('msg');
    
    const counter = allMembers.reduce((totalValue, newValue) => totalValue + Number(newValue.age), 0)

    let average = counter / allMembers.length;
    msg.innerHTML = `El promedio de edad de los miembros es de ${average}`
}

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

    let msg = document.getElementById('msg');
    
    const order = allMembers.sort((a, b) => Number(a.age) - Number(b.age))
    
        if(allMembers.length % 2 != 0){
            const midIndex = Math.floor(allMembers.length / 2)

            msg.innerHTML = `La mediana de edad de los miembros es de ${order[midIndex].age}`

        } else {
            const indexOne = Math.floor(allMembers.length / 2);
            const indexTwo = indexOne - 1;
            
            const middValue = (Number(allMembers[indexOne].age) + Number(allMembers[indexTwo].age))/2

            msg.innerHTML = `La mediana de edad de los miembros es de ${middValue}`

        }
}


addNewMemberBtn.addEventListener('click', addNewMember);
killMembersBtn.addEventListener('click', killMembers);
calcAverageBtn.addEventListener('click', calcAverage);
calcMidBtn.addEventListener('click', calcMid);


Lo que hice fue a帽adir un 鈥渁rray.sort()鈥 apenas inicia la funci贸n calcular mediana.

// mediana

const esImpar = (array) => array.length%2
function calcularMediana (array) {
    array.sort((a,b) => a-b);
    const arrayEsImpar = esImpar(array);
    
    if (!arrayEsImpar) {
        const ObjetoMedianaPar1 = array[(array.length/2)-1];
        const ObjetoMedianaPar2 = array[array.length/2];
        const ObjetosMediana = [ObjetoMedianaPar1, ObjetoMedianaPar2]
        const medianaPar = calcularPromedio (ObjetosMediana)
        return medianaPar
    } else {
        const IndexMedianaImpar = (Math.floor(array.length/2))
        const medianaImpar = array[IndexMedianaImpar]
        return medianaImpar
    }
}


// promedio
function calcularPromedio(array) {
    // function sumarElementos(valorAcumulado, nuevoValor) {
    //     return valorAcumulado + nuevoValor;
    // }

    // const sumaTotal = array.reduce(sumaArray);

    const sumaArray = array.reduce((a,b) => a + b);
    const promedio = (sumaArray / array.length);
    return promedio;
}
<code> 

15. Calculando la mediana en una lista par e impar

/* 
- promedio or mediana aritm茅tica +++ / lenght
    - 1, 2, 3 rpt: 6/3
- mediana 
	- 450, 500, 600 rpt: 500
	- 100, 200, 300, 400 rpt: 200+300/2
- moda: valor que se repite mas veces (cualquier dato)
*/

const array = [5,2,1,4,3];
const what_is_it = array.length % 2 == 0;
// true is par (even) and false is impar (odd)

const sorted_array = array.sort();

const mediana = what_is_it 
    ? (sorted_array[((sorted_array.length / 2) - 1)] + sorted_array[(sorted_array.length / 2)]) / 2 
    : sorted_array[Math.floor(sorted_array.length / 2)];

console.log(sorted_array, 'is', mediana);

<code> 
const id = [1,2,3,4,5,6,7,8,9,10,11,12];
const longitud = id.length

if(id.length%2 == 0){
  const par = true;
  console.log('par');
  arrayPar(id)
}else{
  const par = false;
  console.log('no par');
  arrayInPar(id)
};

function arrayPar(array){
  const lon = longitud/2;
  const sumaMid = array[lon - 1] + id[lon];
  const Mediana = sumaMid / 2;
  console.log(Mediana)
}
function arrayInPar(array){
  const lon = ((longitud + 1) /2)-1;
  const Mediana = array[lon];
  console.log(Mediana)
}

Me gustan mas estas variables 馃槂

const arr = [5,2,1,4,3,6];

/* function esPar(array){
    // true: par  false: impar
    return array.length % 2 == 0 ? true : false; 
}
esPar(arr); */

function median(){
    // true: par  false: impar
    if(arr.length % 2 == 0){
        let left_index = arr[(arr.length / 2) - 1];
        let right_index = arr[arr.length / 2];
        let index_list = [left_index, right_index];

        let average = index_list.reduce((suma, indice) => suma + indice);

        let median_is = average / index_list.length; //2
        
        console.log(`Pair list ${arr} The Median is: ${median_is}`, average);
        return
    }else{
        let index = Math.floor(arr.length / 2);
        let median_is = arr[index];
        console.log(`Odd list ${arr} The Median is: ${median_is}`);
        return
    }
}

median(arr.sort())

Explicaci贸n para determinar la mediana de una lista IMPAR

Explicaci贸n para determinar la mediana de una lista PAR

Resultado:

C贸digo para ordenar un array de n煤meros de menor a mayor:

// Mi soluci贸n
lista.sort((a, b) => a - b);
    let index1 = Math.floor (lista.length / 2) - 1;
    let index2 = Math.floor (lista.length / 2);
    const medianaListaPar = (lista[index1] + lista[index2]) / 2;
    return medianaListaPar;

Mis notas 馃槉 馃檶馃徎:

Para calcular la mediana de los elementos que conforman un array se debe tener en cuanta que existir谩n dos posibilidades: la primera, en la que el array es par; y la segunda, en la que el array es impar. Debemos identificar en cu谩l de estos dos casos nos encontramos para calcular el resultado correctamente, esto lo logramos obteniendo el modulo de la longitud del array dividido entre 2 y retornando la negaci贸n de esta operaci贸n:

const array = [10, 20, 40, 60];

function esPar(array) {
	//Obtener el modulo de la longitud del array y retornar su negaci贸n:
	return !(array.length % 2);
}

Luego, debemos crear una funci贸n, y dentro de esta funci贸n agregamos una condicional que al evaluar en cu谩l de los dos casos se encuentra, realizar谩 el calculo correspondiente:

function calcularMediana (array) {
	const arrayPar = esPar(array);
	
	if (arrayPar) {
		//Calcular mediana par
	} else {
		//Calcular mediana impar
	}
}

Lo primero que hace la condicional para cada caso, es encontrar los elementos intermedios (en el caso de un array par) o el elemento intermedio (en caso de un array impar):

functioncalcularMediana (array) {
const arrayPar = esPar(array);

if(arrayPar) {
		//Obtener la posici贸n de los elementos intermedios:
const indexMitad1 = array[(array.length / 2) - 1];
const indexMitad2 = array[array.length / 2];
	}else {
		//Obtener la posici贸n del elemento intermedio:
const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);
	}
}

En el caso par, obteniendo los indices de los dos elementos intermedios e introduci茅ndolos dentro de un nuevo array (en este ejemplo: araryMitades), podremos pasar dicho array como argumento a la funci贸n que creamos en la clase anterior para obtener el promedio de un array y el resultado de esta operaci贸n lo asignamos a la variable que retornar谩 la condicional:

function calcularMediana (array) {
	const arrayPar = esPar(array);
	
	if(arrayPar) {
		const indexMitad1 = array[(array.length / 2) - 1];
		const indexMitad2 = array[array.length / 2];

		const arrayMitades = [indexMitad1, indexMitad2];

		//Calcular promedio de las dos mitades:
		const medianaArray = calcularPromedio(arrayMitades);

		return medianaArray;

	} else {
		const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);		
	}

}

//Funcion para calcular el promedio de un array:
function calcularPromedio(arrayItem) {
	function sumarElementos (valorAcumulado, nuevoValor) {
		return valorAcumulado + nuevoValor;
	}
	const sumaArray = arrayItem.reduce(sumarElementos);

	const promedio = sumaArray / arrayItem.length;
	return promedio;
}

En el caso impar, debemos obtener el elemento que se encuentra en la posici贸n intermedia y lo asignamos a una variable que ser谩 la que retornaremos.

function calcularMediana (array) {
	const arrayPar = esPar(array);
	
	if(arrayPar) {
		const indexMitad1 = array[(array.length / 2) - 1];
		const indexMitad2 = array[array.length / 2];

		const arrayMitades = [indexMitad1, indexMitad2];
		//Llamado a la funcion de calcularPromedio:
		const medianaArray = calcularPromedio(arrayMitades);

		//Retornar valor luego de calcular el promedio:
		return medianaArray;

	} else {
		const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);
		
		//Asignar el valor del elemento intermedio encontrado a una variable:
		const medianaImpar = array[posicionNumeroIntermedio];
		
		//Retornar elemento
		return medianaImpar;
	}

}

NOTA: antes de hacer el calculo de la mediana es importante contar con un array ordenado, es decir, que los elementos en su interior vayan de menor a mayor; de lo contrario, el calculo realizado estar谩 errado. Una soluci贸n podr铆a ser utilizar el m茅todo sort de los array para ordenar los elementos dentro del array.

Mi soluci贸n al reto de la clase pasada:

function listaEsPar(lista) {
  return (lista.length % 2) === 0;
}
//Calcular la Mediana de una lista impar y par
function calcularMediana(lista) {
  if(listaEsPar(lista)) {
    lista.sort((a,b) => a-b);
    let indice1 = (lista.length/2) - 1;
    let indice2 = indice1 + 1;
    return (lista[indice1] + lista[indice2]) / 2;
  } else {
    lista.sort((a,b) => a-b);
    const indice = Math.ceil(lista.length/2) - 1;
    return lista[indice];
  }
}

esta es mi solucion del reto de la clase pasada!!

Les comparto mi aporte de la clase 馃槉

function promedio (array) {
    const sumaArray = array.reduce((accumulator, element) => accumulator + element);

    const promedio = sumaArray / array.length;
    return promedio;
}

function calculateMedian(array) {

    array = sortArray(array);
    console.log(array);
    const arrayEsPar = arrayDivisibilidad(array);

    if (arrayEsPar) { // Mediana para  listas pares

        const indexMitadIzquierdaArray = (array.length / 2) - 1;
        const indexMitadDerechaArray = array.length / 2;

        const arrayMitades = [];
        arrayMitades.push(array[indexMitadIzquierdaArray]);
        arrayMitades.push(array[indexMitadDerechaArray]);
    
        const mediana = promedio(arrayMitades);
        return mediana;
    } else { // Mediana para listas impares
    
        const indexMitadArray = Math.floor(array.length / 2);
        const medianaArrayImpar = array[indexMitadArray];
        return medianaArrayImpar;
    }

}

// Un funci贸n es par o impar

function arrayDivisibilidad(array1) {
    if (array1.length % 2 === 0) {
        return true; //  Par
    } else {
        return false; // Impar
    }
}

function sortArray(array) {
    return array.sort();
}

Esta es la soluci贸n que pens茅 para obtener la mediana cuando la cantidad de elementos de un arreglo es par o cuando es impar

function averageWithReduce(array){

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

}

function median(array){
    array_sorted = array.sort(function(a, b){
        return a - b;
    })

    if(isEven(array_sorted.length)){
        return averageWithReduce( [ array_sorted[(array_sorted.length / 2) - 1], array_sorted[(array_sorted.length / 2)] ] );
    }
        
    else
        return array_sorted[Math.floor(( (array_sorted.length / 2)) + 1 ) - 1];
}

function isEven(number){
    return !(number % 2);
}