Calculando la moda: arrays a partir de objetos

La moda es el término que aparece la mayor cantidad de veces dentro de un conjunto de datos.

Si hay más de un término que aparece la mayor cantidad de veces, entonces no hay moda.

Podemos considerar entonces:

const listaMaxNumber = listaOrdenada[listaOrdenada.length - 1];
const listaMaxNumberAnterior = listaOrdenada[listaOrdenada.length - 2];

Para finalmente:

if( listaMaxNumber[1] === listaMaxNumberAnterior[1] ) {
	const moda = 'No hay moda';
} else {
	const moda = listaMaxNumber[0];
}
return moda;

Les comparto mi humilde función para calcular la moda 😄

function calcularModa(lista)
{
    const obj = {};
    lista.forEach((e) => !obj[e] ? obj[e] = 1 : obj[e]++);

    let array = Object.entries(obj);
    array.sort((a,b) => b[1] - a[1]);

    let moda = Number(array[0][0]);

    return moda;
}

Investigue y existen tres tipos de modas dependiendo la cantidad de valores que tengan el mismo número de repeticiones máximas.

Tipos de moda estadística

La moda estadística se clasifica de la siguiente manera:

1. Moda unimodal: tipo de moda estadística en la cual un único valor se repite el mayor número de veces dentro de un conjunto de datos.

2. Moda bimodal: tipo de moda estadística en la que 2 valores diferentes presentan el mismo número máximo de repeticiones, dentro de un conjunto de datos.

3. Moda multimodal: tipo de moda estadística en la que 3 o más valores diferentes presentan el mismo número máximo de repeticiones dentro de un conjunto de datos.

Fuente de información:

• Moda estadística

• Moda (estadística)

Utilice esta función para imprimir múltiples modas:

Done! usando arrow functions y entendiendo que cada objeto paso a ser un elemento del array, se puede acceder a cada elemento de cada array, así seleccionando el “1” que sería el segundo, es decir el value, es decir el valor que nos interesa para saber el elemento más repetido:
.
.
.

let list = [2, 7, 4, 7, 2, 4, 1, 7, 3, 8];


function findMode(arr) {
    let objectList = {};

    for (let i = 0; i < arr.length; i++) {
        let element = arr[i];
        if (objectList[element]) {
            objectList[element] += 1;
        } else {
            objectList[element] = 1;
        }
    }

    const objectArray = Object.entries(objectList);

    const orderObjectArray = objectArray.sort((a, b) => a[1] - b[1]);
    return orderObjectArray;
}
findMode(list);

NOTAS DE LA CLASE

utilizando la segunda casilla del array [1]

valorAcumulado[1] - nuevovalor[1]

Despues de ver esta clases por quinta vez al fin entendi…
Siempre es bueno complementar las clases con lecturas de la documentacion oficial

Cómo ordena un array bidimensional

Ejemplo con emojis, y una manera más corta, pero no por eso más fácil de comprender.

const emojis = 
['🍔','🌭','🌭','🍟','🥞','🥪','🥙','🍣','🍕','🍕','🌭']

function mode(arr){
  return arr.sort((a,b) =>
      arr.filter(v => v===a).length
      - arr.filter(v => v===b).length
  ).pop();
}

console.log(mode(emojis)); 
//mode = '🌭'

Comparto ambas soluciones (1ra que hice antes de ver las clases y la segunda con la implementación del Object.entries()

const moda = (array) => {
	let storage = {};
	let answerModa;
	for (let number of array) {
		//storage[number]-->key
		!storage[number] ? (storage[number] = 1) : storage[number]++;
	}
	let max = Math.max(...Object.values(storage));
	for (let key in storage) {
		if (storage[key] == max) {
			answerModa = key;
		}
	}
	return `La moda es ${answerModa} y se repite ${max} veces`;
};



const moda1 = (array) => {
	let storage = {};
	let answerModa;
	for (let number of array) {
		//storage[number]-->key
		!storage[number] ? (storage[number] = 1) : storage[number]++;
	}
	let arrayOfArrys = Object.entries(storage);
	let order = arrayOfArrys.sort((a, b) => a[1] - b[1]);
	answerModa = order[order.length - 1];
	return `La moda es ${answerModa[0]} y se repite ${answerModa[1]} veces`;
};

Mi solución:

código:

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 ordenarListaBidimensional(arr) {
  const arrayObjListNumNewOrder = arr.sort(
    (element1, element2) => element1[1] - element2[1]
  );
  return arrayObjListNumNewOrder;
}

function calcularModa(array) {
  const objListNum = listarElementosRepetidos(array);
  const arrayObjListNum = Object.entries(objListNum);
  const arrayObjListNumNewOrder = ordenarListaBidimensional(arrayObjListNum);
  const arrayMatrisModa = arrayObjListNumNewOrder.filter(
    (element) =>
      element[1] ===
      arrayObjListNumNewOrder[arrayObjListNumNewOrder.length - 1][1]
  );
  const arrayModaValors = arrayMatrisModa.map((element) => {
    return element[0];
  });
  return arrayModaValors;
}

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

esta fue mi solucion

function ordenarLaListaBidimesional (arr) {
    arr.sort(function(a, b) {
        return a[1] - b[1]
    })

}

Comparto mi solución para incluir el caso de que haya más de una moda:

const numeros = [6, 6, 5, 6, 2, 6, 6, 8, 9, 5, 1, 4, 7, 6, 3, 6, 3, 3, 3, 3, 3, 3];
var repeticiones = {};
var modas = {};


function encontrarModa() {
    for (var numero of numeros) {
        if (repeticiones[numero]) {
            repeticiones[numero] += 1;
        }else{
            repeticiones[numero] = 1;
        }
        if (repeticiones[numero] == Math.max.apply(null, Object.values(repeticiones))) {
            masRepetido = numero;
            vecesRepetido = repeticiones[numero];
            modas[masRepetido] = vecesRepetido;
        }}  
        if (Object.keys(modas).length==1) {
            console.log('El numero que más veces se repite es el '+ masRepetido + ' unas ' + vecesRepetido + ' veces.')
        }else{
            console.log('Los numeros que mas se repiten son ' + '(' + Object.keys(modas).length + ')'+ ': ' + Object.keys(modas) + ' unas ' + vecesRepetido + ' veces cada uno.')
        };
        };
encontrarModa();

Reto cumplido de arreglar arrays bidimiensionales:

noentendí

Esta es mi solución en caso exista mas de una moda.

function moda(arr){
    const objarr = {};
    arr.forEach(element => {
        if(objarr[element]){
            objarr[element]+=1;
        }else{
            objarr[element]=1;
        }
    });
    const objlist = Object.entries(objarr);
    let newarr = objlist.sort((acumulado,valor)=>valor[1]-acumulado[1]);
    const newe = newarr[0][1];
    //esto por si hay mas de 1 moda
    newarr.forEach(element=>{
        if(newe==element[1]){
            console.log("La moda es " + element[0]);
        }
    })
}

Dejo el código del profe con su explicación:

let number_list = [20,20,30,30,10,10,10,10,10,80,80,80,80];

function moda(list){
    let new_list = {};

    for(let i=0; i<list.length; i++){
        let item = list[i];

        new_list[item] ? new_list[item] += 1 : new_list[item] = 1;
    }
    console.log('Array', number_list);
    console.log('Objeto', new_list);

    // De objeto a array de arrays 
    let array_list = Object.entries(new_list);
    console.log('Array de arrays', array_list);

    let sort_by_value = sort_two_dimensional_list(array_list, 1);
    console.log('Ordenado por valor',sort_by_value);

    let find_moda = sort_by_value[sort_by_value.length - 1];
    console.log('Find moda', find_moda);
    let found_mode = find_moda[0];
    console.log('Found moda', found_mode);
}

moda(number_list);

function sort_two_dimensional_list(unordered_list, i){
    function sort_list(a,b){
        return a[i] - b[i];
    }

    let sorted_list = unordered_list.sort(sort_list);
    return sorted_list;
}

Explicación:
Este es un código de JavaScript que encuentra la moda (el valor que aparece con mayor frecuencia) en una lista de números.

Primero, define una lista de números llamada “number_list”.

Luego, se define una función llamada “moda” que toma como parámetro una lista.

Dentro de la función, se crea un objeto llamado “new_list” que se usará para contar la cantidad de veces que aparece cada número en la lista.

Se recorre la lista con un bucle “for” y para cada número se verifica si ya está en el objeto “new_list”. Si es así, se incrementa la cuenta en 1, y si no, se agrega al objeto con una cuenta inicial de 1.

Después de crear el objeto “new_list”, se convierte en un “array de arrays” (cada subarray tiene dos elementos: el número y su cuenta) utilizando el método “Object.entries()”.

Luego, se utiliza la función “sort_two_dimensional_list” para ordenar el “array de arrays” por el valor de la cuenta en orden ascendente.

Finalmente, se retorna el último elemento del “array de arrays” ordenado, que corresponde a la moda, y se guarda en la variable “found_mode”.

La función “sort_two_dimensional_list” es una función auxiliar que toma dos parámetros: una lista bidimensional y el índice de la columna por la que se desea ordenar la lista. Esta función utiliza la función “sort” para ordenar la lista bidimensional por la columna especificada y retorna la lista ordenada.

Aquí mi solución al problema propuesto teniendo en cuenta la existencia de varios términos con el mismo número de apariciones:

18. Calculando la moda: arrays a partir de objetos

Moda: valor que se repite mas veces (cualquier dato)

// Pasos 
// 1. Crear un  objeto que tenga el conteo de números existentes
// 2. Convertir objeto a array de arrays 
// 3. Ordenar array de arrays por value (indice 1)

let number_list = [1, 10, 14, 3, 24, 14, 10, 35, 13, 14];
let objet = {};
let array_list;
let sorted_array;  

function moda(array){
    for (let i = 0; i < array.length; i++) {
        let item = array[i];
        
        objet[item] ? objet[item] += 1 : objet[item] = 1;

        array_list = Object.entries(objet);
        sorted_array = array_list.sort((a, b) => a[1] - b[1]);
    }
}

moda(number_list)

console.log(objet);
console.log(array_list);
console.log(sorted_array);
console.log(sorted_array[sorted_array.length - 1][0]);

Asi lo comprimi yo:

• arr[i] .- Es la variable element, solo que en vez de crearla primero y luego usarla, coloco su valor directamente en la condición con el operador ternario.

• Object.entries(arrCount) .- Es el objeto arrCount convertido en array, la función sortTwoDimensionalList ya lo toma como un array.

• return arr.sort((a, b) => a[i], b[i]) .- Retorna directamente el resultado de ordenar el array , respecto al indice pasados como argumentos. Procedimiento en una función flecha.

Tambien podemos imprimir los console.log juntos en sintáxis de objeto {}.

Mi solución ✍🏻

function obtenerModa(lista) {
  const listaCount = {};

  lista.map((elemento) => {
    if (listaCount[elemento]) {
      listaCount[elemento] += 1;
    } else {
      listaCount[elemento] = 1;
    }
  });

  const listaArray = Object.entries(listaCount).sort((a, b) => a[1] - b[1]);

  const moda = listaArray[listaArray.length - 1];

  return moda;
}

const numbersArray = [40, 30, 10, 50, 20, 30, 10, 30];

function calcularModa(numbers) {
const listCount = {};
for (const element of numbers) {
listCount[element] ? (listCount[element] += 1) : (listCount[element] = 1);
}
const listSorted = Object.entries(listCount).sort((a, b) => b[1] - a[1]);
return listSorted[0][0];
}

console.log("La moda de esta lista es: " + calcularModa(numbersArray));

Solución

Entonces como los ordenamos usando solo los valores de los values, pues de igual manera que usamos el método sort, pero yendo al segundo nivel, así queda:

let arraydesordenado = [
  [ '1', 7 ],
  [ '2', 1 ],
  [ '3', 1 ],
  [ '4', 2 ],
  [ '5', 7 ],
  [ '6', 1 ],
  [ '8', 2 ],
  [ '9', 2 ]
]
let arrayOrdenado = arraydesordenado.sort((a,b) => a[1] - b[1])
    console.log(arrayOrdenado);

[
  [ '2', 1 ],
  [ '3', 1 ],
  [ '6', 1 ],
  [ '4', 2 ],
  [ '8', 2 ],
  [ '9', 2 ],
  [ '1', 7 ],
  [ '5', 7 ]
]

1. Tenemos el siguiente arreglo:

const numbers3 = [1,1,2,3,5,5,5,5,6,9,9,8,8,1,4,4,5,5,5,1,1,1,1]

1. Lo trasformamos en un objeto que tenga al número(key) y las veces que se repite(value):

{ '1': 7, '2': 1, '3': 1, '4': 2, '5': 7, '6': 1, '8': 2, '9': 2 }

1. Usamos Object.entries() para obtener un array de dos dimensiones:

[
  [ '1', 7 ],
  [ '2', 1 ],
  [ '3', 1 ],
  [ '4', 2 ],
  [ '5', 7 ],
  [ '6', 1 ],
  [ '8', 2 ],
  [ '9', 2 ]
]

Entonces como los ordenamos usando solo los valores de los values, pues de igual manera que usamos el método sort, pero yendo al segundo nivel, así queda:

let arrayOrdenado = arraydesordenado.sort((a,b) => a[1] - b[1])
    console.log(arrayOrdenado);

[
  [ '2', 1 ],
  [ '3', 1 ],
  [ '6', 1 ],
  [ '4', 2 ],
  [ '8', 2 ],
  [ '9', 2 ],
  [ '1', 7 ],
  [ '5', 7 ]
]

function calcularModa(lista) {
  // Creamos un objeto para almacenar la frecuencia de cada número
  var frecuencias = {};
  
  // Iteramos sobre la lista y almacenamos la frecuencia de cada número en el objeto
  for (var i = 0; i < lista.length; i++) {
    if (lista[i] in frecuencias) {
      frecuencias[lista[i]]++;
    } else {
      frecuencias[lista[i]] = 1;
    }
  }
  
  // Encontramos el número con la frecuencia más alta
  var moda = null;
  var maxFrecuencia = 0;
  
  for (var numero in frecuencias) {
    if (frecuencias[numero] > maxFrecuencia) {
      moda = numero;
      maxFrecuencia = frecuencias[numero];
    }
  }
  
  return moda;
}

El profesor hizo una solución bien larga…pero como siempre se dice en programación, no es replicar lo que el profesor hace, sino entender la lógica y llegar al resultado y para ello hay distintos caminos, así que si no entiendes mucho lo del profe, no trates de replicar, sino de intentar hacerlo con tu propio código hasta llegar al resultado.

Mi forma de resolver el problema

const lista = [1,4,2,3,1,5,4,3,2,6,7,5,1,2,3,4,4,4,4];
const obj = {}
for(let i = 0; i <= lista.length -1; i++){
          const e = lista[i];
          const verificar = (Boolean(obj[e])) ? obj[e] += 1 : obj[e] = 1;
}
// console.log(obj);

// Object.entries(obj);
console.log();
const arrList = Object.entries(obj);
console.log(arrList)
const cosita = arrList.sort((a,b) => b[1] - a[1]);
// console.log(arrList[3][1]);
console.log(cosita);

Mi aporte

let numeros =['casa','apt','condo', 'condo','apt', 'apt','casa','casa','casa','apt','apt'];
function calcularModa(numeros){
let cuenta = numeros.reduce((acumulador, valorActual) => {
    if (acumulador[valorActual]) {
      acumulador[valorActual]++;
    } else {
      acumulador[valorActual] = 1;
    }
    return acumulador;
  }, {});
const listaArray = Object.entries(cuenta)
listaArray.sort(function(a, b) {
    return b[1] - a[1];
  });
  console.log(listaArray[0][0])};
calcularModa(numeros)

Estuvo interesante esta clase principalmente porque aprendí mucho. Esta es mi solución, la función Math.max() la aprendí aquí de mis demás compañeros, antes de eso había hecho una función medio locochona y muy antigua para sacar el máximo valor (en esencia fue reccorrer todo el arreglo hasta que hubiera un valor mayor al actual).
Esta clase fue desempolvar cosas que creía haber olvidado

function trend(array){
//Represents a "hash table"
 let hash = { } ;

 //Create an "hash table" so it can be displayed the times that an element repeats along an array
 array.forEach(function(element){
    !hash[element] ? hash[element] = 1 : hash[element] += 1;
 });

 /*Convert hash object into an array in which each element is an array of two elements represented by key and value*/
 let array_hash = Object.entries(hash);

 //getting the max value of hash object.
 let max_value = Math.max( ...Object.values(hash) );
 
 //Getting an array of elements that contains max value 
 let array_trend = array_hash.filter(function(value){
    if(max_value === value[1])
        return value;
 });

 //Checking out if the output array length is different than the original array length. if it is true it means that trend exists if it is false it means that trend does not exists.
 return array_trend.length !== array.length ? array_trend : [];
}

Así quedo mi función, la hice nutriendola de varios aportes de esta sección

function identificarModa(array){
    const listaObjeto = {};
    array.forEach((e) => !listaObjeto[e]? listaObjeto[e]=1: listaObjeto[e]++);
    const arreglo = Object.entries(listaObjeto).sort((a,b)=> a[1]-b[1])
    const datoU = arreglo[arreglo.length-1][1]
    const datoP = arreglo[arreglo.length-2][1]
    return datoU==datoP?  'No hay moda': arreglo[arreglo.length-1]
    
}

listaArray.sort((a,b)=> b[1]-a[1])

Mi forma de hacerlo (siguiendo al profe jeje)

const arr = [1, 10, 14, 3, 24, 14, 10, 35, 13, 14];

function calcModa(list) {
    const counter = {};
    for (let i = 0; i < list.length; i++) {
        const num = list[i];
        counter[num] ? (counter[num] += 1) : (counter[num] = 1);
    }
    const arrayValues = Object.entries(counter);

    const sortedArray = arrayValues
        .sort((previous, current) => previous[1] - current[1])
        .reverse();
    console.log(sortedArray[0][0]);
}
calcModa(arr);

Esta fue mi solución tratando de simplificar todo con lo visto en la clase, y a las personas que ven esos comentarios con código muy avanzado e incomprensible o al menos lo es para mi, no se preocupen y miren todo lo que hemos aprendido, yo hace 1 mes no entendía los condicionales, ahora entiendo de Arrays bidimensionales jajajaaj, con tiempo entenderemos todo, mucha suerte! .

Posdata: Si mi código tiene algo mal o lo podria mejorar de alguna forma agradecería los consejos.

Así es como yo solucioné el ordenar listas

function OrdenarListaBidimensional(listaCount){
    const listaOrdenada = listaCount.sort((a, b) => 
      a[1] - b[1] ) 
      return listaOrdenada
};

entendí toda la clase cuando dijo ‘El Quinto Elemento’ jaja

Mi solución teniendo en cuenta todos los escenarios posibles (puede que no) 😀

1. Si la muestra tiene mas de 2 valores con la misma maxima frecuencia absoluta, se dice que no la muestra no tiene moda o no tiene utilidad
2. Todos los datos tienen la misma maxima frecuencia absoluta

function calcularModa(arr){
    const objContador=arr.reduce((obj,item)=>{
        if(!obj[item]){obj[item]=1}
        else{obj[item]=obj[item]+1}
        return obj;
    },{});

   const arrContador=Object.entries(objContador)
   const arrOrdenadoPorValues=[...arrContador].sort((a,b)=> b[1] - a[1]);
   let arrModa=[];
   arrModa.push(arrOrdenadoPorValues[0][0])
    for (let i = 1; i < arrOrdenadoPorValues.length; i++) {
        if(arrOrdenadoPorValues[i][1]>=arrOrdenadoPorValues[0][1]){
            arrModa.push(arrOrdenadoPorValues[i][0]);    
        }
    }
    if(arrModa.length>2 || arrModa.length===arr.length){
        return console.log('Distribucion considerada sin moda por alguna de estas causas: 1. todos los datos tienen la misma frecuencia 2. hay mas de 2 valores con la misma frecuencia maxima absoluta')
    }

    return arrModa
}

const list = [2, 4, 4, 5, 6, 9, 6, 6, 8, 1, 4, 5, 6, 7, 1 ,0]


function findMean(arr) {
    const moda = {}
    
    arr.forEach(e => {
        moda[e] ? moda[e] += 1 : moda[e] = 1
    })
    
    //convertimos objeto en array bidimensional
    let sortedArr = Object.entries(moda)
    
    sortedArr.sort(sortBidimensionalArr)
    
    return sortedArr[0][0]
}

function sortBidimensionalArr(a, b) {
    return b[1] - a[1];
}

Mi Solucion a estos ejercicios

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 btnCalcularPromedio = document.querySelector("#btnCalcularPromedio");
const btnCalcularMediana = document.querySelector("#btnCalcularMediana");
const btnCalcularModa = document.querySelector("#btnCalcularModa");
btnCalcularPromedio.addEventListener("click", calcularPromedio);
btnCalcularMediana.addEventListener("click", calcularMediana);
btnCalcularModa.addEventListener("click", calcularModa);

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;
  arrSueldos.sort((a,b)=> a-b) // Aqui es donde ordeno el arreglo
  console.log(arrSueldos)
  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]}`;
  }
}

function calcularModa() {
    const cuenta = {}
    
    arrSueldos.forEach((sueldo) => {
        if (cuenta[sueldo]) {
            cuenta[sueldo] += 1
        } else {
            cuenta[sueldo] = 1
        }
    })
    const cuentaArr = Object.entries(cuenta)
    
    cuentaArr.sort((a,b) => b[1] - a[1])
    
    if (cuentaArr[0][1] === cuentaArr[1][1]) {
        moda.innerHTML = `No hay moda`
    } else {
        moda.innerHTML = `La moda es: ${cuentaArr[0][0]} y la cantidad de veces fue ${cuentaArr[0][1]}`
    }
}

Me quedò la duda sobre que sucederìa si existe mas de un elemento que con el mayor numero de repeticiones e investiguè que puede haber una moda bimodal y una moda multimodal, por lo que agregue codigo extra para estos casos. Dejo mi aporte

// casos de prueba

miListaModa = [7, 10, 30, 7, 10, 28, 7, 10, 0, 7, 8, 7]; // 1 moda

frutasVendidas = ["fresas", "melones", "uvas", "fresas", "manzanas", "uvas", "duraznos", "uvas", "limones", "fresas"]; // Bimodal

magnitudSismos = [3.5, 2.9, 3.1, 2.7, 3.6, 2.7, 2.8, 2.9, 2.7, 2.7, 2.9, 3.1, 3.1, 2.9, 2.6, 3.2, 3.1]; //Multimoda


function calcModa (lista) {
    
    const objFindModa = {}; 
    // Crea un objeto con los elementos de la lista, donde key = elemento, value = numero de veces que se repite
    
    for (let i = 0; i < lista.length; i++ ) {
        
        let keyFindModa = lista[i];
        
        if(keyFindModa in objFindModa) {
            
            objFindModa[keyFindModa] += 1;
        
        } else {
            
            objFindModa[keyFindModa] = 1;
        }
    }

    const arrFindModa = Object.entries(objFindModa);
    // Crea un array bidimensional con las propiedades del objeto [key][value]
    
    const arrFindModaOrder = arrFindModa.sort( ( a, b ) => b[1] - a[1] );
    // ordena el array de mayor a menor por la segunda posiciòn del arreglo bidimensional [1] ò [value] que en este caso es el numero de veces que se repite el elemento 

    const arrayModa = arrFindModaOrder.filter( ( a => a[1] == arrFindModaOrder[0][1]  )  );
    // evalua si existe mas de 1 elemento con el mismo valor del que mas veces se repite 

    if ( arrayModa.length == 1) { // para el caso de 1 moda
      
      console.log(`La moda de los datos ingresados es: ${arrayModa[0][0]}; con una aparicion de ${arrayModa[0][1]} veces`);

      return 
    }

    else if ( arrayModa.length == 2) { // para el caso bimodal
      
      console.log(`Los datos ingresados presentan una moda bimodal: ${arrayModa[0][0]} y ${arrayModa[1][0]}; con una aparicion de ${arrayModa[0][1]} veces`);
      
      return 
    }

    else if ( arrayModa.length > 2) { // para el caso multimodal

      console.log(`Los datos ingresados presentan una moda multimodal, con una aparicion de ${arrayModa[0][1]} veces para los siguientes elementos: `);

      for (let i = 0; i < arrayModa.length; i ++) {

        console.log(`${arrayModa[i][0]}`);        
      }      

    }
       
}

calcModa(miListaModa);

Mi solucion:

function ordenarListaBidimensional(listaDesordenada){
    const lista = listaDesordenada.sort((a, b) => b[1] - a[1]);
    return lista;
}

function obtenerModa(lista){
    const listaCount = {};

    for (let i = 0; i < lista.length; i++) {
        const element = lista[i];
        if(listaCount[element]){
            listaCount[element] += 1;
        }else{
            listaCount[element] = 1;
        }
    }

    const listaArray = Object.entries(listaCount);
    const listaArrayOrdenada = ordenarListaBidimensional(listaArray);

    const moda = listaArrayOrdenada[0][0];
    const modaCount = listaArrayOrdenada[0][1];
    const modaCount2 = listaArrayOrdenada[1][1];

    if(modaCount == modaCount2){
        return "No hay moda porque hay mas de un termino que aparece la mayor cantidad de veces"
    }
    console.log(`La moda es: ${moda}, porque aparece: ${modaCount} veces`);
}

Lo resolví cambiando esto en la función:

Y recibiendo como argumento una lista bidimensional hace el ordenamiento correctamente:

 Ejemplo: const obj = {a:1, b:2, c:3}

Object.keys transforma un objeto a un array con todas las llaves (nombres) de las propiedades del objeto. (3) ["a", "b", "c"]

Object.values transforma un objeto a un arrar de los valores de las llaves. (3) [1, 2, 3]

Object.entries transforma un objeto a un array de arrays. 
    (3) [Array(2), Array(2), Array(2)] esto es:
    0: (2) ["a", 1]
    1: (2) ["b", 2]
    2: (2) ["c", 3]

Un array bidimensinal viene siendo un array de otro array.

Esta imagen sirve de guía para la resolución del ejercicio
![](

También me ayudo a dar solución hacer el engine del sort, simplemente accediendo al elemento con el valor de las repeticiones.

    function sortEngineTwoElements(a, b) {
        return a[1] - b[1] ;
    };

Mi solución a la clase

//! Calculation of the mode with sort and object manipulation

const arrayTest3 = [1,2,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,6,7,8,9,9,9,9,9,9,9,9,9,9,'abc'];

function calculateMode(array) {
    // Calculation of the repeated elements.
    let newObject = {}
    array.forEach(element => {
        (newObject[element]) ? newObject[element] += 1 : newObject[element] = 1 ;  
    });

    // Conversion to array.
    const arrayTransformed = Object.entries(newObject);

    // Calculation sort by length.
    function sortEngineTwoElements(a, b) {
        return a[1] - b[1] ;
    };
    const sortedArray = arrayTransformed.sort(sortEngineTwoElements);
    
    // Return of the mode.
    const mode = sortedArray[sortedArray.length - 1];
    console.log(`El valor de la moda es, ${mode[0]}`);
} 

calculateMode(arrayTest3);

//! End of the calculation of the mode with sort and object manipulation

Holi, viendo varias soluciones de la comunidad, hice la mía un poco mas compacta y (creo yo) mucho mas legible. Todo esto tomando en cuenta que las modas pueden ser multi modales, bimodales o normales como se explica en el aporte de Walter Omar.

Acá mi solución:

Aquí esta mi función para calcular cualquier tipo de moda, me demore todo el día 😅 pero al fin lo logre!!!

function Moda(lista){
    let objLista = {};

    lista.map(item => {
        objLista[item] ? objLista[item] += 1 : objLista[item] = 1
    })

    let orderArray = Object.entries(objLista).sort((a,b)=> a[1] - b[1])

    let modaEst = orderArray[orderArray.length - 1]

    let allModa = orderArray.filter(item => item[1] === modaEst[1])

    if(allModa.length === 1){
        return `La moda estadistica es: ${modaEst[0]}, se repite ${modaEst[1]} veces`
    }
    else if(allModa.length === 2){
        return `La lista es bimodal: el ${allModa[0][0]} y el ${allModa[1][0]} se repiten ${allModa[0][1]} veces`
    }
    else if(allModa.length >= 3){
        let multi = allModa.map(item => item[0])
        return `La lista es multimodal: los elementos ${multi}, se repiten ${allModa[0][1]} veces`
    }
    else{
        return `no hay moda`
    }
}

Usando el método sort():

const arr4 = [
    ['a', 2],
    ['c', 4],
    ['b', 1],
];
const sorted = arr4.sort((a, b) => a[1] - b[1]);
console.log(sorted); //Expected output [ [ 'b', 1 ], [ 'a', 2 ], [ 'c', 4 ] ]

const numbers = [10, 2, 10, 3, 10, 2, 3, 2]

//ordenamos un array de array
function orderListBi(listBi) {
  //cómo a y b son arrays, le indicamos que los ordene en base al segundo index
  const sortArrayBi = listBi.sort((a, b) => a[1] - b[1]);
  return sortArrayBi
}


/**
 * Creamos un objeto donde guardar los numeros
 * Recorremos el array
 * Obtenemos el número del array
 * Si ese número existe dentro del obj, entonces sumale 1
 * SI no existe, guardalo en el obj con el valor 1
 */
function repeatNumber(list) {
  let numbersArray = {}
  list.map(item => {
    if (numbersArray[item]) {
      numbersArray[item] = numbersArray[item] + 1;
    } else {
      numbersArray[item] = 1;
    }
  })
  return numbersArray;
}

function getModa(list) {
  const preview = repeatNumber(list);
  //Convertimos el objeto con los numeros repetidos en un array de arrays
  const previewArray = Object.entries(preview)
  //Ordenamos ese Array de arrays en base a los num repetidos de menor a mayor
  const orderList = orderListBi(previewArray)
  // sacamos la moda, que es el ultimo número porque se repite más
  const moda = orderList[orderList.length - 1]
  return moda[0]
}



console.log(`la moda de [${numbers}] es ${getModa(numbers)}`)

Esta es mi solución con algunas cosas algo diferentes a lo que se desarrollo en la clase:

function calcularModa(array) {
let objArray = array.reduce((obj,item) => {(!obj[item]) ?obj[item] = 1 :obj[item] +=1 ;return obj},{})

let freq = Object.entries(objArray);

let modaFreq = 0;
let moda
for (let i = 0; i < freq.length; i++) {
    if (freq[i][1] > modaFreq) {
        modaFreq = freq[i][1];
        moda = freq[i][0]
    }
}
return moda

}

Obviando el paso del ordenamiento, se puede usar un ciclo for para obtener la moda por medio de comparaciones directas.

Post data: Los trucos de “array.lenght - 1” e ingresar al elemento del array dentro del método sort son muy útiles.

function runMode(array) {
    let countObject = {};
    let mode = [0, 0];

    for(let i = 0; i < array.length; i++) {
        const element = array[i];

        if(countObject[element]) {
            countObject[element] += 1;
        } else {
            countObject[element] = 1;
        }
    }

    let valuesAmount = Object.entries(countObject);
    for(let i = 0; i < valuesAmount.length; i++) {
        let actualValue = valuesAmount[i];

        if(actualValue[1] > mode[1]) {
            mode = actualValue;
        }
    }

    return mode[0];
}
const modeArray = [25, 201, 25, 201, 65, 10, 10, 14, 25, 25, 25, 25];
console.log('Imprimiendo la moda: ', runMode(modeArray));

Elegí usar for... in para recorrer las propiedades y valores del objeto que creamos

function mode(array) {
    
    const listaObj = {};

    array.forEach(e => {
        listaObj[e] ? listaObj[e] += 1 : listaObj[e] = 1;
    });

    let propiedad = null;
    let numMayor = 0;
    for(prop in listaObj) {
        if(listaObj[prop] > numMayor) {
            numMayor = listaObj[prop];
            propiedad = prop;
        }
    }

    return propiedad;
}

Inspirado en el aporte del compañero

function mode(array){
    let obj=array.reduce((obj,item)=>{
        if (!obj[item]){
            obj[item]=1;
        }else{
            obj[item]=obj[item]+1;
        }
        return obj;
    },{})
    ///convertir el array en un array de arrays
    const listArray= Object.entries(obj);
    const listArrayOrderer= listArray.sort((a,b)=>a[1]-b[1])///Entro al indice 1, al segundo elemento  [ '1', (este) ] y ordeno por el elemento.
    const latestNumber=listArrayOrderer[listArrayOrderer.length-1];
    const penultimateNumber=listArrayOrderer[listArrayOrderer.length-2];
    if(latestNumber[1]!=penultimateNumber[1]){
        console.log('La moda es:', latestNumber[0])
    }else{
        console.log('No existe Moda')
    }
}
mode([1,6,3,8,5,9,7,7]);

Este curso me está costando horrores pero poco a poco voy avanzando

const fashion = (array) => {
    const list_count = {};

    for(let i = 0; i < array.length; i++){
        const item = array[i];

        if(list_count[item]){
            list_count[item] += 1;
        }else{
            list_count[item] = 1;
        }

    }

    const array_list = Object.entries(list_count);

    array_list.sort((a,b) => {
        return b[1] - a[1];
    });

    return array_list[0][0];

}

numbers = [1,9,7,7,5,5,7,5,5]
console.log(fashion(numbers));

Espero esto les sirva a aquellos que estaban tan confundidos como yo jasdjasd.

// Creamos un objeto vacío que recibirá la cantidad de veces que se repite un elemento en el array que está recibiendo como argumento la función calcularModa.

let objetoRecipiente = {};

// Creamos la función calcular moda y le damos como parámetro el array del cual queremos obtener la moda.

function calcularModa(array){ 

// Creamos un ciclo for que recorrerá todo el array.
    for (let i = 0; i < array.length; i++) {

        // Fijamos que la variable elemento será igual al elemento con el índice que se obtendrá del valor de la i de la iteración.

        let elemento = array[i];

        // Creamos un condicional que evaluará si existe la key que es igual al valor del elemento en el array que estamos evaluando.

        if (objetoRecipiente[elemento]) {

            // En caso de ser verdadero, añadiremos un +1 al valor que esta key tenga actualmente.

            objetoRecipiente[elemento] += 1;
        } else {

            // En caso de ser falso, le diremos al objeto que crearemos una propiedad, en el cual key será igual a nuestro elemento y el valor de esta key será igual a 1.
            objetoRecipiente[elemento] = 1;
        }
        
    }

    // Una vez termine el for de recorrer todo el array, guardaremos en una variable el array bidimensional del objeto final. Esto permitirá que obtengamos mediante el método sort el valor más repetido.

    let objetoArray = Object.entries(objetoRecipiente);

    // Creamos una variable llamada objetoOrdenado que será igual al array bidimensional del objeto final, como instrucciones a la función le diremos que los ordene con respecto al segundo elemento de cada uno de los arrays que tenemos.

    /*
    Para explicar esto más a fondo, es imposible restar, dividir o multiplicar un array de otro, incluso si intentamos sumarlos aparentemente nos dejará, pero solo concatenara el ultimo elemento del primer array con el segundo y luego añadirá los otros elementos como si fuera un solo array.

    En este caso, tenemos un array bidimensional, o dicho de otro modo un array dentro de otro array, en este caso para poder ordenar la lista debemos acceder al segundo elemento de cada subarray para poder ordenarlo, ya que es la frecuencia o la cantidad de veces que se repite un elemento. La forma de hacerlo sería enviandole como parámetro a JS en vez de a - b o b - a, que entraría directamente a tratar de hacer operaciones con cada array a decirle que entre a[1] - b[1] o b[1] - a[1], por lo tanto le estamos diciendo que evalúe el elemento con índice 1 del 'Valor acumulado' y luego que evalúe el elemento con índice 1 del 'Nuevo valor'.
    */
    let objetoOrdenado = objetoArray.sort((a, b) => {
        return b[1] - a[1];
    });

    console.log('La moda es igual a ' + objetoOrdenado[0][0] + ' ya que se repitió ' + objetoOrdenado[0][1] + ' veces.') 
}

Comparto mi código con explicación.

//MODA consiste en el elemento que más se repite en un conjunto de datos
// formula: contar las repeticiones de cada elemento y el que más se repite es la moda
const numbersModa = [4,4,4,3,2,1];
const calcularModa = (lista) =>{
    const listCount = {};

    lista.forEach((elemento) => {
        listCount[elemento] = (listCount[elemento] || 0) + 1;
    });
    const listArray = Object.entries(listCount).sort((a,b) => a[1] - b[1]);
    // listArray = [ [ '1', 1 ], [ '2', 1 ], [ '3', 1 ], [ '4', 3 ] ]

    /* explicación de arriba: Object.entries(listCount) 
    convierte el objeto en un array de arrays,
    luego se usa sort para ordenar de menor a mayor, 
    luego se resta el segundo elemento de cada array, 
    es decir, el número de repeticiones, y se obtiene el array ordenado de menor a mayor.
    */

    const moda = listArray[listArray.length - 1];
    // moda = [ '4', 3 ]

    /* explicacion de arriba: se obtiene el último elemento del array,
     *  es decir, el que más se repite
     */
    return console.log(`La moda es: ${moda[0]} y se repite ${moda[1]} veces`);
}
calcularModa(numbersModa)

la había hecho diferente antes de ver la solución con el método del bidimensional, la dejo acá por si a alguien le interesa

function calcularModa (arr ) {
    let listacount = {};
    let moda= {moda:0, repetido: 0}
    arr.forEach(element =>{
        if(!listacount[element]){
            listacount[element]=1
            if (listacount[element] > moda.repetido){
                moda.moda = element
                moda.repetido = listacount[element]
            }
        }else{
            listacount[element]+=1
            if (listacount[element] > moda.repetido){
                moda.moda = element
                moda.repetido = listacount[element]
            }
        }
    })
    return moda
}

De la forma en como lo pense en la clase anterior (esta comentado) y en la forma en que se planteo en la clase como reto 😃

function ordenarListaBidimensional(listaDesordenada){
    const lista = listaDesordenada.sort((a,b)=>{
        return a[1] - b[1];
    })

    return lista;
}

function calcularModa(lista){
    const listaCount = {};

    for(let i = 0; i < lista.length; i++){
        const elemento = lista[i];
        if(listaCount[elemento]){
            listaCount[elemento] += 1;
        }else{
            listaCount[elemento] = 1;
        }
    }
    /* PRIMERA MANERA EN LA QUE PENSE EN UNA SOLUCIÓN, RETO CLASE ANTERIOR 
    console.log(listaCount);
    const arrayListCount = Object.values(listaCount);
    const moda = arrayListCount.sort((a,b) => b-a);
    if(moda[0]){
        console.log(Object.keys(listaCount).find(key => listaCount[key] == moda[0]));
    } */

    const listaBidimensional = Object.entries(listaCount);
    const listaOrdenada = ordenarListaBidimensional(listaBidimensional); 
    console.log(listaOrdenada);
    console.log('Moda '+ listaOrdenada[listaOrdenada.length-1]);
}

Mi solución fue la siguiente:

function calcularModa(lista) {
    listaCount = {};

    for (let i = 0; i < lista.length; i++) {    
        const elemento = lista[i];

        if (listaCount[elemento]) {
            listaCount[elemento] += 1;
        } else {
            listaCount[elemento] = 1;
        }
    }

    const listaArray = Object.entries(listaCount);
    const listaArrayOrdenada = listaArray.sort((a, b) => a[1] - b[1]);
    const listaMaxNumber = listaArrayOrdenada[listaArrayOrdenada.length - 1];
    
    /*console.log({listaCount, listaArray, listaArrayOrdenada, listaMaxNumber});*/
    /*console.log('La moda es: ' + listaMaxNumber[0]);*/
    
    const moda = listaMaxNumber[0];
    return moda;
}

Yo esperando un metodo para sacar la moda 🤡

Usé chatGPT pra encontrar el elemento mas grande del array budimencional y WOW
Clao que tuve que hacer unos ajustes para que funcionara con mi codigo ya escrito pero funciono super bien.
Esta fue la instruccion que le dí a la IA
"en js, tengo un arrayx con arraysy dentro que tienen cada uno de los arraysy dos elementos, necesito que crees un codigo que me devuelva el arraysy que tenga el elemento en la posicion 1 mas garnde"

Aqui les pongo como lo solucioné:

function calcularModa(lista) {
    const listaCount = {};
    for(let i = 0; i < lista.length; i++) {
        const elemento = lista[i];
        if(listaCount[elemento]) {
            listaCount[elemento] +=1
        }else {
            listaCount[elemento] = 1
        }
    }
    const listaCantidad = Object.entries(listaCount)
    const listaOrdenada = ordenarListaBidimensional
    (listaCantidad)
    const masRepetido = listaOrdenada[0]
    const moda = masRepetido[0]
    console.log(moda);
}
function ordenarListaBidimensional(listaDesordenada) {
    const lista = listaDesordenada.sort((a,b) => b[1] - a[1])
    return lista
}

Comparto mi solución:

function moda(arr){
    const listaCount ={};
    arr.map((element) => {
        listaCount[element]? listaCount[element] +=1 : 		 
        listaCount[element] =1;
    });

    const listaArray = Object.entries(listaCount);
    return "La moda es: "+ordenarArray(listaArray)[0][0];
}

function ordenarArray(arr){
    return arr.sort((a,b) => b[1]-a[1] );
}

Yo lo resolví sin ordenamiento

const calculateMode = (list) => {
  const result = {};
  list.forEach((el) => {
    if (result[el]) {
      result[el] += 1;
    } else {
      result[el] = 1;
    }
  });
  let mode = null;
  Object.keys(result).forEach((el) => {
    if (!mode || result[el] > result[mode]) {
      mode = el;
    }
  });
  return mode;
};

Tarde casi una hora en lograr organizar de menor a mayor los valores del array bidimensional, mi recomendación para entender bien acerca del tema es leer ejemplos, ver videos, y luego a partir de esos videos crear un ejemplo propio con diferente código u orden. Y de esta manera no solo comprendemos más la información, también podemos retener más la misma.

My solucion:
Basicamente es el mismo metodo que antes, solo que le especificamos que estoamos buscando el elemento del array en la posicion numero 2 [1] (recuerden que se cuenta desde el 0, por eso [1]).
Entonces ordenamos los arrays dentro del array principal en base al numero que esta en la posicion numero 2 [1] de cada uno de los arrays hijos.

const listArray = Object.entries(listCount);
	console.log(listArray)

const orderList = listArray.sort((a, b) => b[1] - a[1])
console.log('array sorted: ', orderList);

Yo lo ordene de mayor a menor y mostré la primera posición del array, la cual contiene al mayor numero de repeticiones

const lista = []
lista.push(1,2,1,1,1,1,5,3,6,3,4,4,4,4,4,4,'a','a','a','a','a','a','a')

function calcularModa (lista) {

    const listaRep = {}

    lista.forEach(element => { 
        if (listaRep[element]) {
            listaRep[element] += 1
        }else{listaRep[element] = 1}
    })

    const array = Object.entries(listaRep)

    const ordenar = array.sort ( (a,b) => b[1]-a[1])

    console.log('La moda es: ' + ordenar[0][0] + ' con '+ ordenar[0][1]+' repeticiones')
}

calcularModa(lista) 

bueno, yo lo hice así v:

const num= [1, 1, 2, 3, 3, 4]
let listaEnObj={}
let listaEnArrayTrid;
function obtenerModa(lista){
    for (let i=0; i<lista.length; i++){
        const orale=lista[i]
        if(listaEnObj[orale]){
            listaEnObj[orale] += 1
        }
        else{
            listaEnObj[orale]=1
        }
    }
    console.log(listaEnObj)
    listaEnArrayTrid= Object.entries(listaEnObj)

    let listaTridOrdenada= listaEnArrayTrid.sort((a,b)=> b[1]-a[1])
    let moda= listaEnArrayTrid[0][0]
    console.log("la moda es: " + moda);

    console.log(listaEnArrayTrid)
}

obtenerModa(num)

Usando metodo sort

function ordenarListaBidimensional(lista){
    return lista.sort((a,b)=>a[1]-b[1]);  
}

Salida

Mi solucion… 😄

objModa_ = objModa_.sort((a,b)=>a[1]-b[1]);

Esta fue mi solución.

<
const ValorModa = (array) => {
    let obj = {}
    array.forEach( item => { 
        if (obj[item]) {
            obj[item] += 1
        } else {
            obj[item] = 1
        }
    });
    const convertidorArray = Object.entries(obj)
    const nuevaLista = convertidorArray.sort( (a, b) => b[1] - a[1] )

    return nuevaLista[0][0]
}
> 

bueno cerré la pagina lo hice solo y me salió esto (funciona):

<script>
        const lista = [12, 15, 21, 87, 110, 37, 15, 87, 37, 15, 15, 100, 110, 37, 37, 12, 12, 12, 15,37];
        const listeset = new Set()
        for (i of lista){
            listeset.add(i)
        }    
        let numero = [];   
        let moda = -Infinity;
        let repeticiones = 0;
        for (i of listeset){
            for (j of lista){
                if(i != j){
                    continue
                }
                else {
                    repeticiones += 1
                }
            } 
        document.write(`mi numero es ${i} y se repite ${repeticiones} <br>`)
        if (moda <= repeticiones) {
            if(moda == repeticiones){
                moda = repeticiones
                numero.push(i)
           }
            else if(moda != repeticiones){
                for (let x in numero) {
                    numero.pop();
                    }
                moda = repeticiones
                numero.push(i) 
            }               
           }      
        repeticiones= 0
        }
        document.write(`mi numero mas repetido ${numero} y se repite ${moda} <br>`)
    </script>

Otra forma de resolverlo

Usando forEach y filter

const moda = (array) =>{
    let moda =0;
    let repeticiones=0;

    array.forEach((x,i) => {
        let apariciones  = (array.filter(y => y == x)).length;

        if (apariciones > repeticiones) {
            repeticiones = apariciones;
            moda = array[i];
        }
    });

    return moda.toFixed(2);
}
function generarModa(){
    const response = document.getElementById("response");

    response.textContent = "La moda de: ["+numeros+"] es: "+moda(numeros);
}

Solución combinando métodos e índice bidimencional.

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

    let matrizBi = Object.entries(conteo)
    let matrizBiOrdenada = matrizBi.sort((a,b) => a[1] - b[1]).reverse()

    console.log(matrizBiOrdenada)


    return `El elemnto que más se repite es ${matrizBiOrdenada[0][0]} con ${matrizBiOrdenada[0][1]} veces`
}
 

 function calcularModa (list){
        let objList = {};
        for(let i = 0; i < list.length; i++){
            let element = list[i];
            
            if(objList[element]) objList[element] += 1
            
            else objList[element] = 1;           
        }
        
        let twoDimensionalList = Object.entries(objList); //convertir obj a array
        let orderList = twoDimensionalList.sort((a,b)=>a[1]-b[1]); //ordenar dicha lista
        return orderList[orderList.length - 1][0]; //ultimo elemento de la lista
    }

Entiendo a las personas que no han entendido esta parte del curso.
yo tuve que verlo varias veces para entender a la perfecccion este tema.
les recomiendo que NO SE RINDAN NUNCA y terminen ded comprender bien esta clase, porque es un tema bien importante.

Para convertir un objeto a array tenemos los siguientes metodos:
Object.keys(obj) – devuelve un array de propiedades. Con este metodo convertimos un objeto a array tomando las llaves del objeto como valores:

const objeto = {
	a: 1,
	b: 2,
	d: 5,
}

Object.keys(objeto);
//output:
['a', 'b', 'd']

Object.values(obj) – devuelve un array de valores. Con este metodo convertimos un objeto a array tomando las valores del objeto:

const objeto = {
	a: 1,
	b: 2,
	d: 5,
}

Object.values(objeto);
//output:
[1, 2, 5]

**Object.entries(obj) **– devuelve un array de pares [propiedad, valor] (bidimencional). Convertimos un objeto a array tomando las llaves y sus valores. Esto devuelve un array que contiene arrays, estos arrays tendran dos posiciones, una para la llave y otra el valor:

[['a', 1], ['b', 2], ['d', 5]]

En este caso utilizaremos el metodo Object.entries() para crear el array:

function calcularModa(array) {
	const arrayCount = {};
	
	for (let i = 0; i < array.length; i++) {
		const elemento = array[i];

		if(arrayCount[elemento]) {
			arrayCount[elemento] += 1;
		} else {
			arrayCount[elemento] = 1;
		}

	}

		// Crear array a partir del objeto:
		const listaArray = Object.entries(arrayCount);
		console.log({arrayCount, listaArray});
}

El siguiente paso es ordenar el array resultante con el metodo sort; la ordenación se hará tomando la cantidad (segundo elemento de cada uno de los arrays). Pero como en este caso tenemos un array de arrays, al realizar el calculo en la funcion que recibe el metodo sort ordenarArraySort debemos tomar el indice 1 de cada array comparado en la resta entre valorAcumulado y nuevoValor. Importante: ahora la funcion para ordenar el array va a recibir un segundo parametro, en este caso i, con el cual indicaremos la posición o indice en la cual se encontrara el valor a partir del cual ordenaremos nuestro array:

//Funcion para ordenar array:
function ordenarArrayBidimensional(arrayDesordenado, i) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado[i] - nuevoValor[i];
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

De esta manera, en nuestra funcion para calcular la moda llamaremos a la funcion para ordenar el array bidimensional y poder obtener el array de manera ordenada. Le enviaremos dos parametros a la funcion: el array a ordenar y el indice que usaremos como criterio de ordenacion del arrray:

function calcularModa(array) {
	const arrayCount = {};
	
	for (let i = 0; i < array.length; i++) {
		const elemento = array[i];

		if(arrayCount[elemento]) {
			arrayCount[elemento] += 1;
		} else {
			arrayCount[elemento] = 1;
		}

	}

		// Crear array a partir del objeto
		const listaArray = Object.entries(arrayCount);
		//Ordernar array
		const arrayOrdenado = ordenarArrayBidimensional(listaArray, 1);
		console.log({arrayCount, listaArray, arrayOrdenado});
} 

Luego de obtener el array ordenado, tomaremos el ultimo elemento que sera el mayor de todos de acuerdo a su valor/cantidad. Esto lo hacemos llamando al array ordenado (arrayOrdenado) y tomando su ultimo elemento:

function calcularModa(array) {
	const arrayCount = {};
	
	for (let i = 0; i < array.length; i++) {
		const elemento = array[i];

		if(arrayCount[elemento]) {
			arrayCount[elemento] += 1;
		} else {
			arrayCount[elemento] = 1;
		}

	}

		// Crear array a partir del objeto:
		const listaArray = Object.entries(arrayCount);
		//Ordernar array:
		const arrayOrdenado = ordenarArrayBidimensional(listaArray, 1);
		//Sacar el ultimo elemento:
		const arrayMaxNumber = arrayOrdenado[arrayOrdenado.length - 1];
		console.log({arrayCount, listaArray, arrayOrdenado, arrayMaxNumber});
}

Finalmente, retornamos la moda. Para retornar la moda tomamos el array que se extrajo en el paso anterior y retornamos su posicion 0:

const array = [1, 2, 3, 4, 1, 'a', 'abc', 13, 'abc', 'abc']; 

function calcularModa(array) {
	const arrayCount = {};
	
	for (let i = 0; i < array.length; i++) {
		const elemento = array[i];

		if(arrayCount[elemento]) {
			arrayCount[elemento] += 1;
		} else {
			arrayCount[elemento] = 1;
		}

	}

		// Crear array a partir del objeto:
		const listaArray = Object.entries(arrayCount);
		//Ordernar array:
		const arrayOrdenado = ordenarArrayBidimensional(listaArray, 1);
		//Sacar el ultimo elemento:
		const arrayMaxNumber = arrayOrdenado[arrayOrdenado.length - 1];
		//console.log({arrayCount, listaArray, arrayOrdenado, arrayMaxNumber});

		const moda = arrayMaxNumber[0];
		console.log(moda);
		return moda;

}

//Funcion para ordenar array:
function ordenarArrayBidimensional(arrayDesordenado, i) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado[i] - nuevoValor[i];
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

//Llamada a la funcion de calcularModa:
calcularModa(array);

Un aporte sobre los arrays, Fuente: visto por la RED

AQui mi solucion completa, ahora a ver como lo hizo el profe!!

aqui mi solucion!!

Intenté hacerlo por mi mismo y este fue el resultado.

VIendo la clase me doy cuenta que mi lógica para resolverlo fue totalmente diferente; sin embargo, fue bastante divertido pensar en todo el proceso por mi mismo y luego ver que había otra manera de resolverlo.

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 argumento "+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,"hola","hola","hola","hola"]);

Las unicas modificaciones fueron agregar indices al comparador

function ordenarListaBidi(listaDesordenada){
  const lista=listaDesordenada.sort(ordenarLista);
  function ordenarLista(valorAcumulado,nuevoValorAcumulado){
    return [valorAcumulado[1]-nuevoValorAcumulado[1]];
  }

  return lista;
}

Comparto mi funcion para calcular la moda, explore varias opciones para llegar al mismo resultado:

function calcular_moda(valores){
    const count = {};
    valores.forEach(valor => {
        if(count[valor] == undefined){
            count[valor] = 1;
        }else{
            count[valor] += 1;
        }
        //OTRO METODO
        //count[valor] = (count[valor] || 0) +1;
    });

    //METODO con Object.values y Object.keys
    // const mayor = Math.max(...Object.values(count));
    // const numeros_repetidos = [...Object.keys(count)];
    // console.log(ordenado);
    // const moda = numeros_repetidos.filter(numero => count[numero] == mayor);

    //METODO con Object.entries
    const conteo = Object.entries(count);
    const conteo_ordenado = conteo.sort((prev, next) => prev[1] + next[1]);
    moda = conteo_ordenado[0][0];
    console.log(conteo_ordenado);
    return moda;
}

const listado = [1,2,3,4,5,8,9,3,4,4,4]

function cantidadRepetidas(lista){
    const listRepeatCount = {};

    for(let i = 0 ; i< lista.length ; i++){
        const element = lista[i];

        if(listRepeatCount[element]){
            listRepeatCount[element] += 1;
        }else{
            listRepeatCount[element] = 1;
        }
        
    }
    const objectArray = Object.entries(listRepeatCount);
   const ordenarBidemensional = ordenarListaBidimensional(objectArray);
   let moda;
   let keys;
   for(let i = 0 ; i<ordenarBidemensional.length;i++){
    moda = Math.max(ordenarBidemensional[i][1]);
    keys = Math.max(ordenarBidemensional[i][0]);
}
   console.log({moda,keys});
}
cantidadRepetidas(listado);


function ordenarListaBidimensional(objectArray){
    const ordenar = objectArray.sort((a,b)=>a[1]-b[1]);
    return ordenar;
}