No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Práctico de JavaScript

Curso Práctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Calculando la mediana en Javascript

16/24
Recursos

Aportes 551

Preguntas 48

Ordenar por:

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

El método .sort de los arrays nos permite ordenar listas de letras o números en JavaScript. Pero por defecto tiene algunos problemillas, como que el 1 millón queda ordenado antes que un 2 porque empieza por 1.

En la próxima clase vamos a utilizar el método .sort enviando como argumento una función anónima que le indique a JavaScript cómo ordenar nuestra lista de números (ya no solo por sus primeros números, sino por sus valores reales).

Pero antes te reto a que descubras cómo hacerlo artesanalmente y por tu cuenta. Esta documentación podrá ayudarte: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort.

Solucion

const numeros = [3, 23, 12];

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

// --> 3, 12, 23

Comparto mi solucion

Comparto mi solución:

function calcularMediana(lista){
    //En la variable listaOrdenada está la lista que se ingresó como
    //argumento pero ordenada ascendentemente. 
    const listaOrdenada = lista.sort(function(primerElemento, segundoElemento){
        return primerElemento - segundoElemento;
    });
    
    //Variable que almacena el índice que se encuentra a la mita de la lista.
    const mitadLista = parseInt(listaOrdenada.length / 2);

    //Variable que almacena el valor de la mediana.
    let mediana; 
    
    //Verificar si la lista tiene n elementos par o impar.
    if(esPar(listaOrdenada.length)){
        const elemento1 = listaOrdenada[mitadLista - 1];
        const elemento2 = listaOrdenada[mitadLista];
    
        const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);
        mediana = promedioElemento1y2;
        return mediana;
    }
    else{
        mediana = listaOrdenada[mitadLista];
        return mediana;
    }
}

function esPar(numerito){
    //Si es par...
    if(numerito % 2 === 0){
        return true;
    }
    //Si es impar...
    else{
        return false;
    }
}

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

    const promedio = sumaLista / lista.length;
    return promedio;
}

Mi aporte


.

  • 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>Mediana</title>
</head>
<body>
    <header>
        <h1>Calculo de la Mediana</h1>
    </header>
    <section>
        <form >
            <label for="inputMediana">Ingresa tus datos: </label>
            <input id="inputMediana" type="text" placeholder="Ej: 20, 10, 50" >
            <button type="button" onclick="calcularMediana()">Calcular la mediana</button>
            <p id="resultadoMediana"></p>
        </form>
        
    </section>
    <script src="./mediana.js"></script>
</body>
</html>

.

  • JS

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

function calcularMediana() {
// Se captura los datos del html y se guardan los valores dentro de una variable
  const entradaMediana = document.getElementById("inputMediana");
  const medianaValue = entradaMediana.value;
// Al ser un String los valores capturados, se procede a convertir el formato a Number 
  let arrayMediana = Array.from(medianaValue.split(","), Number);
//   Ordenamos los valores de la lista desordenada mediante el metodo sort() de menor a mayor
  const listaOrdenada = arrayMediana.sort((numMenor, numMayor) => numMenor - numMayor);
//   console.log(listaOrdenada);
// Hallamos la mitad de la cantidad de elemento de mi lista obtenida del HTML y lo redondeamos en caso sea decimal con la funcion parseInt()
  const mitadLista = parseInt(listaOrdenada.length / 2);
//   console.log(mitadLista);

// Creamos la funcion esPar para verificar si la lista es par o impar
  function esPar(numerito) {
    if (numerito % 2 === 0) {
      return true;
    } else {
      return false;
    }
  }

  let mediana;
// Si la lista es par procedemos hallar la mediana mediante esta forma de lo contrario seguiriamos con el else
  if (esPar(listaOrdenada.length)) {
    const elemento1 = listaOrdenada[mitadLista - 1];
    const elemento2 = listaOrdenada[mitadLista];
// Llamamos a la funcion calcularMediaAritmetica() con los elementos1 y elementos2 como parametros y lo guardamos como la variable mediana
    const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);
    mediana = promedioElemento1y2;
  } else {
    mediana = listaOrdenada[mitadLista];
  }
  //   Enviamos los resultados obtenidos a la pagina html para su visualizacion
  const mostrarResultado = document.getElementById("resultadoMediana");
  mostrarResultado.innerText = "La mediana es de: " + mediana;
}

Saludos ✌🏻


Mis notas

En el siguiente código utilizo el algoritmo de ordenamiento quicksort para ordenar los elementos de la lista, les dejo la implementación.

function ordenarLista(lista){
    if(lista.length < 1){
        return [];
    }else{
        let izquierda = [];
        let derecha = [];
        let pivote = lista[0];
    
        for(let i = 1; i < lista.length; i++){
            if(lista[i]<pivote){
                izquierda.push(lista[i]);
            }else{
                derecha.push(lista[i]);
    
            }
        }
        return [].concat(ordenarLista(izquierda), pivote, ordenarLista(derecha));
    }
}

Ahora con la función .sort() sería de la siguiente forma:

lista.sort((a,b)=>{return a-b})

El sentido de introducir como parámetro dentro de la función sort el resultado de la resta entre a y b, siendo estos dos elementos de la lista, es que si el valor retornado es menor 0, significa que a es menor que b, por lo que dejará esos dos números en su orden. Si el valor de resultante es mayor que 0 significa que b es menor que a por lo que intercambiará el orden de estos dos números dentro de la lista.

También les dejo mi código para calcular la mediana:

function calcularMediana(lista){
    
    if(lista.length!==0){
        let mediana = 0;
        let index = 0;
        if(lista.length%2 === 0){
            index = lista.length/2; 
            let valor1 = lista[index];
            let valor2 = lista[index-1];
            mediana = (valor1 + valor2)/2;
        }else{
            index = lista.length/2; 
            index = Math.floor(index);
            mediana = lista[index];
        }
        return mediana;
    }else{
        console.log("Tu lista es vacia, introduce una que contenga valores!")
    }
}

Mi solucion al reto

let lista = [
    100,
    200,
    500,
    600,
    700,
    800,
    900,
    1000,
    4000000
]

let lista2 = [100, 400, 300, 200, 800, 700, 600, 500]

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



const calcularMediana = (lista) => {

    let mitadLista = parseInt(lista.length / 2);

    let msj =  document.getElementById("resultado")

    let mediana;

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

    if (esPar(lista.length)) {
    
        let buffer1 = lista[(mitadLista - 1)];
        let buffer2 = lista[mitadLista]

        msj.innerText = "la mediana es: " + (buffer1 + buffer2) / 2;
    } else {
    
        mediana = lista[mitadLista];
        msj.innerText = "la mediana es: " + mediana;

    }

}

calcularMediana(ordenarLista(lista2))

si ya tienes el codigo de la clase hacer los retos sera pan comido.

PASO 1: crear funcion calcularMediana(lista) y agregar todas las funciones creadas en la clase dentro de esta, luego invocarla pasandole la lista como argumento

PASO 2: crear const listaOrdenada para ordenar la lista ya creada y aplicar el metodo .sort( )

const listaOrdenada = lista.sort((numAnterior, numSiguiente) => numMenor - numMayor)

Basicamente lo que hace el metodo .sort es recibir como parametros 2 numeros, y en la funcion que creamos como argumento del metodo nosotros definimos como queremos ordenar los datos

En este caso tamos el numero anterior y lo restamos con el numero siguiente. El metodo sort entra en juego ahi y cataloga que numero es mas grande y cual es mas pequeño

POR FAVOR SI ALGUIEN TIENE MEJOR INFORMACION SOBRE EL METODO SORT O PUEDE MEJORAR MI DEFINICION LO AGRADECERIA UN MONTON

PASO 3: cambias el argumento ‘lista’ de la funcion por la ‘listaOrdenada’

DEJO MI CODIGO POR SI ALGUIEN LE SIRVE

const lista = [100, 200, 600, 300, 200, 400]
const listaOrdenada = lista.sort((numMenor, numMayor)=> numMenor - numMayor)

console.log(listaOrdenada)
const calcularMediana = lista => {
    const mitadLista = parseInt(lista.length / 2)
    let mediana
    
    const promedio = (lista) => {
        const sumaLista = lista.reduce((acc , number) => acc + number,)
        let promedio =  sumaLista / lista.length
    
        document.querySelector('.mediana').textContent = promedio
    }
    
    const par = numero => {
        if(numero % 2 === 0){
            return true
        }
        else{
            return false
        }
    }
    
    if(par(lista.length)){
        const n1 = lista[mitadLista - 1] 
        const n2 = lista[mitadLista]  
    
        const n = promedio([n1, n2])
        mediana = n
    }
    else{
        mediana = lista[mitadLista]
        document.querySelector('.mediana').textContent = mediana
    }
}
calcularMediana(listaOrdenada)

Esta es mi solución

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

    const promedioLista = sumaLista / lista.length;

    return promedioLista;

}

function calcularMediana(lista) {

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

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

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

    let mediana;

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

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

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

    return mediana;
}
console.log(calcularMediana([200, 400, 500, 100, 900]));
Solución =  400

bueno intente ordenarla y me ha quedado asi:

const lista1 = [100, 200,500, 400000000,600,300,5,9];
lista1.sort(function(a,b){
return a-b;
});
console.log(lista1);

resultado:

lista1
(8) [5, 9, 100, 200, 300, 500, 600, 400000000]

Finalizado con el reto finalizar de ordenar la lista. Creo que fue un código demasiado “spaguetti” pero bueno, se hizo lo que se pudo 😦 ![](

Se esta forma se ordenan los números:

const lista1 = [
    100,
    50,
    10,
    400000000,
];

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

Os hago una pregunta y dejo mi solución.
La variable mediana se declara dentro de la función calcularMediana ¿verdad?

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

    const promedioLista = sumaLista / lista.length;

    return promedioLista;
}

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

}

function calcularMediana(lista) {
    lista.sort((a, b) => a - b);
    
    let mediana = 0;
    const mitadLista = parseInt(lista.length / 2);

    if (esPar(lista.length)){
        const elemento1 = lista1[mitadLista];  
        const elemento2 = lista1[mitadLista - 1]; 
      
        const promedioElemento1y2 = calcularMediaAritmetica([
            elemento1,
            elemento2
        ]);
          mediana = promedioElemento1y2;
      
      } else {
          mediana = lista[mitadLista];
      }
        
    return mediana

}

Asumiendo la logica binaria de 1 y 0 podriamos saber si un numero es par o impar de esta forma:

const isODD = (num)  => num % 2 ;

esto va a retornar un 1 si el numero es impar y un 0 si es par, entonces los podemos usar en un condicional:

if( isODD(lista.length) ){
	//Si es impar
} else {
	//Si es par
}

Recuerden que TRUE = 1 y FALSE = 0

Aquí mi solución!

// Media aritmética
function mediaAritmetica (array) {
    const sumArray = array.reduce((accumulator, currentValue) => accumulator + currentValue);
    return sumArray / array.length;
};

// Mediana
function mediana (array) {
    const sortedArray = array.sort((a, b) => a - b);
    const middleList = sortedArray.length / 2;
    
    if (array.length % 2 === 0) {
        const middleLeft = sortedArray[middleList - 1];
        const middleRight = sortedArray[middleList];
        return mediaAritmetica([middleLeft, middleRight]);
    } else {
        return sortedArray[Math.floor(middleList)];
    }
};

Comparto mi soluciond con sort:

<const list= [
   
    45,
    57,
    20000,
    34,
    14,
    4567,
    2456
]

list.sort((a,b)=> a-b)
function calcularMediaAritmetica(list){ 
 
  
  const  sumaLista1= list.reduce(
     function (valorAcumulado = 0 , nuevoElemento){
         return valorAcumulado + nuevoElemento 
     } 
  )
  
  const promedioLista1= sumaLista1/list.length 
  return promedioLista1
  }


const mitadLista= parseInt(list.length/2)

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

}

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

    const promedioElemento1y2=calcularMediaAritmetica([
        elemento1,
        elemento2
    ])

    mediana= promedioElemento1y2
    
    

 }else{
    

     mediana= list[mitadLista]
 }

 console.log(mediana)
> 

Buen dia, campeon… tengo la siguiente imagen, donde al precionar enter y si, no hay valor alguno introducido por el usuario de entrada se elmine el “NaN” de la lista de array, tambien en el resultado de promedio, ya que en JavaScript reconoce como un valor undefine, muy representativo en la segunda imagen.

mi pregunta es, con que metodo de array podria aplicar tal problema, descriptivo.

function ordenarLista(arr) {
    return arr.sort((a, b) => a - b)
}

function calcularMediana(arr) { 
    ordenarLista(arr);
    let mitadLista = parseInt(arr.length / 2);
    if (arr.length % 2 === 0) {
        return (arr[mitadLista] + arr[mitadLista - 1]) / 2
    } return arr[mitadLista]
}

<code> 

Me gustó la sintaxis del arrow function. Ahora empiezo a entender mejor con este ejemplo su aplicación.

let lista = [
    500,
    300,
    200,
    400,
    100,
    600,
];

lista.sort((a, b) =>  a - b);
// [100, 200, 300, 400, 500, 600]

Hice un función más “interactiva” no sé como decirle pero el usuario puede ingresar los valores del array y con la función .push() se agregan al array

<function addingArray(){
    const cantidad = prompt("Cuantos elementos deseas en el array?: " );
    var arrayNumeros = [];

    for (let i = 0; i < cantidad; i++){
        numero = Number(prompt("Ingresa numero: "))
        arrayNumeros.push(numero);
    }

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

    document.write(arrayNumeros + " ");
}

> 

La solución del reto me quedó así

Mi codigo finalizado, transformado a función y ordenando el array de entrada:

function calcularMediana(lista){

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

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

    let mediana;

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

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

        mediana = promedioElemento1y2;

    } else {
        mediana = listaOrdenada[mitadLista1]
    }

    return mediana;

}

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


function calcularMediaAritmetica(lista) { // se calcula el promedio por medio del encapsulamiento del codigo en una función
    const sumaLista = lista.reduce( // metodo reduce() perteneciente a los array que permite ir operando cada elemento
        function (valorAcumulado = 0, nuevoElemento){
            return valorAcumulado + nuevoElemento;
        }
    );
    const promedioLista = sumaLista / lista.length;
    return promedioLista;
}

Comparto mi solución de .sort sin usar .sort( con recursividad):

<code> 
let list1 = [100, 20, 102920, 3000, 1, 40404, 1000, 101011010];

let ordenarLista = (listaAOrdenar) => {
	let listaOrdenada = [];

	const encontrarMenor = (lista) => {
		let numeroMenor = lista[0];
		lista.map((element) =>
			element < numeroMenor
				? (numeroMenor = element)
				: (numeroMenor = numeroMenor)
		);
		return numeroMenor;
	};
	const agregarMenor = (listaMenor) => {
		if (listaMenor.length === 0) {
			return;
		}
		let menor = encontrarMenor(listaMenor);
		listaOrdenada.push(menor);
		listaMenor.splice(listaMenor.indexOf(menor), 1);
		agregarMenor(listaMenor);
	};
	agregarMenor(listaAOrdenar);
	return listaOrdenada;
};
console.log(ordenarLista(list1));

Comparto mi reto

Saludos!!!

Realice la solución de dos maneras, manualmente con el uso de dos estructuras iterativas for(Método conocido como la burbuja) y con el método sort propuesto en clase ambos para ordenar de menor a mayor los elementos del array. Comente las lineas de código que corresponden a la solución realizada con el método de la burbuja.

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

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

/* function ordenarMenorMayor(){
    for(let i = 0; i < lista.length ; i++){

        for(z = 0; z < lista.length ; z++){
            if(lista[z + 1] < lista[z]){
                let aux1 = lista[z + 1];
                let aux2 = lista[z];
                lista[z + 1] = aux2;
                lista[z] = aux1;
            }
        }
    }
} */

function esPar(cantElementos){
    if(cantElementos % 2 === 0){
        return true;
    }
    return false;
}
/* ordenarMenorMayor(); */

const mitadElementos = lista.length / 2;
let media =  0;

if(esPar(lista.length)){
    const element1 = lista[mitadElementos-1];
    const element2 = lista[mitadElementos];
    media = (element1 + element2) / 2;
}else{
    media = lista[parseInt(mitadElementos)]; 
}

console.log(media);

Ya saben amigos, primero fue la gallina que el huevo
les comparto este video de Sasha (La cocina del código) en donde explica el sort y lo que se debe tener en cuanta

let media;

const calculateMean = (list) => {
  let total = 0;
  total = list.reduce((accumulator = 0, currentValue) => {
    return (accumulator += currentValue);
  });

  const mean = total / list.length;
  return mean;
};

const calculateMedia = (list) => {
  const orderedList = list.sort((a, b) => a - b);
  const halfList = parseInt(orderedList.length / 2);

  if (evenNumber(orderedList.length)) {
    const elem1 = orderedList[halfList];
    const elem2 = orderedList[halfList - 1];
    media = calculateMean([elem1, elem2]);
  } else {
    media = orderedList[halfList];
  }
};

const evenNumber = (num) => {
  return num % 2 === 0 ? true : false;
};
// const lista = [
//     40000000,
//     100,
//     500,
//     200,
// ];

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

function siEsPas(numero){
    if (numero % 2 === 0){
        return true;
    }else{
        return false;
    }
}
    
function calcularMediana(lista) {
    //ordena el sort array y lo hace mas simple
    let listaOrtdenada = lista.sort(
        function(a,b){
            return a - b;
        }
    )
    const medianaLista = parseInt( listaOrtdenada.length/2);
        
    let mediana;
    if (siEsPas(listaOrtdenada.length)) {
        const elemento1 = listaOrtdenada[medianaLista-1];
        const elemento2 = listaOrtdenada[medianaLista];
    
        mediana = calcularMediaAritmetica([elemento1, elemento2]);
        return mediana;
    } else {
        mediana = listaOrtdenada[medianaLista];
        return mediana;
    }
}
// Promedio
const average = (arr) => {
  const sum = arr.reduce((a, b) => a + b, 0);
  const avg = sum / arr.length;

  return avg;
};

// Un numero es par?
const isEven = (number) => {
  if (number % 2 === 0) {
    return true;
  } else {
    return false;
  }
};

// Mediana
const median = (arr) => {
  const sortedArr = arr.sort((a, b) => a - b);
  const half = parseInt(sortedArr.length / 2);

  if (isEven(sortedArr.length)) {
    const firstElement = sortedArr[half];
    const secondElement = sortedArr[half - 1];
    return average([firstElement, secondElement]);
  } else {
    return sortedArr[half];
  }
};

const list = [100, 200, 300, 500];
const list2 = [200, 100, 40000000, 500];

console.log(average(list));
console.log(median(list2));


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

    const promedioLista = sumaLista / lista.length;
    console.log("El promedio de la lista es: " + promedioLista);
    return promedioLista;
    
}

function calcularMediana(lista){
    const listaOrdenada = lista.sort(); 
    const mitadLista = parseInt(listaOrdenada.length / 2);

    if (listaOrdenada.length % 2 === 0) {
        let medianaA = listaOrdenada[mitadLista];
        let medianaB = listaOrdenada[mitadLista-1];
        const mediana = calcularMediaAritmetica([medianaA,medianaB]);
        console.log("La mediana de la lista par es: " + mediana);
        return mediana;

    }else{
        mediana = listaOrdenada[mitadLista];
    }
    
    console.log("La mediana de la lista impar es: " + mediana);
    return mediana;
}

Aqui mi solucion un poco diferente

let lista1 = [500, 200, 100, 600, 2, 5, 400];

// Se obtiene el valor de la divición de la lista
let mitadLista = lista1.length / 2;

// Expresion que ordena la lista
lista1.sort((a, b) => {
  return a - b;
});

function calcMediana(lista) {
  // El metodo isInteger verifica si una variable es entera
  if (Number.isInteger(mitadLista)) {
    /* Si es un numero par necesitamos sacar la media de los 2 numeros del centro
     *  y dividir el resultado de la suma de ambos numeros entre 2 para obtener la mediana
     */
    mediana = (lista1[mitadLista] + lista1[mitadLista - 1]) / 2;
    console.log(mediana);
  } else {
    /* Si es un numero impar redondeamos este numero con el metodo floor
     * el cual coniverte un numero con decimal a entero quitandole los decimales.
     */
    mediana = Math.floor(mitadLista);
    console.log(lista1[mediana]);
  }
}

calcMediana(lista1);

antes de ver la clase y solo para practicar la lógica de programación hice un código que primero crea un array con los números ordenados y luego retorna la mediana.

function calcularMedianaAritmetica(lista){
    const length = lista.length
    let newList = []
    let lengthNewList = newList.length
    let number
    while (lengthNewList != length){
        for(let j = 0; j < lista.length; j++) {
            number = lista[0]
            for (let i= 1; i < lista.length; i++){
                if (lista[i] < number){
                    number = lista[i]
                } else {
                    continue
                }
            }
            newList.push(number)
            let index = lista.indexOf(number)
            if (index > -1) {
                lista.splice(index, 1);
            }
            lengthNewList = newList.length
        }
    }
    if (lengthNewList%2 == 0){
        const x1 = lengthNewList/2 - 1
        const x2 = x1 + 1
        return (newList[x1] + newList[x2])/2
    } else {
        const x = (lengthNewList/2) - 0.5
        return newList[x]
    }
} 

Comparto mi solución:

// MEDIANA
// La mediana es el valor que ocupa el lugar central de todos los datos
// cuando estos están ordenados de menor a mayor.
// 1) organiza todos los valores de menor a mayor
// 2) Encuentra el dato central del rango de datos.
// nota: si el numero de datos es par tomas los dos datos centrales y
// realiza esta operación: mediana = (dato1+dato2) / 2;

function calcularMediana (lista){

    //1)
    const linstaOrdenada = lista.sort(function(a, b){return a - b});
    //2)
    const mitadDeLALista = linstaOrdenada.length /2;
    

    if (linstaOrdenada.length % 2 === 0){
        //La base de datos tiene un punto central
        const valor1 = linstaOrdenada[mitadDeLALista-1];//(2
        const valor2 = linstaOrdenada[mitadDeLALista];
        let mediana = (valor1+valor2)/2;//(2

        return console.log(mediana);
    }else{
        //La base de datos no tiene mitad
        let mediana = linstaOrdenada[parseInt(mitadDeLALista)];//(2
        return console.log(mediana);
    }
}

Mi solucion

function calcularMediana(lista) {
  let arr = lista.sort((a,b) => a -b); 
  let mediana;

  if (arr.length % 2 == 0) {
    mediana = (arr[Math.floor(arr.length/2) - 1] + arr[Math.floor(arr.length/2)]) / 2;
  } else {
    mediana = arr[(arr.length-1)/2];
  }

  return mediana
}

Este es mi codigo para el calculo de la mediana

document
  .getElementById("btnAgregar")
  .addEventListener("click", agregarNumLista);

document
  .getElementById("btnCalcularPromedio")
  .addEventListener("click", calcularPromedio);
document
  .getElementById("btnCalcularModa")
  .addEventListener("click", calcularModa);
document
  .getElementById("btnCalcularMediana")
  .addEventListener("click", calcularMediana);

const lista = [100, 200, 300, 500];

let alerta = document.getElementById("alerta");
let listaAgregados = [];
let resultado = document.getElementById("resultado");
let resultadoAgregar = document.getElementById("listaAgregados");
let mensaje = document.getElementById("mensaje");

function ordenar(listaD) {
  let listaO = listaD;
  let paso = 0;
  for (let i = 0; i <= listaO.length; i++) {
    for (let j = 0; j < listaO.length; j++) {
      if (listaO[j] > listaO[j + 1]) {
        paso = listaO[j];
        listaO[j] = listaO[j + 1];
        listaO[j + 1] = paso;
      }
    }
  }
  return listaO;
}

function promedio(lista, mostrar) {
  let suma = 0;
  for (let i = 0; lista.length > i; i++) {
    suma = suma + parseInt(lista[i]);
  }
  suma = (suma / lista.length).toFixed(2);
  mostrar.innerHTML = "El promedio es: " + suma;
}

function mediana(lista, mostrar) {
  let posicion = 0;
  // let suma = lista.reduce(function (acumulado = 0, elemento) {
  // return acumulado + elemento;
  //});
  let listaO = ordenar(lista);
  let suma = listaO.length;
  if (suma % 2 == 0) {
    let listaF = [];
    let mitad = listaO.length / 2;
    listaF.push(listaO[mitad]);
    listaF.push(listaO[mitad - 1]);
    promedio(listaF, mostrar);
  } else {
    posicion = Math.floor(listaO.length / 2);
    mostrar.innerHTML = "La mediana es de: " + listaO[posicion];
  }
}

function moda(lista, mostrar) {
  console.log("Moda");
}

function agregarNumLista() {
  let limpiar = document.getElementById("numAgregar");
  let num = parseInt(limpiar.value);
  if (num > 0) {
    mensaje.innerText = "Lista de numeros para sacar promedios";
    listaAgregados.push(parseInt(num));
    num = "<li>" + num + "</li>";
    resultadoAgregar.innerHTML = resultadoAgregar.innerHTML + num;
    alerta.innerHTML = "";
    limpiar.value = "";
  } else {
    alerta.innerHTML = "Error<br>* El numero no puede ser menor o igual a 0";
  }
}

function calcularPromedio() {
  if (listaAgregados.length != 0) {
    promedio(listaAgregados, resultado);
    listaAgregados = [];
    resultadoAgregar.innerHTML = "";
    mensaje.innerText = "";
    alerta.innerHTML = "";
  } else {
    alerta.innerHTML =
      "Error<br>* Debe de contener al menos un numero para calcular el promedio";
  }
}

function calcularModa() {
  if (listaAgregados.length != 0) {
    moda(listaAgregados, resultado);
    listaAgregados = [];
    resultadoAgregar.innerHTML = "";
    mensaje.innerText = "";
    alerta.innerHTML = "";
  } else {
    alerta.innerHTML =
      "Error<br>* Debe de contener al menos un numero para calcular la moda";
  }
}

function calcularMediana() {
  if (listaAgregados.length != 0) {
    mediana(listaAgregados, resultado);
    listaAgregados = [];
    resultadoAgregar.innerHTML = "";
    mensaje.innerText = "";
    alerta.innerHTML = "";
  } else {
    alerta.innerHTML =
      "Error<br>* Debe de contener al menos un numero para calcular la mediana";
  }
}

Excelente clase teacher Juan!

Les comparto mi código que llevo hasta este momento.
Reutilice la función de la clase pasada que hice.

Código

const valores = [1, 4, 7, 3, 12, 23, 12, 3, 20, 16, 6, 8, 5, 8, 4]; //54

//Calculo de la Media
const calcularMedia = arreglo =>{
    return (arreglo.reduce((suma, elemento)=>{
        return suma+=elemento
    })) / arreglo.length;
};

console.log(calcularMedia(valores));

//Saber si el tamaño de un arreglo es par
const esPar = arreglo =>{
    if(arreglo.length % 2 === 0){
        return true;
    }else{
        return false;
    }
}

//Ordenando un Arreglo
const ordenarArreglo = arreglo =>{
    return arreglo.sort((a,b)=>{
        return a - b;
    });
};

//Calculo de la Mediana
const calcularMediana = arreglo =>{
    let mitad = parseInt(arreglo.length/2);
    if(esPar(arreglo)){
        let actual = arreglo[mitad];
        let anterior = arreglo[mitad-1];
        //console.log(`El actual es: ${actual}, anterior es: ${anterior}`);
        console.log(`La mediana es: ${calcularMedia([actual,anterior])}`);

    }else{
        let mitad = parseInt(arreglo.length / 2);
        //console.log(`La mitad es: ${mitad}`);
        console.log(`La mediana es: ${arreglo[mitad]}`);
    }
}


console.log(`El arreglo ordenado es: ${ordenarArreglo(valores)}`);

//console.log(`Es par: ${esPar(valores)}, tiene ${valores.length}`)

calcularMediana(valores);

Resultado:

Reto completado de ordenar un Arreglo de números

Código

const ordenarArreglo = arreglo =>{
    return arreglo.sort((a,b)=>{
        return a - b;
    });
};

console.log(`El arreglo ordenado es: ${ordenarArreglo(valores)}`);

Resultado

El arreglo ordenado es: 1,3,4,4,6,7,8,12

Documentación de Ayuda:

https://www.w3schools.com/js/js_array_sort.asp

Aquí mi solución

// Ordena array de menor a mayor (Aún no lo entiendo)
function ordenarMenorMayor(array) {
  arrayOrdenado = array.sort((a, b) => a - b);
  return arrayOrdenado;
}

// Halla la mediana de un array
function mediana(array) {
  let longitud = array.length;
  let posicion = 0; // Uno menos de lo que en realidad es (Porque el indice empieza en 0)
  let res = 0;
  if (longitud % 2 === 0) {
    numCentroIzquierda = longitud / 2 - 1;
    numCentroDerecha = longitud / 2;
    posicion = (numCentroIzquierda + numCentroDerecha) / 2;
    res = (array[numCentroIzquierda] + array[numCentroDerecha]) / 2;
  } else {
    posicion = longitud / 2 - 0.5;
    res = array[posicion];
  }
  return res;
}

Así ordene mis números. 😄

function isEven(number) {
    if(number % 2 === 0) {
        return true;
    } else {
        return false;
    }
}

function calculateMedian(list) {

    const orderedList = list.sort((num1, num2) => {return num1 - num2});
    const halfList = parseInt(list.length / 2);
    let median;

    if (isEven(list.length)) {
        const element1 = list[halfList];
        const element2 = list[halfList - 1];

        const averageElement1And2 = calculateAverage([
            element1,
            element2
        ]);

        median = averageElement1And2;
    } else {
        median = list[halfList];
    }

    return median;
}

Solución usando insertion sort.

function ordernarLista(lista) {
	for (let i=1; i < lista.length; i++) {
		temporal = lista[i];
		posicion = i;

		while (posicion >= 0 && temporal < lista[posicion]) {
			lista[posicion+1] = lista[posicion];
			posicion--;
		}

		lista[posicion+1] = temporal;
	}
}

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

	const promedioLista = sumaLista / lista.length;
	return promedioLista;
} 

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

function calcularMediana(lista) {
	ordernarLista(lista)

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

	let mediana;

	if (esPar(lista.length)) {
		const elemento1 = lista[mitadLista - 1];
		const elemento2 = lista[mitadLista];
		const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);

		mediana = promedioElemento1y2;

	} else {
		mediana = lista[mitadLista];
	}

	return mediana;
}

Mi solucion con Sort.

const lista1 = [
    1500,
    300,
    800,
    10,
    5,
    100,
    200,
    500,
    400000000,
  ];

  function calcularMediana(lista) {
    lista.sort(function(a, b) {
        return a - b;
      });
    const mitadLista = parseInt(lista.length / 2);
    if (esPar(lista.length)) {
        const elemento1 = lista[mitadLista - 1];
        const elemento2 = lista[mitadLista];
      
        const promedioElemento1y2 = calcularMediaAritmetica([
          elemento1,
          elemento2,
        ]);
        
        mediana = promedioElemento1y2;
      } else {
        mediana = lista[mitadLista];
      }
      return mediana;
  }
/**
 * Función encargada de calcular el la media aritmética
 * @param {*} p_list,  recibe un lista de numeros enteros
 * @returns  valueAverage , promedio
 */
function arithmeticAverage(p_list) {
	let valueAcum = 0;
	let valueAverage = 0;

	// Realiza la sumatorias de valores
	valueAcum = p_list.reduce(function (valueAcumulate = 0, valueCurrent) {
		return valueAcumulate + valueCurrent;
	});

	// realiza el calculo de la media aritmética
	valueAverage = valueAcum / p_list.length;
	return valueAverage;
}

/**
 *función que verfica sí  un numero es par o no
 * @param {*} p_number, un valor entero
 * @returns true: si  es par, false: si no es par
 */
function isEven(p_number) {
	let responseIsEven;
	if (p_number % 2 === 0) {
		responseIsEven = true;
	} else {
		responseIsEven = false;
	}
	console.log({ responseIsEven, p_number });
	return responseIsEven;
}

/**
 * Ordena una lista de números enteros ascendentemente
 * @param {*} p_list lista de números enteros
 */
function orderList(p_list) {
	// ordena lista de salarios
	p_list.sort(function (a, b) {
		return a - b;
	});
	return p_list;
}

/**
 *Calcular la mediana
 * @param {*} p_list:
 * @returns resultMedian: Mediana 
 */
function arithmeticMedian(p_list) {
	let valueA = 0;
	let valueB = 0;
	let resultMedian = 0;
	// Se obtiene  la mitad de la lista
	const midList = parseInt(p_list.length / 2);
	// Se Ordena la lista
	p_list = orderList(p_list);

	if (isEven(p_list.length)) {
		// si el tamaño de la lista es par, entonces:
		// se toma el valor de la mitad de la lista
		// y un valor anterior para sacar el promedio
		valueA = p_list[midList - 1];
		valueB = p_list[midList];
		resultMedian = arithmeticAverage([valueA, valueB]);
	} else {
		// Si lista de elementos es impar:
		// se retorna el elemento de la mitad de la lista
		resultMedian = p_list[midList];
	}

	return resultMedian;
}

const inputResultListSalarys = document.getElementById(
	'inputResultListSalarys'
);
const inputResultMedianSalary = document.getElementById(
	'inputResultMedianSalary'
);



const SALARY_LIST = [100, 200, 500, 700];

let mediana = arithmeticMedian(SALARY_LIST);

inputResultListSalarys.innerText = `${SALARY_LIST}`;
inputResultMedianSalary.innerText = `${mediana}`;

Ordenar número con array.sort()

Ordenar ascendentemente

const numbers = [3, 23, 12];

numbers.sort(function(a, b){return a - b}); // --> 3, 12, 23

Ordenar descendentemente

const numbers = [3, 23, 12];

numbers.sort(function(a, b){return b - a}); // --> 23, 12, 3

Referencia para ordenar lista de números con sort

Solución reto, ordenar números =>

const lista= [10, 1000, 50,60];

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

¡Esta es la función que yo hice para calcular la mediana!

const mediana = (lista) =>{
    if(lista.length % 2 == 0){
        let puntosMedios = [lista[(lista.length/2)-1],lista[(lista.length/2)]]
        return (puntosMedios[0] + puntosMedios[1])/2

    }else{
        let puntoMedio = lista[Math.trunc(lista.length/2)]
        return puntoMedio
    }
}

Artículo de sort
Video de sort
Mi solución al reto:

const lista = [100, 900, 200, 400, 500];
function calcularMediana(array){
    let lista_en_orden = array.sort((a, b) => a - b);
    console.log(lista_en_orden)
    let mitad_lista = parseInt(lista_en_orden.length / 2);
    let mediana; 

    if(lista_en_orden.length % 2 == 0){
        let elemento = lista_en_orden[mitad_lista];
        let elemento2 = lista_en_orden[mitad_lista - 1];
        mediana = calcularMedia([elemento, elemento2]);
    }
    else {
        mediana = lista_en_orden[mitad_lista];
    }
    console.log(mediana)    
}
calcularMediana(lista)
const lista1 = [
    100,
    200,
    500,
    400,
    600,
    800,
];

//ordenar la lista de forma ascendente
lista1.sort((a,b)=>a-b);

/*
0: 100
1: 200
2: 400
3: 500
4: 600
5: 800*/
// Mediana
function calcularMediana(lista) {
  let listaOrdenada = lista.sort(function (a, b) {
    return a - b;
  });
  console.log(listaOrdenada);
  console.log("segundo print");
  let mediana;
  const mitadLista = parseInt(listaOrdenada.length / 2);

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

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

    const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);
    mediana = promedioElemento1y2;
    return mediana;
  } else {
    mediana = listaOrdenada[mitadLista];
    return mediana;
  }
}

Esta fue mi solucion:
const tamanoArray = parseInt(prompt(“A que cantidad de numeros quieres calcularle la mediana”));
console.log(tamanoArray);
var lista1 = [];
console.log(lista1);

function crearListaArray(numeroPrueba) {
if (true) {
while (lista1.length < tamanoArray) {
numeroPrueba = parseInt(prompt(“escribe un numero prueba”));
lista1.push(numeroPrueba);
console.log(lista1);
}
} else {
alert(“por favor escribe todos los numeros necesarios para el calculo”);
};

};
crearListaArray();

var mostarArray = lista1.sort(function (a, b) { return a - b });
console.log(mostarArray);
var mitadLista1 = parseInt(mostarArray.length / 2);
console.log(mitadLista1);

let mediana;

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

if (esPar(mostarArray.length)) {
const elemento1 = mostarArray[mitadLista1 - 1];
const elemento2 = mostarArray[mitadLista1];
const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);
mediana = promedioElemento1y2;
} else {
mediana = mostarArray[mitadLista1];
}

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

Mi código quedo algo así…,

function esPar(num){
    if(num % 2 === 0){
    return true
    } else{
        return false
    
    }
    }
function calcularMediana(lista) {
    const listaOrdenada = lista.sort((a,b) => a - b);
    const mitadLista1 = parseInt(listaOrdenada.length / 2);

  let mediana;
    if(esPar(listaOrdenada.length)){
        const elemento1 = listaOrdenada[mitadLista1 - 1]
        const elemento2 =listaOrdenada[mitadLista1]
        const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2])
        mediana = promedioElemento1y2
        return mediana
    } else{
        mediana = listaOrdenada[mitadLista1]
        return mediana
    }
}

Mi Solución:

const lista1 = [
    100,
    200,
    500,
    400,
    600,
    800,
];
const mitadLista1 = Math.trunc(lista1.length / 2);
let mediana;

//Determinar si la longitud de la lista es par o impar

function esPar(numero){
    return (numero % 2 === 0)
}

if (esPar(lista1.length)){
    mediana = (lista1[mitadLista1] + lista1[mitadLista1-1])/2
}else{
    mediana = lista1[mitadLista1]
}

Para poder ordenar el método sort la documentación nos dice que es necesario una función de comparación la cual para comparar números en lugar de strings se debe de crear la función de comparación que pueda simplemente restar b de a. Siendo a y b dos elementos comparados.

function calcularMediaAritmetica(lista
    ){
      const sumaLista=lista.reduce(
          function(valorAcumulado=0,nuevoElemento){
            return valorAcumulado + nuevoElemento;
            }
        );
      const promedioLista=sumaLista/lista.length;
      return promedioLista;
    }
function mediana(lista){
const listaOrdenada=lista.sort(function(a,b){return a - b;});

const mitadLista1 = parseInt( listaOrdenada.length / 2);
function esPar(numerito) {
    if (numerito % 2 === 0) {
        return true;
    } else {
        return false;
    }
}
let mediana;

if (esPar(listaOrdenada.length)) {
const elemento1=listaOrdenada[mitadLista1 -1];
const elemento2=listaOrdenada[mitadLista1];
 const promedioE1E2= calcularMediaAritmetica([elemento1,elemento2,]);
 mediana=promedioE1E2;
 return mediana;
} else {
mediana=listaOrdenada[mitadLista1];
return mediana;
}}

Ordenando los elementos de mi lista y calculando la mediana.

function calcularMediana(lista) {

  var lista = lista.sort(function(a,b){return a - b;});
  console.log(lista);

  let mediana;

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

  function esPar(num) {
    if(num % 2 === 0){
      return true;
    } else {
      return false;
    }
  }
  
  if(esPar(lista.length)) {
    const elemento1 = lista[mitadLista];
    const elemento2 = lista[mitadLista - 1];
    
    const promedioElementos = calcularMedia([
      elemento1,
      elemento2,
    ]);

    mediana = promedioElementos;
  } else {
    mediana = lista[mitadLista];
  };
  
  return mediana;
};

Consola.

calcularMediana([50, 15, 5000, 56, 22, 14]);
(6) [14, 15, 22, 50, 56, 5000]
36

Asi quedo mi codigo:

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


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



function calcularMediana(lista){
let mediana;

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

const listaOrdenada=lista.sort();
console.log(listaOrdenada);

if(esPar(lista.length)){
//necesitamos dos elementos
// el promedio
// esto sera la mediana
const elemento1=lista[mitadLista -1];//la posicion 1 , ojo se le resta 1 para que tome el elemento anterior
const elemento2=lista[mitadLista];//la posicion 2

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

mediana=promedio1y2;

} else{
// el num es impar

mediana=lista[mitadLista];
//posicion mitadLista1 dentro de lista1
//es la mediana
}



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

function calcularmediana(lista1) {
    
    
    const lista1ordenada = lista1.sort((a, b) => a - b);
    
    const mitadLista1 = parseInt(lista1ordenada.length / 2);
    
    function esPar(numero) {
        if (numero % 2 === 0) {
            return true;
        } else {
            return false;
        }
    }
    
    let mediana;
    
    if (esPar(lista1ordenada.length)) {
        const elemento1 = lista1ordenada[mitadLista1 - 1];
        const elemento2 = lista1ordenada[mitadLista1];
        const promedioElemento1y2 = calcularPromedio([
            elemento1,
            elemento2
        ]);
        
        mediana = promedioElemento1y2;
        
    } else {
        mediana = lista1ordenada[mitadLista1];
    }

    return mediana;
}

Aquí les dejo mi solución al reto:

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

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

const ordenarLista = (lista) =>
  lista.sort(
    (primerElemento, segundoElemento) => primerElemento - segundoElemento
  );

function calcularMediana(listaDesordenada) {
  const listaOrdenada = ordenarLista(listaDesordenada);
  const mitadLista = parseInt(listaOrdenada.length / 2);
  let mediana;
  if (esPar(listaOrdenada.length)) {
    const elemento1 = listaOrdenada[mitadLista - 1];
    const elemento2 = listaOrdenada[mitadLista];
    const promedio1y2 = calcularMediaAritmetica([elemento1, elemento2]);
    mediana = promedio1y2;
  } else {
    mediana = listaOrdenada[mitadLista];
  }
  return mediana;
}

console.info(calcularMediana([100, 700, 200, 500, 400, 133, 400000000]));

hola chicos esta es mi solución :

function calcularLaMediana(lista)
{
    lista = lista.sort((a,b)=> a-b);
    const mitadLista = lista.length/2;



    let mediana;
    if(esPar(lista.length))
    {
        const posicionDerecha = lista[mitadLista];
        const posicionIzquierda = lista[mitadLista-1];
        mediana = CalcularMediaaritmetica([posicionIzquierda,posicionDerecha]);
    }
    else
    {
        mediana = lista[parseInt(mitadLista)];
    }

    return mediana;
}

Aquí mi solución.

function encontrarMediana (array) { // Recibe un array
    const lista = array.sort(); // Ordena el array
    if (lista.length % 2 == 0) { // Condicional que define ruta en caso que el lenght del array sea par
        const medianaIndex = (lista.length / 2);
        const medianaIndex2 = (lista.length / 2) -1;
        const mediana = (lista[medianaIndex] + lista[medianaIndex2]) / 2; // Operación para sumar los valores de en medio
        return mediana;
        
    } else { 
        const medianaIndex = ((lista.length - 1) / 2);
        const mediana = lista[medianaIndex]; // Regresa el valor que se encuentra en el array en caso que el array sea impar.
        return mediana;
        
    }


}

Tal cual como lo dice @juanDC, el método ordena de manera alfabética sin importar el valor entero. Es por ello que al metodo sort() puede recibir como función para ordenar de acuerdo al valor entero.
Aquí aporto mi ejemplo, para que se ayuden.

function calcularMediaAritmetica(lista) {
  let inicial = 0;
  for (const i of lista) {
    inicial = inicial + i;
  }
  let promedio = inicial / lista.length;
  return promedio;
}

function calcularMediana(lista) {
  let order = lista.sort(function (a, b) {
    return a - b;
  });
  console.log(order);
  let mitad = parseInt(order.length / 2);
  let veri = mitad % 2 === 0;
  let mediana;

  if (veri == true) {
    let el1 = order[mitad - 1];
    let el2 = order[mitad];
    let promedioPar = parseInt(calcularMediaAritmetica([el1, el2]));
    mediana = promedioPar;
    console.log(mediana);
  } else {
    mediana = order[mitad];
    console.log(mediana);
  }
}
calcularMediana([100, 800, 500, 957, 200, 4000]);

Aquí mi solución.

function calcular_mediana(lista_datos){
    ordered_list = lista_datos.sort(function compare(first, next){return first - next})
    console.log(ordered_list)

    if(ordered_list.length % 2 === 0){
        valor_central = lista_datos.length/2
        posicion_central_1 = parseInt(valor_central - 1)
        posicion_central_2 = parseInt(valor_central)
        mediana = calcular_promedio([ordered_list[posicion_central_1], ordered_list[posicion_central_2]])
        return mediana
    }
    else {
        const posicion_central = parseInt(lista_datos.length/2)
        mediana = ordered_list[posicion_central]
        return mediana
    }
}

La función calcular_promedio() la reutilicé de la clase anterior.

Use el algoritmo de bubble sort, que lo aprendí en la uni, se me hizo interesante aplicarlo aquí. Lo metí dentro de una función que luego mande llamar en el calculo de la mediana y el promedio.

–Más info–
https://www.geeksforgeeks.org/bubble-sort-algorithms-by-using-javascript/

Con metodo .sort():

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

Con función bubbleSort:

function bubbleSort (lista) {
	const len = lista.length;
	for (let i = 0; i < len; i++) {		
		for(let j=0; j < len - i; j++) {
			if(lista[j] > lista[j+1]){				
				const tmp = lista[j];
				lista[j] = lista[j+1];
				lista[j + 1] = tmp;
			}
		}
	}

	return lista;
}

Por favor, lean la documentación que pasó Juan, tiene todo lo necesario para entender perfectamente el método sort.
Aquí va mi código:

// This is a sample array
const sampleList = [
  200,
  300,
  100,
  400000000,
  500,
];

// Funcion ya creada en clase anterior
// para calcular promedio
function calcularMediaAritmetica(lista) {
  const sumaLista = lista.reduce(
    function (valorAcumulado = 0, nuevoElemento) {
      return valorAcumulado + nuevoElemento;
    }
  );
  const promedioLista = sumaLista / lista.length;
  return promedioLista;
}

// Función que retorna booleano de acuerdo al
// largo de una lista que se pase como argumento.
function esPar(numerito) {
  if (numerito % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

// Código de calcular mediana pasado a función
function calcularMediana(lista) {
  // Arrow function utilizando método sort
  // personalizada para evitar error que tiene por default.
  // TODO ESTA EXPLICADO EN DOCUMENTACIÓN
  // ADJUNTA A LA CLASE.
  const sortedLista = lista.sort((a, b) => a - b)

  console.log(`Sorted list on function: ${sortedLista}`)

  const listaLenght = parseInt(sortedLista.length / 2);

  let mediana;

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

    const promedioElemento1y2 = calcularMediaAritmetica([
      elemento1,
      elemento2,
    ]);
    
    mediana = promedioElemento1y2;
  } else {
    mediana = sortedLista[listaLenght];
  }
  
  return mediana;
}

calcularMediana(sampleList);

solución con los elementos ya ordenados.

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

function calcularMediana(lista1) {

    const lista = lista1.sort((a, b) => a - b);
    console.log(lista);
    const mitadLista1 = parseInt(lista.length / 2);
    let mediana;
    console.log(mediana);
    if (esPar(lista.length)) {
        const elemento1 = lista[mitadLista1 - 1];
        const elemento2 = lista[mitadLista1];

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

        mediana = promedioElemento1y2;
        console.log(mediana);
    } else {
        mediana = lista1[mitadLista1];
        console.log(mediana);
    }
}

Aquí dejo mi ejercicio

// * MEDIANA
// Clase anterior función media aritmética
function calcularMediaAritmetica(lista) {
    const sumaLista = lista.reduce((valorAcumulado=0, nuevoElemento) => valorAcumulado + nuevoElemento);
    const promedioLista = sumaLista / lista.length;
    return promedioLista;
}

// Función que válida un número par (con operador ternario)
function esPar(numero) {
    return numero % 2 === 0 ? true : false;
}

// Reto ordenar elementos
function ordena(lista){
    lista.sort((a,b)=>a-b);
    return lista; 
}

// Reto Función mediana 
function medianaLista(listaUsr){
    const ordenado = ordena(listaUsr);
    const mitadLista = parseInt(ordenado.length/2);
    let mediana;
    if (esPar(ordenado.length)) {
        const elemento1 = ordenado[mitadLista - 1];
        const elemento2 = ordenado[mitadLista];
        const promedio = calcularMediaAritmetica([elemento1,elemento2]);
        mediana = promedio;
    } else {
        mediana = ordenado[mitadLista];
    }
    return mediana;
}

function calculateMedian(list) {
  const orderedList = list.sort(function (elementOne, elementTwo) {
    return elementOne - elementTwo;
  });

  const middleList = parseInt(orderedList.length / 2);

  if (isPair(orderedList.length)) {
    const elementOne = orderedList[middleList - 1];
    const elementTwo = orderedList[middleList];

    const averageElementsOneTwo = calculateAverage([elementOne, elementTwo]);

    median = averageElementsOneTwo;
  } else {
    median = orderedList[middleList];
  }

  return median;
}

let median;
function isPair(number) {
  if (number % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

function calculateAverage(list) {
  const sumList = list.reduce(function (acumulatedValue = 0, newValue) {
    return acumulatedValue + newValue;
  });
  const averageList = sumList / list.length;
  return averageList;
}

Lo hice con sort pero implementé hecho a “mano”. Reto cumplido!

PD: Me ayudó mucho haber tomado el curso de Estructura de Datos

function ordenando(lista) {
    for(let i = lista.length; i > 0; i--) {
        if(lista[i] < lista[i - 1]) {
            const first = lista[i - 1];
            const holding = lista[i];
            lista[i - 1] = holding;
            lista[i] = first;
        } 
    }
    return lista;
}

function medianaCal(lista) {

  /* lista.sort(function(a, b) {
       return a - b;
   })
   console.log(lista)*/
    let mediana;
   const listaOrdenada = ordenando(lista)
    const mitadLista1 = parseInt(listaOrdenada.length / 2);

    if (esPar(listaOrdenada.length)) {
        const elemento1 = listaOrdenada[mitadLista1 -1];
        const elemento2 = listaOrdenada[mitadLista1];
    
        const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2])
        mediana = promedioElemento1y2;
    } else {
        mediana = listaOrdenada[mitadLista1];
    }

    return mediana;
}

Reto de sort y función calcular mediana

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

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

  let mediana;

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

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

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

  return mediana;
}

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

Yo lo hize asi, estoy abierta a correcciones:

function calcularMediana() {

	let str = input.value
	let arrayInput = str.split(" ")
	let medianaPar = 0
	let medianaResults = 0
	if (arrayInput.length % 2 == 0) {
	        medianaPar = (arrayInput.length / 2)
	        medianaResults = (medianaPar + (medianaPar + 1)) / 2
	        return results.innerText = `La mediana es igual a: ${medianaResults}`


	} else {
	        medianaResults = Math.ceil(arrayInput.length / 2)
	        return results.innerText = `La mediana es igual a: ${medianaResults}`
	}
}


Aquí un video explica el método sort() y como ordenar el array de números correctamente 😄

Mi humilde solucion

let list = [
    200,
    500,
    1200,
    900,
    800
];

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

function par(list){
    
    var num = list.length;

        if (num % 2 === 0){

            let midNumber = num / 2;

            var result1 = list[midNumber];
            let result2 = list[midNumber - 1] ;
            let resultAvg = (result1 + result2) / 2;

            console.log(resultAvg);
        }
        else {

            let result = Math.floor(num / 2);

            console.log(list[result]);
        }

}

Para que el usuario cree la lista hice esta función:

const lista1 = [];
function crearArray(valor) {
    lista1.push(valor);
}

Para ordenar de manera ascendente:

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

SORT! Les comparto un video explicativo, asi deberia sr una clase simple directa sin vueltas menos palabras que confunden. Impecable
https://youtu.be/i9v4dfxwlbQ

Esta es mi solución usando math.floor que siempre redondea hacia abajo, y siento que da más control. La función de sort la saqué de la documentación, sólo que la convertí en arrow function para que quedara en una sola linea más legible. Saludos

const lista1 = [4, 2, 5, 1, 3, 31, 54, 65, 158, 458, 787, 5, 65, 4, 9, 854];

const esPar = (numero) => {
  return numero % 2 === 0 ? true : false;
};

const mitadDeNumeroEnEntero = (numero) => Math.floor(numero / 2);

const calcularPromedio = (valores) => {
  const sumaValores = valores.reduce((valorAcumulado = 0, nuevoElemento) => {
    return (valorAcumulado = valorAcumulado + nuevoElemento);
  });
  return sumaValores / valores.length;
};

const mediana = (lista) => {
  lista = lista.sort((a, b) => a - b);
  if (esPar(lista.length)) {
    return calcularPromedio([lista[mitadDeNumeroEnEntero(lista.length) - 1], lista[mitadDeNumeroEnEntero(lista.length)]]);
  } else {
    return lista[mitadDeNumeroEnEntero(lista.length)];
  }
};

mediana(lista1);

Paso mi pen del ejercicio
https://codepen.io/nel193/pen/MWmodKK

function median (list) {
    // To sort an array of numbers
    list.sort(function(a, b) {return a-b});
    const middleList = parseInt(list.length / 2);
    if ((list.length % 2) === 0) {
        const firstElement = list[middleList - 1];
        const secondElement = list[middleList];
        const medianValue = (firstElement + secondElement) / 2;
        return medianValue;
    } else {
        const medianValue = list[middleList];
        return medianValue;
    }
}

De esta manera pude resolverlo, que tal?

/const listaExample = [10, 20, 30, 200];
const listUser = [];
let mediana;
let mitadlista;


//saber si la mitad es par o no
const esPar = (numero) => {

if (numero % 2 === 0){
    return true;
}else{
    return false;
}
};
//calcular promedio
const calcularPromedioDeMediana = (elemento1, elemento2) => {
  return (elemento1 + elemento2) / 2;
}
//calcular mediana
const calcularMediana = (lista)=> {
    if (esPar(listUser.length)){
        const posicion1 = lista[mitadlista - 1];
        const posicion2 = lista[mitadlista];

        mediana = calcularPromedioDeMediana(posicion1, posicion2);
        return mediana;

    }else if(esPar(listUser.length) && mitadlista === 1){
        mediana = lista[mitadlista + 1]
    }else{
        mediana = lista[mitadlista];
        return mediana;
    }
}

// enlistar los numeros que agregue el usuario
const enlistarNumeroOrdenados = (numeroUser) => {
    //agregar el numero a la lista
    listUser.push(Number(numeroUser));
    //ordenar la lista
    listUser.sort(function (a,b) {return a-b})
    //saber la mitad de la lista
    mitadlista = parseInt(listUser.length / 2);

}

//agregar los numeros a la lista
const agregar = () => {
    let numeroAdd = document.getElementById("inputMediana");
    let numeroAddValue = numeroAdd.value;

    enlistarNumeroOrdenados(numeroAddValue);
}

// calcular la mediana con la lista del usuario.
const calcular = () => {
    let resultado = calcularMediana(listUser);

    let para = document.getElementById("resultadoP");
    para.textContent = `La mediana es ${resultado}`; 

}

Yo trabaje con dos funciones: una para ordenar y otra para calcular la mediana. Poniendo la primera dentro de la segunda. Me quedo asi.


const listaPx = [
    200,
    300,
    500,
    2000,
    11,
    555,
    100000,
    7000000,
    3000,
    93290482398872673,
];


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

function calcMediana(listaDesordenada){

    var lista = ordenarLista(listaDesordenada)

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

    let mitadLista = Math.floor(lista.length / 2);

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

        mitadLista = (lista.length / 2) - 1;
    
        let mitadListaPar = Math.floor(lista.length / 2 );

        let promedio = (listaOrdenada[mitadLista] + listaOrdenada[mitadListaPar]) / 2

        return `La mediana de la lista es ${parseInt(promedio)}`;
    }

    return `La mediana de la lista es ${lista[mitadLista]} `;
}


console.log(calcMediana(listaPx));

console.log(listaPx.sort(function(a,b){return a - b;}))

Esta es mi solución al reto:

const lista1 = [
    800000,
    200,
    500,
    300,
];

const CalcularMediana = (lista) => {

    let listaOrdenada = lista.sort();

    if (listaOrdenada.length % 2 === 0){
        
        const num1 = listaOrdenada[parseInt(listaOrdenada.length / 2)];
        const num2 =listaOrdenada[parseInt(listaOrdenada.length / 2)-1];

        const mediana = (num1 + num2) / 2;

        return mediana
    } else {
        return lista[parseInt(listaOrdenada.length / 2)];
    }
}


const mediana = CalcularMediana(lista1);

console.log(mediana);

Bueno, esto fue lo que realicé, inicialice un array vació, para luego crear un función que me traiga los inputs(que seran los salarios que el usuario decida) del html y pasarlos al array vacio con el método push(), luego los organizara por el método sort() , dentro de esa misma función metí las demás funciones y condiciones que ya habíamos hecho en la clase

si creen que debería mejorar algo o corregir me gustaría que me lo dejaran en comentarios. Gracias 😃

En el minuto 8:11 no me salía lo mismo.

Todo era culpa de una **** letra

Puse:
const mitadLista1 = parsetInt(lista1.length / 2);

Era:
const mitadLista1 = parseInt(lista1.length / 2);

Sí tan solo era una T de más

Solo tuve una duda, busqué como limpiar un array y leí que solo con sustituirlo > lista = [];
Pero decía que debía tener cuidado porque si al antiguo lo estaban referenciando podía haber conflicto, no entendí bien. Igual eso es un extra, para el botón de limpiar todo. Pero me quedó la duda.

Comparto mi solución, con el método .sort y solucionando errores al intentar pasar la lista que deseamos calcular a través de un input a la función.
![](

const inputLista = document.getElementById("InputLista");
    const inputValue = inputLista.value 
    
    let lista = inputValue;
    let lista1 = lista.split(',').map(i=>Number(i));
    
    console.log(lista1);

    lista1.sort((a,b) => a-b);

Gracias por los ejemplos de algunos compañeros

/** 2RA PARTE - MEDIANA ***************************************/
function calcMiddleArith(listm) {
	listm.sort( (a, b) => a - b);
	// return listm;

	const middleList = parseInt(listm.length / 2);
	let middle = 0;

	if (isEven(listm.length)) {
		const elem01 = listm[middleList];
		const elem02 = listm[middleList - 1];
		
		const meanElements = calcMeanArith([
			elem01,
			elem02,
		]);
		middle = meanElements;

	} else {
		middle = listm[middleList];
	}

	return middle;
}

function isEven(num) {
	if (num % 2 === 0)
		return true;
	else
		return false;
}

Código para el cálculo de la mediana



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

    const promedioLista= sumaLista/lista.length;
    return promedioLista;    
}

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

function ordenarArray(lista){

    lista.sort(function(a,b)
    {
        return a-b;
    });
    console.log(lista);
}

function calcularMediana(lista){
    ordenarArray(lista);
    const mitadLista =parseInt(lista.length/2);
    let mediana;
    if (esPar(lista.length)){
        const elemento1 = lista[mitadLista];
        const elemento2 = lista[mitadLista-1];
        const promedio = calcularMediaAritmetica([elemento1, elemento2]);
        mediana = promedio;
    }else{
        mediana = lista[mitadLista];
    }

    return "Mediana: " + mediana;
}

Así solucioné el reto:

function calcularMediana(lista){

let valorCalculado = 0;
let valorCalculado2 = 0;
let valorFinal = 0;
let resultadoMediana = 0;
let listaOrdenada = lista.sort((a,b)=>{
    return a-b;
 }); 

    if(lista.length % 2 == 0){
        
        valorCalculado = lista.length / 2;
        valorCalculado = valorCalculado - 1;
        valorCalculado2 = valorCalculado + 1;
        resultadoMediana = lista[valorCalculado] + lista[valorCalculado2];
        resultadoMediana = resultadoMediana / 2;
        return resultadoMediana;
    }
    else{
        
        valorCalculado = lista.length / 2;
        valorCalculado = valorCalculado + 1;
        valorFinal = Math.trunc(valorCalculado);
        resultadoMediana = lista[valorFinal - 1];
        return resultadoMediana;
    }

}

Mi version del reto

function calcularmediana(lista2){
lista2.sort((a,b)=>a-b);
console.log(lista2);
mediana= parseInt(lista2.length/2);
if (lista2.length % 2 ===0) {
mediana2=mediana;
mediana=mediana-1
mediana=(lista2[mediana]+lista2[mediana2])/2;
return mediana;
}else{
return lista2[mediana];
}
}

En la documentación aparece la comparación para valores numéricos.

function calucularMediana(lista) {
    function ordenNumerico(a, b) {   //para ordenar numerico dentro del SORT
        return a - b;
      }
    listaOrdenada = lista.sort(ordenNumerico);
    let mediana;
    const mitadLista = parseInt(lista.length / 2);
//si el listado es numero par hay que sacar el promedio de las del medio, sino se queda con el elemento del medio
    if (esPar(lista.length)) {
        const elemento1 = listaOrdenada[mitadLista - 1];
        const elemento2 = listaOrdenada[mitadLista];
        const promedioElemento1y2 = calucularMediaAritmetica([elemento1, elemento2]);
        mediana = promedioElemento1y2
    } else {
        mediana = listaOrdenada[mitadLista];
    }
    return mediana
}

const lista1 = [
100,
200,
654,
500,
350,
400000000
];
const mitadLista1 = parseInt((lista1.length) / 2);
let mediana;
let mediana2;
function par(valor) {
if(valor % 2 === 0) {
console.log(lista1[mitadLista1]);
} else {
mediana = lista1[mitadLista1];
mediana2 = lista1[mitadLista1-1]
let res = mediana+mediana2;
console.log(res / 2)
}
};
par(mitadLista1)

Aquí cumpliendo ambos retos, la función y el sorting correcto:
.
.
.
JS

const anyArray = [2, 34, 5, 24, 31, 23, 18, 49, 60, 9, 38, 6];

function calculateAverage(list) {
    const sum = list.reduce(
        function (accumulatedValue = 0, newValue) {
            return accumulatedValue + newValue;
        }
    )

    const average = sum / list.length;
    console.log(average);
}

const orderedArray = anyArray.sort( function(a, b) {
    return a - b;
});

function calculateMedian(orderedArray) {

    const halfArray = parseInt((orderedArray.length / 2));

    if (orderedArray.length % 2 === 0) {
        const value1 = orderedArray[halfArray - 1 ];
        const value2 = orderedArray[halfArray];
        calculateAverage([value1, value2])
    } else {
        console.log(orderedArray[halfArray]);
    }  
    
}

calculateMedian(orderedArray);

Yo me anticipé y solo viendo el ejercicio, quise tratar de hacerlo por mi cuenta antes de ver la explicación de Juandi 😃

Les dejo por acá mi código 😃

function calcMedian(listNumber) {
  let lengthList = listNumber.length;
  let sortedList = listNumber.sort((a, b) => a - b);
  //console.log("Sorted array is: " + sortedList);
  let median = 0;
  let middle1 = 0;
  let middle2 = 0;

  if (lengthList % 2 == 0) {
    middle1 = sortedList[lengthList / 2 - 1];
    middle2 = sortedList[lengthList / 2];
    //console.log(`Middle1 =${middle1} and Middle2 = ${middle2}`);
    median = (middle1 + middle2) / 2;
  } else {
    median = sortedList[Math.floor(lengthList / 2)];
  }
  return median;
}

Les comparto mi solución al reto:

function calculateAverage(list) {
  const sumList = list.reduce(function (accumulatedValue = 0, newElement) {
    return accumulatedValue + newElement;
  });

  const averageList = sumList / list.length;
  return averageList;
}

function calculateMedian(list) {
  list.sort();

  const halfList = parseInt(list.length / 2);

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

  let median;

  if (esPar(list.length)) {
    const element1 = list[halfList - 1];
    const element2 = list[halfList];

    const averageElement1n2 = calculateAverage([element1, element2]);

    median = averageElement1n2;
  } else {
    median = list[halfList];
  }
  return median;
}

Para ordenar numero en el Array es necesario utilizar un metodo de comparación debido a que ordena por caracteres y no por el valor numerico.

var arr = [ 40, 1, 5, 200 ];
function comparar ( a, b ){ return a - b; }
arr.sort( comparar );  // [ 1, 5, 40, 200 ]

Esta es mi solución al problema, creo que fue relativamente fácil

const list1 = [10000, 400, 200, 1, 500, 725, 893, 346]
list1.sort(function(a,b){
    return a - b
})
console.log(list1)

mi codigo en JS:

const mediaOrdenada = (lista=[])=>{
    lista = lista.sort((a, b) => a - b);
    let mediana = 0;
    const mitad = parseInt(lista.length / 2);
    if(mitad % 2 === 0  ){
        const elemento1 = lista[mitad];
        const elemento2 = lista[mitad+1];
        mediana = (elemento1 + elemento2 )/ 2;
    }else{
        mediana = lista2[mitad];
    };
    return console.log(mediana);
};

espero les ayude

aqui mi aporte espero les ayude :

en js:

const lista2 =[
    100,
    200,
    500,
    400000000,
];
let mediana = 0;
const mitadLista = parseInt(lista2.length / 2);

if(mitadLista % 2 === 0  ){
    const elemento1 = lista2[mitadLista];
    const elemento2 = lista2[mitadLista-1];
    mediana = (elemento1 + elemento2 )/ 2;
}else{
    mediana = lista2[mitadLista];
};
console.log(mediana); 

Logrado! 💪🚀💚

JS

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

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

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

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

  if (esPar(lista.length)) {
    const elemento1 = lista[mitadLista - 1];
    const elemento2 = lista[mitadLista];
    const medianaEspromedioElem1y2 = calcularMediaAritmetica([elemento1, elemento2]);
    return medianaEspromedioElem1y2;
  } else {
    return lista[mitadLista];
  }
}

Mi código en HTML

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Calculo de mediana</title>
</head>
<body>
    <header>
        <h1>
            Mediana
        </h1>
    </header>

    <section>
        <h2>
            Calcular la mediana de una lista echa a partir de valores ingresados.
        </h2>
        <form>
            <label for="InputList">
                Ingrese los valores que se agregaran a la lista.
            </label>
            <br>
            <br>
            <br>
            <input id="InputList" type="number">
            <br>
            <br>
            <button type="button" onclick="onClickButtonMediana()">
                Agregar valores a la lista.
            </button>
            <br>
            <br>
            <button type="button" onclick="onClickButtonOrdenar()">
                Ordenar el array.
            </button>
            <br>
            <br>
            <button type="button" onclick="onClickButtonCalculo()">
                Calcular mediana de la lista.
            </button>
            <p id="mediaP"></p>
        </form>
    </section>

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

Mi código en javaScript

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

const lista1 =  [];



function onClickButtonMediana(){
    const inputMediana = document.getElementById("InputList");
    const medianaValue = lista1.push(inputMediana.value);
}

function comparacion (a, b){
    return a - b;
}

function onClickButtonOrdenar(){
    lista1.sort(comparacion);
    return console.log(lista1);
}


function onClickButtonCalculo(){

const mitadLista1 = parseInt(lista1.length / 2);

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


let mediana;


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

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

    mediana = promedioElemento1y2;
} else{
    mediana = lista1[mitadLista1];
}

const resultP = document.getElementById("mediaP");
resultP.innerText = "La mediana de la lista es: " + mediana;
}