Calculando la mediana en una lista impar

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

Eliezer Hernandez

¿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]

Juan Pablo Cortés

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

Antonio Mora

Les comparto mi solución para calcular la mediana

Raúl Adolfo Sánchez Rodríguez

Mi solución para la función MEDIANA

Verificación en la consola:

Anderson alejandro Sanchez martinez

if(arrayEsPar){
        const primera = Math.floor(array.length / 2) - 1;
        const segunda = Math.floor(array.length / 2);
        return resultadoDeSuma = array[primera] + array[segunda] / 2;

Luis Miguel Rodriguez

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

Gustavo Liendo

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>

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

Orlando Rodriguez

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

diego rivera

hace 6 meses

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

Nestor Rios Garcia

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

Nestor Rios Garcia

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)

Ricardo Alfonso Chavez Vilcapoma

Mi mediana usando la función parImpar():

Ricardo Alfonso Chavez Vilcapoma

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…SI PASA .5 REDONDEA AL SIGUIENTE, SINO AL ENTERO ANTERIOR.

Raymondi Alejandro Ramos Vásquez

→ math.round: redondeo al más cercano
→ math.floor: redondeo hacia el menor
→ math.ceil: redondeo hacia el mayor

Raúl Adolfo Sánchez Rodríguez

Explicación para determinar la mediana de una lista IMPAR

Explicación para determinar la mediana de una lista PAR

Resultado:

Alejandrina Pérez Lugo

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

Patagonia Chic Tech

Aca mi solucion

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

Maria Esther Mendoza Zafra

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

Yerson Felipe Ramirez Garnica

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

Ivan Argote

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

Andrés Schuster

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.

Santiago Quintero

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

Carlos Abad Garcia Perez

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;

Elizabeth Villarruel

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

JORGE ALEXANDER MÚNERA CANABAL

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

Alejandro Renzo Cespedes Rojas

Lo hice de esta forma

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

Victor Mendoza

Aquí mi solución para sacar la mediana en lista par o impar…😃

Ronald Victor Blanco Balboa

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
    }

}

Alejandrina Pérez Lugo

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

Iván Camilo Jaramillo García

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


}

Joserph Camacho

Yo lo resolví de está manera:

Uriel Solis Salinas

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

Roberto Fernández Romero

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!

Alejandro Manzo

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)

Jhon_B

Mi solución usando at():

Laura Roa

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

Sergio Javier Lopez Olivera

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

silfredo mario

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>

Efrén Ruíz Rubio

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

Carlos Alvarez

hace 14 días

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

Carlos Alvarez

hace 14 días

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

Brand Vargas Lis

hace un mes

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; }, []); ```

Andres Montes

hace un mes

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

Andres Montes

hace un mes

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

        const valorDeLaMitad = ((arr.length - 1 ) / 2) + 1

Juan Cortez

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

Juan Diego Cabrera Remírez

**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])) ```

Elizabeth Villarruel

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

Javier Arias

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

Jefferson Nalvarte Miranda

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

Manuel Camacho

hace 3 meses

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

JORGE MANRIQUE CHAVARRO

hace 3 meses

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

Maximiliano Morales

hace 4 meses

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

Erick Yongdae Kim Shin

hace 5 meses

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

Stivenson David Mejia Palacios

hace 5 meses

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

Miguel Negron Garcia

hace 5 meses

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.

Alejandro López Aguilar

hace 6 meses

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

Sebastián Caraballo Marzola

hace 6 meses

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

![](

Santiago Montero

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;

    }
}

CRISTIAN DARIO AGUDELO PORRAS

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!!

Nicolás Colombero

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>

Jose Pedro Garcia Rojas

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

Jose Pedro Garcia Rojas

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

Jamy Morales

Carlos Garcia

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

Luis Paredes

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

Guillermo Ocaña

![](

Manuel Camacho

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

Carlos Guillermo Prituluk Correa

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

    
}

Elkin Morales

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.

PairOrNot Captura de pantalla 2023-03-15 220758.png

Franco Moreira

Math.ceil() redondea para arriba 🚀

Regina Victoria Juárez Miranda

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 */

Rafael Salirrosas Soto

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

Monica Maria Munoz Alzate

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

Johangly Sucre

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

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

Johangly Sucre

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

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

Marcia Hernández

Me tomó como 10 minutos darme cuenta de que mi código no funcionaba porque escribí “lenght” en lugar de “length” 😵🔫

Gualberto Montiel

Fuente: Visto por la Red! 🖥

Elías Yoel Romero Sánchez

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;

Lucas Ignacio Constantinidi

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

}

Felipe Pacheco

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

Leopoldo Martinez

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

Victor Hugo Cruz Carballo

Erick Martin Meza Alonso

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

Camilo Ernesto Hurtado Cataño

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

Miguel Angel Hernandez Colombo

tarde 3 eternidades viendo esta clase!

Diego Fernando Ortiz Gamboa

Mi solución al reto de la clase anterior

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

Omar Gabriel Aguilar Moscoso