No tienes acceso a esta clase

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

Calculando la mediana en una lista impar

14/30
Recursos

Aportes 88

Preguntas 4

Ordenar por:

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

o inicia sesi贸n.

Math.round()

Obtiene el siguiente numero mas cercano( si es >.5 redondea hacia arriba, si es <.5 redonda hacia abajo)

Math.round(2.5) // output: 3
Math.round(2.49) // output: 2

Math.floor()

Obtiene el numero entero anterior mas cercano (redondear hacia abajo).

Math.floor(2.99) // output: 2
Math.floor(2.5) // output: 2
Math.floor(2.49) // output: 2

Math.ceil()

Obtiene el numero entero siguiente mas cercano (redondear hacia arriba).

Math.ceil(2.5) // output: 3
Math.ceil(2.49) // output: 3
Math.ceil(2.1) // output: 3

驴Pero si la lista no est谩 ordenada? Estuve viendo los m茅todos para ordenar el array y encuentre el m茅todo sort aplique la siguiente soluci贸n para ordenar el array de menor a mayor.

Esta es mi soluci贸n:

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

const newArray  = arrayNum.sort((a, b) => a - b);

console.log(newArray) // [1,2,3,4,5]
Math.ceil(10.1) //redondea hacia arriba  sin importar la cantidad de decimales el output es  11
Math.floor(10.1) //solo elimina los decimales el output es  10

Les comparto mi soluci贸n para calcular la mediana

Mi soluci贸n para la funci贸n MEDIANA

  • Verificaci贸n en la consola:
if(arrayEsPar){
        const primera = Math.floor(array.length / 2) - 1;
        const segunda = Math.floor(array.length / 2);
        return resultadoDeSuma = array[primera] + array[segunda] / 2;

He aqu铆 mi soluci贸n 馃殌!

function calcularMediana(lista){
    // ordenar la lista, en caso de no serlo
    const listaOrdenada = lista.sort((a,b)=>a-b)

    // llamar funcion es par
    const listaEsPar = esPar(listaOrdenada);

    if(listaEsPar){
        // obtener indices
        const indexListaPar = Math.floor(listaOrdenada.length/2);
        const indiceAntListaPar = (indexListaPar-1)
        const medianaListaPar = ((listaOrdenada[indexListaPar] + listaOrdenada[indiceAntListaPar]) /2);

        //imprimir posicion y mediana
        console.log(indiceAntListaPar,indexListaPar);
        console.log(medianaListaPar);
    }else{
        // redondear hacia arriba, para obtner la mitad de la cuenta,
        //floor: solo elimina los decimales 
        const indexMitadListaImpar = Math.floor(listaOrdenada.length/2)
        const medianaListaImpar = listaOrdenada[indexMitadListaImpar];

        //imprimir posicion y mediana
        console.log(indexMitadListaImpar);
        console.log(medianaListaImpar);
        return medianaListaImpar
    }
}

Despu茅s de darle mucho a la cabeza logr茅 resolver el desaf铆o a mi manera, ** Les invito a probar el c贸digo, nos vemos la pr贸xima clase **.

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>Promedios</title>
</head>
<body>
    <h1> Introduce un valor a la vez para crear un promedio de los numeros</h1>
    <input id="inputvalue" value="0" type="number"></input>
  
    <div class="buttons">
        <label for="store">Guarda el numero que ingresaste </label>
        <button id="store" type="button">Save</button>
        <label for="show">muestra la lista de numeros que has ingresado </label>
        <button id="show" type="button">Show</button>
        <label for="average">muestra el promedio de esos numeros </label>
        <button id="average" type="button">promedio</button>
        <label for="middle"> calcula la mediana</label>
        <button id="middle" type="">mediana</button>
    </div>
    
    <div id="error"></div>
    <div id="result"></div>

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

JS

// promedio

const inputNumber = document.getElementById('inputvalue');
const allnumbers = [];
let sum = 0;
let media = [];
let numbersOfElements = allnumbers.length;


document.getElementById("store").addEventListener("click", function() {
    sum = 0;
    for( i = 0; i < allnumbers.length; i++){
        sum += parseInt(allnumbers[i]);
    }
    allnumbers.push(inputNumber.value);
    console.log("La cantidad de elementos es de: " + allnumbers.length + " La lista de los elementos es:  " + allnumbers  );

});
document.getElementById("show").addEventListener("click", function() {
    sum = 0;
    for( i = 0; i < allnumbers.length; i++){
        sum += parseInt(allnumbers[i]);
    }
    console.log("La suma le los numeros ingresados es: " + sum);
});
document.getElementById("average").addEventListener("click", function(){
    sum = 0;
    for( i = 0; i < allnumbers.length; i++){
        sum += parseInt(allnumbers[i]);
    }
    totalAverage = sum / allnumbers.length;

    console.log("El promedio de todos los elementos es de:  " + totalAverage);
});

// media

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

    let media = allnumbers.map(function (x){return parseInt(x, 10)});
    
        if (allnumbers.length % 2 === 0) {
          console.log("La mediana es par");
        } else {
          const medianaImpar = Math.floor(media.length / 2) + 1;
          const medianaListaImpar = media[medianaImpar - 1];
          console.log("La mediana es: " + medianaImpar);
          console.log("Y su valor es: " + medianaListaImpar);
          return medianaListaImpar;
        }
    });

Reto cumplido, otra forma de redondear es usando .toFixed(0);

(2.5).toFixed(0);
//  3
(2.4).toFixed(0);
//  2
let array = [1,2,3,4,5];

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

function calcularMediana (array){
    let mitad = array.length / 2;
    if (esPar(array)){
        let mediana = (array[mitad-1] + array[mitad]) / 2
        return mediana;
    } else {
        let mediana = (array[(mitad-1).toFixed(0)]);
        return mediana
    }
}

calcularMediana(array);
// 3

function esPar(lista){
return!(lista.length%2);
}
function esImpar(lista){
return(lista.length%2);
}

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

Mi soluci贸n

'use strict';
const numbers = [12, 56, 89, 56, 78, 23, 56, 12, 23, 24, 71, 55, 20, 41, 46]
const numbers2 = [1, 2, 3, 4, 5]

function mediana(array) {
    const newArray  = array.sort((a, b) => a - b);
    const isEven = array.length % 2 == 0 ? true : false
    if (isEven) {

    } else {
        const indexMediana = Math.floor(newArray.length / 2);
        const median = newArray[indexMediana]
        console.log(median);
    }
    console.log(newArray);
}
mediana(numbers)
mediana(numbers2)

Referecia al metodo sort

Mi soluci贸n al reto

'use strict';
const numbers = [12, 56, 89, 56, 78, 23, 56, 12, 23, 24, 71, 55, 20, 41, 46, 100]
const numbers2 = [10, 13, 2, 50, 80, 3, 15, 43, 5, 6, 7]

function mediana(array) {
    let indexMediana;
    let median
    const newArray  = array.sort((a, b) => a - b);
    const isEven = array.length % 2 == 0 ? true : false
    if (isEven) {
        indexMediana = newArray.length / 2;
        median = average( [newArray[indexMediana], newArray[indexMediana - 1] ] )
        console.log(median);
    } else {
        indexMediana = Math.floor(newArray.length / 2);
        median = newArray[indexMediana]
        console.log(median);
    }
    console.log(newArray);
}
mediana(numbers)
mediana(numbers2)

Mi mediana usando la funci贸n parImpar():

Math.floor() ==> REDONDEA AL N脷MERO ENTERO ANTERIOR M脕S CERCANO
Math.ceil() ==> REDONDEA AL N脷MERO ENTERO POSTERIOR M脕S CERCANO
Math.round() ==> REDONDEA COMO NOS ENSE脩ARON EN EL COLEGIO鈥I PASA .5 REDONDEA AL SIGUIENTE, SINO AL ENTERO ANTERIOR.

鈫 math.round: redondeo al m谩s cercano
鈫 math.floor: redondeo hacia el menor
鈫 math.ceil: redondeo hacia el mayor

Explicaci贸n para determinar la mediana de una lista IMPAR

-

Explicaci贸n para determinar la mediana de una lista PAR

Resultado:

Calcular la mediana y el 铆ndice de una lista impar 馃

  console.group("Calcular la mediana y el 铆ndice de una lista impar:");
        //Calcular la mediana y el 铆ndice de una lista impar

        function calcularIndiceListaImpar(arr) {
            const longitudLista = arr.length;
            const indexMitadListaImpar = Math.floor(longitudLista / 2);
            //return console.log(longitudLista, indexMitadListaImpar);
            return console.log(`La mediana de la lista es: \n ${arr[indexMitadListaImpar]}`);
        }

        calcularIndiceListaImpar(["a", "b", "c"]);
        calcularIndiceListaImpar(["1", "2", "3", "4", "5"]);
        calcularIndiceListaImpar(["1", "2", "3", "4", "5", "7", "8", "9", "10"]);

        console.groupEnd("Calcular la mediana y el 铆ndice de una lista impar:");

Aca mi solucion

const resolveParNumber = (num) => {
return num % 2 == 0;  
}

Resolv铆 el reto aplicando esta l贸gica:

function calcularMediana(){
        
    arrayMediana = arrayMediana.sort((a,b)=> a-b); //Ordenar el Array
    let arrCant = arrayMediana.length; //Obtener la cantidad de datos de la Lista
    let indexMitad = Math.round(arrCant/2); //Obtener el numero del medio
    let mediana;
    
    let isPar;
    !(arrCant % 2) ? isPar = true :  isPar = false;
    
    if(isPar){
        let index1 = indexMitad-1;
        let index2 = indexMitad;
        mediana = (arrayMediana[index1] + arrayMediana[index2])/2;
        console.log(mediana);

    }else{        
        mediana =arrayMediana[indexMitad];
        console.log(mediana);
    }       
}

calcularMediana();

Mi aporte people 馃槂

const paroimpar = (...lista)=>{
    lista.forEach(function(e,index){
        e % 2 == 0 ? console.log(`El ${index + 1} es par`)   : console.log(`El ${index + 1} es impar`); 
    });
}
paroimpar(2,3,6,8,10);

here my solution:

const numeros = [25,27,28,29,30,45]
numeros.sort();
function esPar(numeros){
if (numeros.length % 2 === 0 )
{
   return true}
    else { return false};}

console.log (esPar(numeros));

function mediana(numeros){
    const par = esPar(numeros);
    if (par){
        let numero1 = numeros[numeros.length/2] ;
        let numero2 = numeros[numeros.length/2-1];
        let mediana = (numero1 + numero2)/2;
        console.log (mediana)
    } else {
        let mediana = numeros[Math.round (numeros.length/2 - 1)]
        console.log(mediana)
    }
}
mediana(numeros);

function getMedian(arr) {
  arr.sort((a, b) => a - b);
  let middle = Math.floor(arr.length / 2);
  if (arr.length % 2 === 0) {
    return (arr[middle - 1] + arr[middle]) / 2;
  } else {
    return arr[middle];
  }
}

const values = [5, 7, 12, 45, 3, 2];
console.log(getMedian(values)); // 7

La funci贸n getMedian() toma un array como par谩metro y utiliza el m茅todo sort() para ordenar los valores del array. Luego, se determina si el tama帽o del array es par o impar. Si es par, se promedia los dos valores del medio y si es impar se retorna el valor del medio. En este ejemplo la mediana es 7.

Mi soluci贸n:

let array2 =[1,2,3,4,5,6,7,8,9,10];
const p =document.querySelector("p");
let redondear = Math.round((array2.length / 2)) ;
let cantidadDeArray = array2.length;

console.log(cantidadDeArray/redondear);

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

parOinpar(); 

EL codigo si el array es par

        let pos1=arr[Math.floor(arr.length/2)-1];
        let pos2=arr[Math.floor(arr.length/2)];
        return (pos1+pos2)/2;

Aqu铆 mi contribuci贸n 鉂わ笍

function esPar(lista){
    for(let i = 0; i < lista.length; i++){
        reciduo = lista[i] % 2;
        if(reciduo == 0){
            console.log(`El n煤mero ${lista[i]} es par`);
        } else {
            console.log(`El n煤mero ${lista[i]} es inpar`);
            const medianaInpar = Math.floor(lista[i] / 2) + 1;
            console.log(`Su mediana es: ${medianaInpar}`);
        }
    }
}


Mis funciones
es par
es impar
calcularMediana

const isEven= (arr)=> arr.length%2 === 0 ? true : false;
const isOdd = (arr)=> !isEven(arr);

function calcularMediana(arr){
    let mediana;
    if(isEven(arr)){mediana = (arr[arr.length/2]+arr[(arr.length/2)-1])/ 2; return mediana}
    else {mediana = arr[(arr.length-1)/ 2]; return mediana}
}

Lo hice de esta forma

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

Aqu铆 mi soluci贸n para sacar la mediana en lista par o impar鈥︷煒

Comparto mi soluci贸n para hallar la mediana de una lista ordenada, ya sea par o impar:

function calcularMediana(lista){
    const listaEsPar = esPar(lista)
    if(listaEsPar){
        const i = lista.length /2;
        const medianaListaPar = (lista[i-1]+lista[i])/2;
        console.log({medianaListaPar});
        return medianaListaPar
    } else {
        const indexMitadListaImpar = Math.floor(lista.length/2);
        const medianaListaImpar = lista[indexMitadListaImpar];
        console.log(indexMitadListaImpar);        
        console.log({medianaListaImpar})
        return medianaListaImpar
    }

}

Saber si la longitud de mi arreglo es par 馃:

 const nums = [0, 1, 2, 3, 4, 5, 6];
 //Funci贸n longitud arreglos es par o impar
        function longParOImpar(arr) {
            if (arr.length % 2 == 0) {
                console.log("Longitud del arreglo es par: ", arr.length);
            } else {
                console.log("Longitud del arreglo es impar: ", arr.length);
            }
        }

        longParOImpar(nums);

que chistoso que cuando hago el c贸digo descriptivo juan lo hace sencillo y cuando lo hago sencillo el lo hace bien descriptivo jajajaja, aqu铆 est谩 como lo hice sin Math.floor y luego utilizando el Math.floor.
Sin Math.floor:

function calcularMediana(lista) {
    const listaEsPar = esPar(lista);

    if (listaEsPar) {
        return console.log('hola');
    } else {
        return lista[((lista.length / 2) - 0.5)] 
    }


} 

Con Math.floor:

function calcularMediana(lista) {
    const listaEsPar = esPar(lista);

    if (listaEsPar) {
        return console.log('hola');
    } else {
        return lista[Math.floor(lista.length / 2)] 
    }


}

Yo lo resolv铆 de est谩 manera:

As铆 qued贸 mi funci贸n, espero les ayude:

// Par -> 0 -> En booleano 0 es false
// Impar -> 1 -> En booleano 1 es true

function esPar(lista) {
    return !(lista.length % 2);
}
function esImpar(lista) {
    return lista.length % 2;
}

function calcularMediana(lista) {
    const listaEsPar = esPar(lista);
    
    if (listaEsPar) {
        const posicionAbajoPar = Math.floor(lista.length / 2);
        const posicionArribaPar = Math.floor(lista.length / 2) + 1;
        const medianaListaPar = (lista[posicionAbajoPar] + lista[posicionArribaPar]) / 2;

        console.log(medianaListaPar)

    } else {
        const posicionElementoImpar = Math.floor(lista.length / 2); // Posici贸n en el array del elemeto impar.
        const medianaListaImpar = lista[posicionElementoImpar];

        console.log(posicionElementoImpar);
        console.log(medianaListaImpar);
    }
}

Por mi parte aqu铆 les dejo mi c贸digo en GitHub de la manera que lo hice: https://github.com/robefernandez22/taller-math-js/tree/master/median y tambi茅n el despliegue en GitHub Pages por si quieren probarlo: https://robefernandez22.github.io/taller-math-js/median/. Cualquier cr铆tica y mejora es bien recibida!

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

function saberSiEsPar() {
    return arrayParImpar.length % 2 == 0
}

function calcularMediana() {
    let listaEspar = saberSiEsPar(arrayParImpar)

    if (listaEspar) {
        //si es par
        let segundoNumero = arrayParImpar.length / 2
        let primerNumero = (arrayParImpar.length / 2) -1
        
        let PromedioDeLosDosNumero = (arrayParImpar[segundoNumero] + arrayParImpar[primerNumero]) / 2
        console.log(PromedioDeLosDosNumero)

    } else {
        //si es impar
        indexDelArray = Math.floor(arrayParImpar.length / 2)
        console.log(arrayParImpar[indexDelArray])
    }

}

calcularMediana(arrayParImpar) 

Mi soluci贸n usando at():

馃槂 Hola! Asi resolvi el ejercicio antes de empezar la clase para hallar la mediana siendo par o impar

const arrayOfNumbersForMedian = [1,15, 2, 8, 6];

console.log(arrayOfNumbersForMedian.length)
console.log(arrayOfNumbersForMedian.sort((a, b) => a - b));

const halfOfTheArray = arrayOfNumbersForMedian.length / 2
if(arrayOfNumbersForMedian.length % 2 == 0) {
    const half1 = arrayOfNumbersForMedian[Math.round(halfOfTheArray - 1)];
    const half2 = arrayOfNumbersForMedian[Math.round(halfOfTheArray)];
    const median = (half1 + half2) / 2;
    
    //console.log(arrayOfNumbersForMedian)
    console.log("The median is: " + median); 
} else {
    const median2 = arrayOfNumbersForMedian[Math.round(halfOfTheArray - 1)];
    console.log("The median of an odd array is: " + median2);
}

Soluci贸n al reto:
.
.
.

    if (isEven(array)) {
        let number1 = orderedArray[(array.length / 2) - 1];
        let number2 = orderedArray[array.length / 2];
        let medianEvenArray = (number1 + number2) / 2;
        return medianEvenArray;
    }

Aqu铆 mi soluci贸n para Mediana Par:

    if(listaEsPar){
        
        const primerIndexListaPar = lista.length / 2;
        const segundoIndexListaPar = Math.floor((lista.length - 1) / 2) ;

        const valorPrimerIndexListaPar = lista[primerIndexListaPar];
        const valorSegundoIndexListaPar = lista[segundoIndexListaPar];
        
        const mediana = (valorPrimerIndexListaPar + valorSegundoIndexListaPar)  / 2 ;

        console.log(valorPrimerIndexListaPar);
        console.log(valorSegundoIndexListaPar);
        console.log(mediana);
    }
<code> 

Para encontrar la mediana sin importar si la lista es par o impar:

const calculateMedian = (arr) => {
	const median = arr.length / 2;
	const ordenedArray = arr.sort((a, b) => a - b);
	return arr.length % 2 === 0
		? (ordenedArray[median] + ordenedArray[median - 1]) / 2
		: ordenedArray[Math.floor(median)];
};
```js function esPar(length){ return (length % 2) == 0 } const arr = [15, 8, 9, 27, 58, 21] function obtenerMediana(arr){ if(esPar(arr.length)){ arr.sort((a, b) => a - b) const mitad = (arr.length / 2) - 1 return (arr[mitad] + arr[1 + mitad])/ 2 } else{ arr.sort((a, b) => a - b) return arr[Math.floor(arr.length / 2)] } } console.log(obtenerMediana(arr)) ```function esPar(length){ return (length % 2) == 0 } const arr = \[15, 8, 9, 27, 58, 21] function obtenerMediana(arr){ if(esPar(arr.length)){ arr.sort((a, b) => a - b) const mitad = (arr.length / 2) - 1 return (arr\[mitad] + arr\[1 + mitad])/ 2 } else{ arr.sort((a, b) => a - b) return arr\[Math.floor(arr.length / 2)] } } console.log(obtenerMediana(arr))
```js function esPar(length){ return (length % 2) == 0 } const arr = [15, 8, 9, 27, 58, 21] function obtenerMediana(arr){ if(esPar(arr.length)){ arr.sort((a, b) => a - b) const mitad = (arr.length / 2) - 1 return (arr[mitad] + arr[1 + mitad])/ 2 } else{ arr.sort((a, b) => a - b) return arr[Math.floor(arr.length / 2)] } } console.log(obtenerMediana(arr)) ```function esPar(length){ return (length % 2) == 0} const arr = \[15, 8, 9, 27, 58, 21] function obtenerMediana(arr){ if(esPar(arr.length)){ arr.sort((a, b) => a - b) const mitad = (arr.length / 2) - 1 return (arr\[mitad] + arr\[1 + mitad])/ 2 } else{ arr.sort((a, b) => a - b) return arr\[Math.floor(arr.length / 2)] }} console.log(obtenerMediana(arr))
Esta es mi solucion para identificar numeros pares.const array = \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];const calcularArray = array.reduce((prev, actual) => {聽 if (actual % 2 === 0) {聽 聽 return \[...prev, actual];聽 }聽 return prev;}, \[]);```js const array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]; const calcularArray = array.reduce((prev, actual) => { if (actual % 2 === 0) { return [...prev, actual]; } return prev; }, []); ```

reto de la lista par

function calcularMediana (arr) {
    const listaEsPar = listIsPar(arr)
    if (listaEsPar) {
        const primerValorDeLaMitad = (arr.length / 2 ) - 1
        const medianaDeUnaListaPar= (arr[primerValorDeLaMitad] + arr[primerValorDeLaMitad + 1] ) / 2 
        return medianaDeUnaListaPar
        

    } else {
        const valorDeLaMitadimpar = ((arr.length - 1 ) / 2) + 1
        return arr[valorDeLaMitadimpar - 1]
    }
  
}

yo para hallar el elemento de la mitad de una lista no par descifre esta formula

        const valorDeLaMitad = ((arr.length - 1 ) / 2) + 1
//MEDIAN
const isEven = (array) => {
    
    if(array.length % 2 === 0){
        return true;
    }else{
        return false;
    }
}

const median = (array) => {

    const even = isEven(array);
    console.log(even);
    const number_items_array = array.length;

    if(!even) {

        middle = Math.ceil(number_items_array / 2);
        return array[middle - 1];

    }else{

        const middle_down = (number_items_array/2) - 1;
        const middle_up = (number_items_array/2);

        console.log(middle_down)

        return (array[middle_down] + array[middle_up]) / 2
    }

}

numbers = [1,3,5,7,9];
console.log(median(numbers));
**Mi soluc贸n para el reto** ```js const median = list => { const isPair = list.length % 2 // 0 = false - 1 = true if(!isPair) { const firstIndexList = (list.length / 2) - 1 const secondIndexList = (list.length / 2) return { element1: list[firstIndexList], element2: list[secondIndexList] } } else { const indexList = Math.floor(list.length / 2) return list[indexList] } } console.log(median([5, 12, 32, 15, 25])) ```
Aqu铆 tengo mi aporte *function* esPar(*lista*){ return !(lista.length % 2); } console.log(esPar(\[3,5])); // Retorna si la longitud del arreglo tiene NO tiene un residuo,// eso significa que es PAR, retorna TRUE O FALSE *function* esImpar(*lista*){ return lista.length % 2; } console.log(esImpar(\[4,2,3])); // Retorna si la longitud del arreglo tiene un residuo, lo// que lo convierte en un numero impar *function* Mediana(*lista*){ *const* listaEsPar = esPar(lista); if(listaEsPar){ return listaEsPar; }else{ // return lista.length / 2; // toma todo el arreglo y la longitud que tiene // la divide entre 2 *const* MedianaImpar = Math.floor(lista.length / 2); console.log(lista\[MedianaImpar]); // El metodo de Math floor nos va ayudar a quitar los decimales // a los numeros. por ejemplo el numer 9.5, se convierte en 9. // Esto nos ayuda, creamos una constante llamada MedianaImpar, a esta le // vamos a asignar el m茅todo de JS Matj.floor el cual no va ayudar // quitarle los decimales a lista.length con la divisi贸n de la longitud // del arreglo entre dos, sacando as铆 la mitad del arreglo } } console.log(Mediana(\[10,4,8,9,9,4,3]));

Asi quedo el mio

function calcularMediana(datos) {
  const datosPares = esPar(datos);
  if (datosPares) {
    const index1MitadListaPar = Math.floor(datos.length / 2) - 1;
    const index2MitadListaPar = index1MitadListaPar + 1;
    const medianaPar1 = datos[index1MitadListaPar];
    const medianaPar2 = datos[index2MitadListaPar];
    const mediana = promedio([medianaPar1, medianaPar2]);
    console.log(mediana);
    return mediana;
  } else {
    const indexMitadListaImpar = Math.floor(datos.length / 2);
    const medianaImpar = datos[indexMitadListaImpar];
    console.log(medianaImpar);
    return medianaImpar;
  }
}

Funci贸n para calcular los dos elementos en una lista par.

<function calcularMediana(lista){
    const listaEsPar = esPar(lista); // true or false
    console.log(listaEsPar, "xd");

    if(listaEsPar){
      const mitad = lista.length/2;
      return [lista[mitad -1], lista[mitad]];
    }else{
      const indexMitadListaImpar = Math.floor(lista.length / 2);
      const medianaListaImpar = lista[indexMitadListaImpar];
      console.log(indexMitadListaImpar);
      console.log(medianaListaImpar);
      return medianaListaImpar;
    };
const arrayNum = [5,20,30,8,25,30,60,55]
const newArrayNum = arrayNum.sort((a,b) => a - b)
console.log(newArrayNum);

console.log(calcularMediana(arrayNum));
}> 

Comparto mi codigo:

function calcularMediana(lista){
    // determinar si es par
    const isPar = lista.length % 2 == 0 ? true : false;
    const numerosMitad = lista.length / 2
    if (isPar){ //si es par, entonces:
        //sumar los dos numeros de en medio 
        return Math.round((lista[numerosMitad]+lista[numerosMitad-1]) / (2));
    }else{//si no es par, entonces
        const redondear = Math.floor(numerosMitad); //redondeamos el resultado de la divisi贸n
        return lista[redondear];
    }
}

As铆 me quedo la funci贸n para hallar la mediana en una lista par e impar.
*
*
*
*
*

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

function calcularMediana(lista) {
    let mitadLista = (lista.length / 2);
    let result = 0;

    if (esPar(lista)) {
        // Mediana lista par
        result = ((lista[Math.floor(mitadLista - 1)]) + (lista[Math.floor(mitadLista)])) / 2;
    } else {
        // Mediana lista impar
        result = lista[Math.floor(mitadLista)];
    }

    console.log(result);
    return result;
}

a mi manera pero lo intente y funciono, siempre y cuando la lista este ordenada.

function calcularMediana(lista){
    const listaEsPar = esPar(lista);

    if(listaEsPar) {
        const indexMitadListaImpar1 = (Math.floor(lista.length / 2)) - 1;
        const indexMitadListaImpar2 = (Math.floor(lista.length / 2));
        const medianaListaPar1 = lista[indexMitadListaImpar1];
        const medianaListaPar2 = lista[indexMitadListaImpar2];
        const promedioDeMedianaPar = (medianaListaPar1 + medianaListaPar2) / 2;
        return promedioDeMedianaPar;
    } else {
        const indexMitadListaImpar = Math.floor(lista.length / 2);
        const medianaListaImpar = lista[indexMitadListaImpar];
        console.log(indexMitadListaImpar);
        return medianaListaImpar;
    }
}

este fue mi solucion

function buscarParOimpar(lista) {
  // literar el array
  for (let i = 0; i < lista.length; i++) {
    if (lista[i] % 2 === 0) {
      console.log(`${lista[i]} es par`);
    } else {
      console.log(`${lista[i]} no es par`);
    }
  }
}

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

Esto fue lo que me invente con lo aprendido en clase, estuvo genial intentarlo.

Para aquellos que se le hizo un poco confuso la funcion esPar o imPar:

Recuerden que cuando Juan us贸 el modulo con el numero 10, le daba como resultado 0. Asi es como se veia, 10 % 2 == 0.

Explicacion del 0 y 1 como booleanos:

Por lo tanto la respuesta seria false, ya que el 0 es interpretado como false y 1 como true. Otro ejemplo seria, 1 es la luz prendida y 0 la luz apagada.

Explicacion del simbolo !:

El simbolo de exclamacion lo que hace es alterar el valor booleano del resultado por lo opuesto. Asi que cuando decimos que tenemos 0 residuo es igual a un numero par, lo que la funcion nos entregaria seria un false debido al valor 0. Al agregar el simbolo ! lo que hacemos es decirle que cada vez que nos tregue el residuo como 0 que nos mande true.

Ejemplos de uso del simbolo !:

if(gallina){
return comeras huevo;
}

if(!gallina){
return tendras que ir al super;
}

Espero que le sirva a alguien y si me equivoque en algo estaria genial que me corrigieran.

Asi lo hize yo:

const esParOImpar = lista => lista.length % 2 === 0;

const calcularMediana = lista => {
    
    if (esParOImpar(lista) === true) {
        const indexMitadListaparIzquierda = Math.floor(lista.length / 2) - 1;
        const indexMitadListaparDerecha = Math.floor(lista.length / 2);
        const mediaListaparIzquierda = lista[indexMitadListaparIzquierda];
        const mediaListaparDerecha = lista[indexMitadListaparDerecha];
        return console.log(`${mediaListaparIzquierda} ${mediaListaparDerecha}`)
    } else{
        //Para encontrar los numeros
        const indexMitadListaImpar = Math.floor(lista.length / 2);
        const mediaListaImpar = lista[indexMitadListaImpar];
        console.log(mediaListaImpar)
        return mediaListaImpar
    }
}
let array = [1, 3, 4, 5, 6, 134, 5, 2, 9]

function  parOInparMediana(list) {
    let longitud = list.length
    let residuo = (longitud % 2)
    if (residuo == 0) {
        
        let mitadMenor = Math.floor(longitud / 2) - 1;
        let mitadMayor = mitadMenor + 1
        let promedioModa = (list[mitadMenor] + list[mitadMayor]) / 2
        console.log(list[mitadMenor], list[mitadMayor]);
        console.log(`moda ${promedioModa}`);
    }else {
        let mitad = Math.floor(longitud / 2);
        console.log(list[mitad]);
    }
}

parOInparMediana(array);

![](

Mi solucion fue la siguiente:

function calcularMediana(lista){
    const listaEsPar = esPar(lista);

    if(listaEsPar){
        const IndexMitadNum1 = (lista.length/2);
        const IndexMitadNum2 = IndexMitadNum1 - 1;
        const medianaListaPar = ((lista[IndexMitadNum1] + lista[IndexMitadNum2]) / 2 )

        return medianaListaPar;
    
    }else{
        const indexMitadListaImpar = Math.floor(lista.length / 2);
        const medianaListaImpar = lista[indexMitadListaImpar]

        return medianaListaImpar;

    }
}
en mi caso, observe que cuando se hace numImpar / 2.. el resultado siempre tiene .5 por lo cual me parece m谩s r谩pido agregar a la operaci贸n + 0.5 y as铆 se tiene la mitad del array!!

si, aca esta la tarea:
el 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>Document</title>
</head>
<body>
    <label for="element">Nuevo Elemento</label>
    <input type="text" name="element" id="element">
    <input type="button" id="btn" value="Agregar">

    <p id="msg"></p>

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

y el js:

<!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>Document</title>
</head>
<body>
    <label for="element">Nuevo Elemento</label>
    <input type="text" name="element" id="element">
    <input type="button" id="btn" value="Agregar">

    <p id="msg"></p>

    <script src="function.js"></script>
</body>
</html>
function calcularMedia(lista) {
  lista.sort((a, b) => a - b);
  let media;
  if (ParImpar(lista)) {
    media = lista.length / 2;
    return (lista[media - 1] + lista[media]) / 2;
  } else {
    media = lista.length / 2;
    console.log(lista);
    return lista[Math.round(media) - 1];
  }
}
 function ParImpar(lista){
    return lista.length%2 == 0 ? true : false
 }

Si la lista es par la calcular铆a de la siguiente forma: y teniendo los dos numero del centro llamo la funcion de calcular promedio

function esPar(lista) {
  return !(lista.length % 2)
}
function esImpar(lista) {
  return lista.length % 2;
}

function calcularMediana(lista) {
  const listaEsPar = esPar(lista);
  if (listaEsPar) {
    const indexMitadListaPar = lista.length / 2;
    const numerosCentro = lista.slice(indexMitadListaPar - 1, indexMitadListaPar + 1);
    const medianaListaPar = calcularPromedio(numerosCentro);
    console.log(indexMitadListaPar);
    console.log(numerosCentro);
    console.log(medianaListaPar);
    return medianaListaPar;
  } else {
    const indexMitadlistaImpar = Math.floor(lista.length / 2);
    const medianaListaImpar = lista[indexMitadlistaImpar];
    console.log(indexMitadlistaImpar)
    console.log(medianaListaImpar);
    return medianaListaImpar;
  }
}

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

  const sumaLista = lista.reduce(sumarTodosElementos);
  const promedio = sumaLista / lista.length;
  console.log(promedio);
  return promedio;
}
//calcularPromedio([65, 98, 54, 62, 70]);
calcularMediana([10, 20, 30, 40, 50, 60]);

aqui esta mi solucion y la solucion se representa en un array

function esImpar(lista) {
    return lista.length % 2
 }

 function calcularMediana (lista){
    const listaEsPar = esPar (lista);

    if (listaEsPar){
        const iniceMitadParMayor = Math.floor(lista.length /2)
        const medianaPar = [lista[iniceMitadParMayor-1], lista[iniceMitadParMayor]]
        console.log (medianaPar)

    }else {
        const indiceImpar = Math.floor(lista.length / 2);
        const medianaImpar = lista[indiceImpar]
        console.log(medianaImpar)
    }
 }

![](

Ojo, la segunda funci贸n de esImpar no devolver谩 ni True ni False, devolver谩 1 o 0, para devolver True o False necesitamos convertir el resultado a su valor booleano, esto se hace con doble signo de admiraci贸n, as铆: 鈥!!鈥, seguida de los asteriscos con el valor que queremos convertir a booleano. Si mandas a llamar a ambas funciones s铆 devuelve false o true para ambas, si s贸lo llamas a la segunda, devuelve un valor, pues estamos haciendo una operaci贸n matematica.

console.log(isListArrayPar(listArray));
function isListArrayPar(list){
    return !!(list.length % 2);
}
// calcular mediana 

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

function esImpar(lista){
    return lista.length % 2;
}

function calcularMediana(lista) {
    const listaEsPar = esPar(lista);

    if(listaEsPar){
        const mitadA = (lista.length / 2) - 1 ;
        const mitadB = lista.length / 2;
        const preResult = (((lista [mitadB]) - (lista [mitadA])) / 2) ;
        const resul = preResult + (lista [mitadA]);
        return resul;
        
    }else{
        const mitad = lista.length / 2;

        return lista [Math.floor(mitad)];
    }

    
}

Cordial saludo

Esta fue mi soluci贸n a la tarea de la clase pasada, para saber si un array es par o impar empec茅 pensando la l贸gica, si al dividir entre 2 la longitud del array me da un n煤mero entero quiere decir que la lista es par, caso contrario la lista es impar.

Luego consult茅 si exist铆a alguna herramienta en Javascript para saber si un n煤mero es entero o no, y encontr茅 la funci贸n Number.isInteger() que devuelve un booleano (true o false) y con ese valor se puede escribir un condicional if que eval煤e si la lista es par o impar.

Math.ceil() redondea para arriba 馃殌
function esPar(myArray){
    return !(myArray.length%2);
};
function mediana(myArray){
const even = esPar(myArray);
if (even){
    const newArray =myArray.sort((a,b)=>a-b);
    findNumber1=(newArray.length/2)-1;//recuerda que los arrays empiezan a contar sus posiciones desde el cero.
    findNumbe2=(newArray.length/2);
    const result=(newArray[findNumber1]+newArray[findNumbe2])/2;
    const final='mediana par '+result;
    console.log(final);
}else{
    const newArray =myArray.sort((a,b)=>a-b),
    findNumber=Math.floor(newArray.length/2);//recuerda que los arrays empiezan a contar sus posiciones desde el cero.
    const result= newArray[findNumber];
    const final ='mediana impar '+result;
    console.log(final);
}

};
/*NOTAS:
Math.round redondea al n煤mero mas cercano.
Math.floor redondea hacia abajo
Math.ceil redondea hacia arriba
Math.trunc redondea hacia el n煤mero que este m谩s cerca del cero
Math.Truncate is like Math.Floor for positive numbers, and like Math.Ceiling for negative numbers.
m茅todo sort para ordenar el array
https://desarrolloweb.com/articulos/ordenacion-arrays-javascript-sort */
function isPar(lista) {
  if (lista.length%2===0) {
    return true
  } else {
    return false
  }
}
function calcular_mediana(lista) {
  let mediana
  let numero_medios
  const lista_par=isPar(lista)

  if (lista_par) {
    numero_medios=lista[lista.length/2]+lista[(lista.length/2) - 1]
    mediana=numero_medios/2

  } else {
    mediana=lista[Math.floor(lista.length/2)]
  }
  return mediana
}

const lista=[2,4,6,9,15,10,3,7]
lista.sort((a, b) => a - b)
console.log(lista)

console.log(calcular_mediana(lista))
function listaParImpar(array) {
    if ((array.length % 2) == 0) {
        return true;
    } else {
        return false;
    }
}

Por si no entiendes los metodos ni sus procesos, con esta pagina pueden ver el proceso del codigo que quieran:

https://pythontutor.com/javascript.html#mode=edit

Aqui les dejo esta web para que creen sus propios snippets de visual studio code, me ayudo mucho a trabajar mas rapido

https://dev.to/franqsanz/como-crear-tus-propios-snippets-para-vscode-3i3g

Me tom贸 como 10 minutos darme cuenta de que mi c贸digo no funcionaba porque escrib铆 鈥渓enght鈥 en lugar de 鈥渓ength鈥 馃樀馃敨

Fuente: Visto por la Red! 馃枼

si array.length es par entonces:

if(listaEsPar){
        indexMitadListaPar1 = (lista.length / 2) - 1;
        indexMitadListaPar2 = lista.length / 2 ;
        console.log({indexMitadListaPar1, indexMitadListaPar2});
        console.log('es par');

        let promedioParaMediana = calcularPromedio([lista[indexMitadListaPar1], lista[indexMitadListaPar2]]);
        return promedioParaMediana;

Aporto mi soluci贸n para devolver la mediana cuando es par la cantidad de elementos del array.

function calcularMediana(lista){
    const listaEsPar = esPar(lista);

    if(listaEsPar){ // mediana cuando es par
        const indexMitadListaPar = lista.length / 2;
        const valorPromedioListaPar = (lista[indexMitadListaPar] + lista[indexMitadListaPar - 1]) / 2;
        return valorPromedioListaPar;
    }else{ // mediana cuando es impar
        const indexMitadListaImpar = Math.floor(lista.length / 2); // llegar a la mitad
        //console.log(lista[indexMitadListaImpar]);
        return lista[indexMitadListaImpar];
    }

}

Soluci贸n al reto de calcular la mediana de una lista par

if (listaEsPar){
            const indexMitadInferior = lista.length/2;
            const indexMitadSuperior = (lista.length/2) + 1;
            const indexPromedio = ((lista[indexMitadInferior]) + (lista[indexMitadSuperior])) / 2 ;
                   console.log(indexPromedio);

Esta es Mi solucion

const salario = document.querySelector('#salario')
const salarios = document.querySelector('#salarios')
const promedio = document.querySelector('#promedio')
const mediana = document.querySelector('#mediana')
const moda = document.querySelector('#moda')
const btnEnviar = document.querySelector('#btnEnviar')
btnEnviar.addEventListener('click', enviarSueldo)
const btnCalcular = document.querySelector('#btnCalcular')
btnCalcular.addEventListener('click',calcularPromedio)

let arrSueldos = []

function enviarSueldo(){
    arrSueldos.push(parseInt(salario.value))
    salarios.innerHTML += `${salario.value} `
}

function calcularPromedio(){
    const mediaAritmetica = (arrSueldos.reduce((ante,actu) => {return ante + actu}))/arrSueldos.length
    promedio.innerHTML = `El promedio es ${mediaAritmetica.toFixed(2)}`
}

function esPar(arr){
    return !(arr.length % 2)
}

function calcularMediana(){
    let med;
    if(esPar(arrSueldos)){
        valor1 = (arrSueldos.length / 2)
        valor2 = (arrSueldos.length / 2) -1
        med = (arrSueldos[valor1] + arrSueldos[valor2]) / 2
        mediana.innerHTML = `La mediana es ${med}`
    }else{
        med = Math.floor(arrSueldos.length / 2)
        mediana.innerHTML = `La mediana es ${arrSueldos[med]}`
    }
}
let conjunto = [1,3,4,5,6,8,9,0,19,10];
const esParoImpar = numero =>{
    if(numero%2 == 0 ){
        return true;
    }else{
        return false;
    }
}
const calcularMedia = lista =>{
    media = 0;
    if(esParoImpar(lista.length)){
        console.log('El total de elementos es par');
        mitad = Math.ceil(lista.length/2);
        media = lista[mitad]+lista[mitad-1];
        console.log(`La media del conjunto impar con ${lista.length} elementos es: ${media}`)
    }else{
        mitad = Math.ceil(lista.length/2);
        media = lista[mitad-1];
        console.log(media);
        console.log(lista[media]);
        console.log(`La media del conjunto impar con ${lista.length} elementos es: ${media}`)
    }
}
console.log(calcularMedia(conjunto))

function listaParImpar(lista) {
  return lista.length % 2 === 0 ? true : false;
}

tarde 3 eternidades viendo esta clase!

Mi soluci贸n al reto de la clase anterior

const checkEven = (number) => (number % 2 != 0) ? false : true;

Soluci贸n Mediana Lista Par

if(listaEsPar) {

        //Calcular la mediana de una lista par
        const indexMitadListaPar = (lista.length / 2) - 1
        console.log (indexMitadListaPar + ' -> el index de la lista par contando desde la posicion 0 array')

        const indexPosSiguiente = indexMitadListaPar + 1

        console.log (indexPosSiguiente + ' -> sacar el index por el cual indexMitadListaPar + este sacara promedio')

        const medianaListaPar = calcularPromedio([lista[indexMitadListaPar], lista[indexPosSiguiente]])

        console.log(medianaListaPar + ' -> sacar la mediana de la lista par') 
        return medianaListaPar

    }