Contenido del curso

Introducción

1
¿Ya tomaste el Curso Práctico de JavaScript?
08:20 min

Matemáticas en JavaScript

Porcentajes

Estadística básica

Análisis de salarios

Próximos pasos

30
Toma el Taller Práctico de JavaScript: Videojuegos
04:27 min

Tomar examen

Calculando la moda: objetos a partir de arrays

Comentarios

Josue Cerron Tuesta

student•

Yo lo hice con el método :

const arr2 = [1, 2, 6, 6, 3, 4, 5, 4, 5, 1, 2, 4, 4];

const histogram = array => {
    const obj = new Object();
    array.forEach(element => !obj[element] ? obj[element] = 1 : obj[element]++);
    return obj;
};
console.log(histogram(arr2));

Yordy Leonardo Almonte Ruiz

student•

Bro muchas gracias por tu codigo, lo use como guia e inspiracion para mi solucion (no queria usar ciclo for xD) y lo comprendi en su gran mayoria pero tengo una duda ¿porque arroja nan cuando retira la negacion a !obj[element]?

Henry Alexander Velásquez Rosas

student•

Yo lo hice de esta manera:

// Solución personal 
let number = 14;
let number_list = [1, 10, 14, 3, 24, 14, 10, 35, 13, 14];

function find_number(item){
    return item == number;
}

successful_number = number_list.filter(find_number);
console.log(`Encontramos ${successful_number.length} coincidencias`, successful_number);```

Efrén Ruíz Rubio

student•

Yo lo implementé similar a la clase, pero con operador ternario en vez de if-else, y para mostrar el mayor elemento, con un Math.max convirtiendo el objeto en arreglo:

const calculateModal = (arr) => {
	let obj = {};
	//Se hace un recorrido del array con map
	arr.map((el) => {
		/*
		Por cada elemento en el array, el método retornará dos cosas dependiendo de la condición en el ternario, si el elemento existe en el objeto, se le va a incrementar el contador de dicho objeto, si no, se crea la propiedad elemento en el objeto y se le asigna un 1.
		*/
		el in obj ? (obj[el] += 1) : (obj[el] = 1);
	});
	/*
	La función Math.max() encuentra el elemento más grande de una lista - arreglo, para ello, convertimos el objeto obj en un array y buscamos en todos los elementos del nuevo array con el spread operator (...)
*/
	console.log(Math.max(...Object.values(obj)));
};

Bruno Rosso

student•

gracias por la explicación ! ;)

Eliezer Hernandez

student•

Acá mi solución para determinar la moda, considerando que puede tratarse de bimodal, trimodal, etc.

Resultado bimodal cargado en un array mostrado en consola:

Adjuntaré el código por si quieren probarlo:

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

function listarElementosRepetidos(arrayNum) {
  let objList = new Object();
  arrayNum.forEach((element) => {
    objList[element] = ++objList[element] || 1;
  });
  return objList;
}

function calcularModa(array) {
  const objListNum = listarElementosRepetidos(array);
  const arrayValors = Object.values(objListNum);
  const numeroMayor = Math.max(...arrayValors);
  const arrayObjListNum = Object.entries(objListNum);
  const arrayMatrizModal = arrayObjListNum.filter(
    (elementArrayActual) => elementArrayActual[1] === numeroMayor
  );
  const arrayModaElements = arrayMatrizModal.map((arrayActual) => {
    return arrayActual[0];
  });
  return arrayModaElements;
}

const moda = calcularModa(arrayNum);
console.log(moda);

Ivan Soca

student•

Si quieren saber como Juan mueve toda una linea de codigo para arriba y para abajo sin necesidad de copiar y pegar con el mouse, simplemente tocan la linea de codigo que quieren mover, luego presionan la tecla alt y manteniendo presionado mueven con las flechitas. de nada :))

Gualberto Montiel

student•

Este ejemplo muestra el ordenamiento de un objeto a su propiedad edad.

let people = [
    { name: "John", age: 30 },
    { name: "Mike", age: 25 },
    { name: "Sarah", age: 35 }
];
people.sort(function (a, b) {
    return a.age - b.age;
});
console.log(people);
/* Output:
[
    { name: "Mike", age: 25 },
    { name: "John", age: 30 },
    { name: "Sarah", age: 35 }
]
*/

Santiago Quintero

student•

Fue un poco complejo pero logré sacar la moda del array, aunque me tomó un buen rato jajaja:

No se si es la mejor forma y probablemente en la siguiente clase se verá una forma más sencilla, pero estoy contento con mi solución :D .

function moda (array){
  const ordenarLista = array.sort(ordenar = (a,b)=>a-b)
  const arrayFInal = [];
  const repeticion =[];
  let   resultado ;


console.log(ordenarLista);

ordenarLista.forEach((objeto,index,array)=>{       
  if (objeto == array[index+1] && !arrayFInal.includes(objeto)){
    arrayFInal.push(objeto);
    resultado = array.filter((a)=>{
    return a==objeto;
                                  })
    repeticion.push(resultado.length);    
        }
         
        })

for(let i= 0; i < repeticion.length; i++ ){
  console.log("El número "+arrayFInal[i],"se repite "+repeticion[i]+" veces")
          };
            
    const vecesMayor= Math.max(...repeticion);
    const indexVecesMayor = repeticion.indexOf(vecesMayor);
    console.log("La moda del Array indicado es " + arrayFInal[indexVecesMayor]) 
        }
      


moda([1,2,3,4,4,5,5,5]);

Jeison Esteban Rojas Mora

student•

AGREGAR PROPIEDADES A UN OBJETO

Para agregar un valor podemos usar:

++la clave dentro de comillas y éstas dentro de corchetes++. Esta manera se recomienda cuando la key tiene un nombre de dos o más palabras separadas
++La clave dentro de corchetes SIN COMILLAS++. Esta manera se recomienda cuando la key hace referencia a una variable.
++la sintaxis del punto++. Se recomienda usarla cuando la key tiene un nombre de una sola palabra

Alan Muñoz Badillo

student•

Utilizando varios metodos

const calcularModa = (array) => {
    let conteo = {}
    for(let element of array) {
        if (!conteo[element]) {
            conteo[element] = 0;
        }
        conteo[element] += 1;
    }

    let repticiones= Object.values(conteo).sort((a, b) =>  a - b)
    repticionesMasAltas = repticiones[repticiones.length -1]
    let indexMax = (Object.values(conteo).indexOf(repticionesMasAltas))
    let elementoMasRepetido = Object.keys(conteo)[indexMax]


    return `El elemnto que más se repite es ${elementoMasRepetido} con ${repticionesMasAltas} veces`
}

Frandel Corporan Rodríguez

student•

lo hice con for-of, me parece mas sencillo asi

const list = [1,2,2,3,'a','a','a']
const modaViewer = {}
for(let item of list){
    if(modaViewer[item]){
        modaViewer[item] +=1
    }
    else{

        modaViewer[item] = 1
    }
}

Elizabeth Villarruel

student•

Yo soy más de guardar apuntes en libreta para repasarlos, aquí una mini explicación

Sonia Mendoza

student•

Yo lo resolví así:

let ratings = [10, 10, 10, 10, 10, 5, 7, 7, 7, 7, 3, 3, 2];

//Moda
const calculateMode = () => {
    const warehouseObject = {};
    ratings.forEach((item) => {
        warehouseObject[item] = (warehouseObject[item] ?? 0) + 1;
        //console.log(warehouseObject);
    })
    //console.log(warehouseObject);
    let keyArray = Object.keys(warehouseObject);
    //console.log(keyArray);
    let valueArray01 = Object.values(warehouseObject);
    //console.log(valueArray01);

    let valueArray = Object.values(warehouseObject);
    let orderValueArray = valueArray.sort((a, b) => {
        return a - b;
    });
    let index = valueArray01.indexOf(orderValueArray.at(-1))
    //console.log(index);
    console.log(keyArray[index])
    return keyArray[index];

}

calculateMode(ratings);

Raúl Adolfo Sánchez Rodríguez

student•

FUNCIÓN PARA CALCULAR LA MODA (UNIMODAL, BIMODAL Y MULTIMODAL)

He utilizado los siguientes métodos:

Array Method: Array.prototype.find( )
Array Method: Array.prototype.indexOf( )
Array Method: Array.prototype.filter( )
Array Method: Array.prototype.push( )
Object Method: Object.keys( )
Object Method: Object.values( )

Slides:

Raúl Adolfo Sánchez Rodríguez

student•

Revisemos las características de un Objeto para entender mejor la función para calcular la moda

Mauricio Combariza

student•

Asi los solucione yo

const unique = [];
const moda = [];

lista.forEach((l) => {
  if (!unique.includes(l)) {
    unique.push(l);
  }
});
// console.log(unique);

unique.forEach((e) => {
  let m = lista.filter((f) => f === e);
  moda.push({
    id: e,
    moda: m.length,
  });
});
// console.log(moda);

let max = 0;
let numModa = 0;

moda.forEach((m) => {
  if (m.moda > max) {
    max = m.moda;
    numModa = m.id;
  }
});

console.log(`La moda de la lista es ${numModa} con ${max} repeticiones`);

Alberto Montero

student•

Con el método reduce:

function calcularModa(lista){
    const listaCount = lista.reduce((obj, elemento) => {
        if(!obj[elemento]){
            obj[elemento] = 1;
        }else{
            obj[elemento]++;
        }
        return obj;
    }, {});
    console.log(listaCount)
}

Victor Hugo Cruz Carballo

student•

function calcModa(lista){
  const elementos={};

  for (let i=0; i<lista.length; i++){
    const elemento= lista[i];
    if(elementos[elemento]){
      elementos[elemento] += 1;
      console.log(elementos[elemento]);
    }else{
      elementos[elemento]=1;
      console.log(elementos[elemento])
    }
  }
  console.log(elementos);
}

Gustavo Liendo

student•

Me encantó esta serie de ejercicios, desde un principio me propuse a integrarlos todos con un input del user.

Con un poquito de manipulación del DOM y algunos estilos pudiera mostrarles que tal quedaría, o si quieren que suba el código para que puedan interactuar con el avísenme :)

Diego Fernando Ortiz Gamboa

student•

Con el método de foreach.

const arrayTest2 = [1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,9,9,9,'abc'];
function calculateModa(array) {

    let repeatedElements = {};

    array.forEach(element => {
        const index = element;

        if (repeatedElements[index]) {
            repeatedElements[index] += 1; 
        } else {
            repeatedElements[index] = 1; 
        }
    });
    console.log(repeatedElements);
}

calculateModa(arrayTest2);

Diego Garcia

student•

Mi solución se basó en poder encontrar la moda sin la ayuda de objetos, es un poco más largo, pero se logró, funciona igual.

function moda(array){

    let acum = 0;
    const arrayValues = [...new Set(array)]
    
    const newArray = arrayValues.map((numA)=>{
        let acum = 0;
        array.map( numB => numB == numA ? acum++ : '' )
        return acum;
    });

    newArray.map(item => item > acum ? acum = item : '' );
    const indextMax = newArray.findIndex(item => item==acum);

    return arrayValues[indextMax];
}

Duvan Yesid Becerra Rodríguez

student•

Una forma más resumida (en mi opinión) sería la siguiente:

function listRepeatedElements(list) {
  const listCount = {};

  list.forEach(element => {
    listCount[element] = (listCount[element] || 0) + 1;
  });

  return listCount;
}

const arr2 = [1, 2, 6, 6, 3, 4, 5, 4, 5, 1, 2, 4, 4];

const histogram = array => {
    const obj = new Object();
    array.forEach(element => !obj[element] ? obj[element] = 1 : obj[element]++);
    return obj;
};
console.log(histogram(arr2));

// Solución personal 
let number = 14;
let number_list = [1, 10, 14, 3, 24, 14, 10, 35, 13, 14];

function find_number(item){
    return item == number;
}

successful_number = number_list.filter(find_number);
console.log(`Encontramos ${successful_number.length} coincidencias`, successful_number);```

const calculateModal = (arr) => {
	let obj = {};
	//Se hace un recorrido del array con map
	arr.map((el) => {
		/*
		Por cada elemento en el array, el método retornará dos cosas dependiendo de la condición en el ternario, si el elemento existe en el objeto, se le va a incrementar el contador de dicho objeto, si no, se crea la propiedad elemento en el objeto y se le asigna un 1.
		*/
		el in obj ? (obj[el] += 1) : (obj[el] = 1);
	});
	/*
	La función Math.max() encuentra el elemento más grande de una lista - arreglo, para ello, convertimos el objeto obj en un array y buscamos en todos los elementos del nuevo array con el spread operator (...)
*/
	console.log(Math.max(...Object.values(obj)));
};

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

function listarElementosRepetidos(arrayNum) {
  let objList = new Object();
  arrayNum.forEach((element) => {
    objList[element] = ++objList[element] || 1;
  });
  return objList;
}

function calcularModa(array) {
  const objListNum = listarElementosRepetidos(array);
  const arrayValors = Object.values(objListNum);
  const numeroMayor = Math.max(...arrayValors);
  const arrayObjListNum = Object.entries(objListNum);
  const arrayMatrizModal = arrayObjListNum.filter(
    (elementArrayActual) => elementArrayActual[1] === numeroMayor
  );
  const arrayModaElements = arrayMatrizModal.map((arrayActual) => {
    return arrayActual[0];
  });
  return arrayModaElements;
}

const moda = calcularModa(arrayNum);
console.log(moda);

let people = [
    { name: "John", age: 30 },
    { name: "Mike", age: 25 },
    { name: "Sarah", age: 35 }
];
people.sort(function (a, b) {
    return a.age - b.age;
});
console.log(people);
/* Output:
[
    { name: "Mike", age: 25 },
    { name: "John", age: 30 },
    { name: "Sarah", age: 35 }
]
*/

function moda (array){
  const ordenarLista = array.sort(ordenar = (a,b)=>a-b)
  const arrayFInal = [];
  const repeticion =[];
  let   resultado ;


console.log(ordenarLista);

ordenarLista.forEach((objeto,index,array)=>{       
  if (objeto == array[index+1] && !arrayFInal.includes(objeto)){
    arrayFInal.push(objeto);
    resultado = array.filter((a)=>{
    return a==objeto;
                                  })
    repeticion.push(resultado.length);    
        }
         
        })

for(let i= 0; i < repeticion.length; i++ ){
  console.log("El número "+arrayFInal[i],"se repite "+repeticion[i]+" veces")
          };
            
    const vecesMayor= Math.max(...repeticion);
    const indexVecesMayor = repeticion.indexOf(vecesMayor);
    console.log("La moda del Array indicado es " + arrayFInal[indexVecesMayor]) 
        }
      


moda([1,2,3,4,4,5,5,5]);

const calcularModa = (array) => {
    let conteo = {}
    for(let element of array) {
        if (!conteo[element]) {
            conteo[element] = 0;
        }
        conteo[element] += 1;
    }

    let repticiones= Object.values(conteo).sort((a, b) =>  a - b)
    repticionesMasAltas = repticiones[repticiones.length -1]
    let indexMax = (Object.values(conteo).indexOf(repticionesMasAltas))
    let elementoMasRepetido = Object.keys(conteo)[indexMax]


    return `El elemnto que más se repite es ${elementoMasRepetido} con ${repticionesMasAltas} veces`
}

let ratings = [10, 10, 10, 10, 10, 5, 7, 7, 7, 7, 3, 3, 2];

//Moda
const calculateMode = () => {
    const warehouseObject = {};
    ratings.forEach((item) => {
        warehouseObject[item] = (warehouseObject[item] ?? 0) + 1;
        //console.log(warehouseObject);
    })
    //console.log(warehouseObject);
    let keyArray = Object.keys(warehouseObject);
    //console.log(keyArray);
    let valueArray01 = Object.values(warehouseObject);
    //console.log(valueArray01);

    let valueArray = Object.values(warehouseObject);
    let orderValueArray = valueArray.sort((a, b) => {
        return a - b;
    });
    let index = valueArray01.indexOf(orderValueArray.at(-1))
    //console.log(index);
    console.log(keyArray[index])
    return keyArray[index];

}

calculateMode(ratings);

const unique = [];
const moda = [];

lista.forEach((l) => {
  if (!unique.includes(l)) {
    unique.push(l);
  }
});
// console.log(unique);

unique.forEach((e) => {
  let m = lista.filter((f) => f === e);
  moda.push({
    id: e,
    moda: m.length,
  });
});
// console.log(moda);

let max = 0;
let numModa = 0;

moda.forEach((m) => {
  if (m.moda > max) {
    max = m.moda;
    numModa = m.id;
  }
});

console.log(`La moda de la lista es ${numModa} con ${max} repeticiones`);

function calcularModa(lista){
    const listaCount = lista.reduce((obj, elemento) => {
        if(!obj[elemento]){
            obj[elemento] = 1;
        }else{
            obj[elemento]++;
        }
        return obj;
    }, {});
    console.log(listaCount)
}

function calcModa(lista){
  const elementos={};

  for (let i=0; i<lista.length; i++){
    const elemento= lista[i];
    if(elementos[elemento]){
      elementos[elemento] += 1;
      console.log(elementos[elemento]);
    }else{
      elementos[elemento]=1;
      console.log(elementos[elemento])
    }
  }
  console.log(elementos);
}

const arrayTest2 = [1,2,3,4,5,6,7,8,9,9,9,9,9,9,9,9,9,9,'abc'];
function calculateModa(array) {

    let repeatedElements = {};

    array.forEach(element => {
        const index = element;

        if (repeatedElements[index]) {
            repeatedElements[index] += 1; 
        } else {
            repeatedElements[index] = 1; 
        }
    });
    console.log(repeatedElements);
}

calculateModa(arrayTest2);

function moda(array){

    let acum = 0;
    const arrayValues = [...new Set(array)]
    
    const newArray = arrayValues.map((numA)=>{
        let acum = 0;
        array.map( numB => numB == numA ? acum++ : '' )
        return acum;
    });

    newArray.map(item => item > acum ? acum = item : '' );
    const indextMax = newArray.findIndex(item => item==acum);

    return arrayValues[indextMax];
}

Introducción

¿Ya tomaste el Curso Práctico de JavaScript?

Matemáticas en JavaScript

Fórmulas matemáticas en JavaScript

Math en JavaScript

Reto: altura de un triángulo

Playground: Calcula la Altura de un Triángulo Escaleno

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Playground: Encuentra el ID

Estadística básica

Qué es promedio, moda y mediana

Calculando el promedio

Método reduce

Calculando la mediana en una lista impar

Calculando la mediana en una lista par

Método sort