Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Calculando la mediana en Javascript

16/24
Recursos

Aportes 497

Preguntas 44

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

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 ✌🏻

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!")
    }
}


Mis notas

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> 

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

Dejo aquí mi solución.

function calcularMediana(lista){
    
     const sortedList = lista.sort((a, b) => a - b );

    console.log(sortedList); //Para ver el orden.

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

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

};


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

Logre hacer que pusieran los números que quieran separándolos con coma, les comparto el código que me toco hacer para lograrlo, en internet veía formas mas complejas jaja

var inputNumber_mean = document.getElementById("inputNumber_mean");
var numbers = inputNumber_mean.value;
  var numbersA = numbers.split(`,`);
  var numberList = numbersA.map(function (numbersA) {
    return numbersA - "";
  });

Bueno le vote corriente.

Y le puedes ingresar cualquier array y funciona 😃

Les comparto amigos 😃

function calcularMediaAritmetica(lista){
        
    const acumulador= (acumulado, numero) => acumulado+numero;
    const sumaLista= lista.reduce(acumulador)
    
    
    const promedioLista= sumaLista / lista.length
    
        return promedioLista;
    }
    
    

const list= [];

 
function calcularMediana(list){
    const sortedList= list.sort(function(a,b){
        return a - b;
    })
    
      
    const mitadListado= parseInt(sortedList.length/ 2);

    console.log(sortedList)

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

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

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

        mediana= promedio1y2;
        
    }else{
        mediana= sortedList[mitadListado]; 
    }
    return mediana;
}



Mi resultado

function ordenarArray(array) {
  return array.sort((a, b) => a - b);
}

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.length % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

function calcularMediana(array) {
  const mitadArray = parseInt(array.length / 2);

  ordenarArray(array);

  if (esPar(array)) {
    const elemento1 = array[mitadArray - 1];
    const elemento2 = array[mitadArray];
    const promedio = [elemento1, elemento2];

    const mediana = calcularMediaAritmetica(promedio);

    return mediana;
  } else {
    const mediana = array[mitadArray];
    return mediana;
  }
}

Retos completados 😃

Comparto mi solución siguiendo la documentación proporcionada 😃:

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

    let media
    if(orderedList.length % 2 === 0){
        media = (orderedList[middleList] + orderedList[middleList - 1])/2 
    } else {
        media = orderedList[middleList]
    }
    return media
}

console.log(calculateMedia([2000,10,800,1,50,10000]));
console.log(calculateMedia([2000,10,10000,800,1,50,20]));

Asi hice esta función n_n

function calcularMedia(lista){
    const listaOrdenada = lista.sort();
    if (listaOrdenada.length % 2 === 0){
        let pos1 = (listaOrdenada.length / 2) - 1;
        let pos2 = pos1 + 1;
        let mediaPar = (listaOrdenada[pos1] + listaOrdenada[pos2]) / 2;
        return mediaPar;
    } else {
        let pos = parseInt(listaOrdenada.length / 2);
        let mediaImpar = listaOrdenada[pos] / 2;
        return mediaImpar;
    }

Hola comparta mi solución


function cacularMediana(info) {
  const lista2 = info;

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

  const listaOrdenada = lista2;
  console.log("Lista Ordenada: " + listaOrdenada);

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

  let mediana;

  if (esPar(listaOrdenada.length)) {
    const elem1 = lista2[mitadLista2 - 1];
    const elem2 = lista2[mitadLista2];
    const promedioElements = calcularMediaAritmetica([elem1, elem2]);
    mediana = promedioElements;
  } else {
    mediana = lista2[mitadLista2];
  }

  return console.log("Mediana: " + mediana);
}

Ordenamiento con el metodo sort()

Este fue mi resultado. Muy recomendada la lectura de sort.
Gracias!

function calculoMediana(lista1){
    //Ordenando la lista
    lista1.sort(function(a ,b){
        return a - b;
    })

    console.log(lista1);

    const mitad1 = lista1.length / 2;
    const mitad2 = mitad1 + 1;

    if (lista1.length % 2 === 0){
        //tomar datos de la mitad y sacar promedio
        let mediana = (lista1[mitad1 - 1] + lista1[mitad2 - 1]) / 2;
        console.log("la mediana es: " + mediana);
        console.log("esta es una lista con elementos pares");
        return mediana;
    }else{
        //tomar e imprimir dato de la mitad
        let mediana = lista1[parseInt(mitad2 - 1)];
        console.log("la mediana es: " + mediana);
        console.log("esta es una lista con elementos impares");
        return mediana;
}
}

¡Hola Platzinautas!

Les comparto mi solución al reto:

// Media, Media Aritmética o Promedio
function calcularPromedio(lista) {
    const suma = lista.reduce((acc, cur) => acc + cur, 0)
    const promedio = suma / lista.length
    return promedio
}

// Mediana
const comparar = (a, b) => a - b
const esPar = (numero) => numero % 2 === 0 ? true : false

function calcularMediana(lista) {
    const sortedArray = lista.sort(comparar)
    const mitad = parseInt(sortedArray.length / 2)
    const elemento1 = sortedArray[mitad - 1]
    const elemento2 = sortedArray[mitad]
    let mediana

    esPar(sortedArray.length)
        ? mediana = calcularPromedio([elemento1, elemento2])
        : mediana = sortedArray[mitad]

    return mediana
}

Pues yo aplique tal y como te menciona en la documentación, solo que usando una function anonima:

function calcularMediaAritmetica(lista){

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

return promedioLista;

}

const lista1 = [
800,
1,
80,
1500,
200,
100,
500,
40000,
];

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

function esPar(numerito){
if(lista1 % 2 == 0){
return “Es par”;
}else {
return “Es inpar”;
}
}

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

Hola, solo les quiero compartir en algo donde me perdí y como lo entendí en cuanto a la función de comparación que hacemos cuando ya tenemos la lista ordenada con el método sort.
Por si alguien se habra quedado con la duda. ( yo si lol ) y quería saber que estaba pasando por detrás en vez de copiar el código funcionando…

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

Honestamente cuando vi esa función no lo entendí jeje, me preguntaba “Que estaba restando?”, Que era a y b?, exactamente como estaba funcionando


Adentrándonos en los parámetros:


Luego de a ver entendido como ordena sort, debemos saber que este recibe una función como parámetro que es opcional,
de la cual esta función recibe otro parámetro que en este caso es a y b

const lista1 = [
  100,
  400,
  10,
  800
]

Que simplemente son los elementos de tu array:



Pero si hacemos un console.log de (a,b) el los ordena de la siguiente manera:

El primero con el segundo

El segundo con el tercero…etc


Luego de que ya sabemos esto, el procede hacer el return donde resta estos 2 parámetros, de los cuales ya sabes que dependiendo el resultado si es mayor o menor que 0 este los va a posicionar…

a mi me quedó así

function calcularPromedio(lista) {
  return lista.reduce((ac, v) => ac + v) / lista.length;
}

function calcularMediana(lista) {
    lista = lista.sort((a, b) => a - b);
  return lista.length % 2 != 0
    ? lista[parseInt(lista.length / 2)]
    : calcularPromedio(lista.slice(lista.length / 2 - 1, lista.length / 2 + 1));
}

no esta bonito gráficamente pero… Funcioonaa XD.
obviamente tiene algunos errores, le quería aplicar que con enter se pudiera ingresar el valor del input en lugar de onclick pero bueno, ahí les va. Orden cumplida.

<!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">
    <style>
        *{
            margin: 0;
            padding: 0;
        }
        body{
            background-color: rgb(5, 5, 60);
            color: lime;
            text-align: center;
        }
        p{
            color: whitesmoke;
        }
    </style>
    <title>Document</title>
</head>
<body >
    <h1>mediana</h1>
    
    
    <label for="valores">Ingrese los valores a operar</label>
    <input  type="number"  id="valores">
    <button  type="button" onclick="mostrarDatos(), borrarValor()" >Agregar valor.</button>
    <hr>
    <h3>Valores a operar:</h3>
    
    <p id="contentValues"></p>
    <br>
    <button  onclick="mediana()">Operar valores</button>
    <br>
    <br>
    <h3 id="medianaTotal">Total mediana</h3>
    <br>


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

const contentValues = document.getElementById('contentValues')


var lista1 = [];
function mostrarDatos() {

    const valores = document.getElementById('valores').value;

    //agregamos el valor escogido por el usuario al array
    lista1.push(valores);

    //ordenamos los elementos dentro del array
    lista1.sort(function(a, b) {
        return a - b;
    });

    //mostramos en pantalla  el valor escogido por el usuario ya almacenado
    // contentValues.innerHTML = lista1;
    let mostrarValores= []; 
    mostrarValores.push(valores);
    for (const dato of mostrarValores) {
        // almacenamos cada valor  a operar en un nuevo parrafo verticalmente
        let nuevoParrafo = contentValues.cloneNode(true);
        let parrafoContent = document.createTextNode(dato);
        nuevoParrafo.appendChild(parrafoContent);
        document.body.insertBefore(nuevoParrafo, contentValues);
        
    }


    return lista1;

}
lista1 = mostrarDatos();
lista1.shift();// eliminamos el primer elemento del array el cual es 
//un espacio en blanco que se añade por error... '_' =(


//limpiamos el imput para ingresar un nuevo valor
function borrarValor () {
    valores.value = "";
}




//Realizamos los calculos para hallar la mediana
const calcMediana = document.getElementById('calcMediana');
let medianaTotal = document.getElementById('medianaTotal');
function mediana(){

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

            }
        );

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



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

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

    let mediana;

    if (esPar(lista1.length) /*lista1 es par?*/) {
        const elemento1 = lista1[mitadLista1 -1]; 
        const elemento2 = lista1[mitadLista1]; //nesesitamos dos elementos
        const promedioElemento1y2 = calcularMediaAritmetica([elemento1, elemento2]);// - el promedio 
        mediana = promedioElemento1y2; // - la mediana
        medianaTotal.innerText = mediana;
    } else {
        mediana = lista1[mitadLista1]// posicion mitadLista1 dentro de lista 1
        // mediana
        medianaTotal.innerText = mediana;
    }

}

Mi solucion al problema

otra forma de realizarlo

//MEDIANA

const lista1=[100,200,500,400000000,800,2,8,9];
const mitadLista1=parseInt(lista1.length/2);
 let mediana;
 if(lista1.length%2==0){
        mediana=lista1.splice(mitadLista1-1,2);
    }else{
        mediana=lista1.splice(mitadLista1,1);  
 }
 console.log(mediana);
 console.log(mitadLista1);

const lista1 = [
    100,
    200,
    500,
    400000000,
];

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

//Este es mi forma de resolverloo, leí mucha documentación

let sueldosWapos = [
    10, 1, 90, 9, 40, 505, 69, 645, 64, 62  
];

function media( arr ){
    //Ordenamos el array de menor a mayor
    arr.sort( function( a, b ){
        return a - b;
    } );
    console.log( arr );
    //Comprobamos si es par o impar
    if( arr.length % 2 == 0 ){
        let mitad = arr.length / 2;
        console.group( "par" );
        console.log( ( arr[ mitad ] + arr[ mitad - 1] ) / 2 );
    }
    else{
        console.group( "impar" );
        console.log( arr[ ( arr.length / 2 ) - 0.5  ] );
    }
}

media( sueldosWapos );

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 + " ");
}

> 

Reto cumplido

function calcularMediaAritmetica(lista) {
    const sumaLista = lista.reduce((valorAcumulado, nuevoElemento) => 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);
    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;
}


de esta manera logre ordenar mi lista

const lista1 = [10, 50, 30, 80, 14, 10]

lista1.sort((a, b) => a - b)     // lista1 = [10, 10, 14, 30, 50, 80]