Calculando la mediana en una lista par

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…usando la función de parImpar()

Recordemos la definición de mediana

• 📕Definición: “Medida 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

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

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

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 “array.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);
}