Método sort

La verdad, la verdad, la verdad… hace un par de clases que me perdi, pero aqui seguimos, tratando de entenderle sin que me explote la cabeza jeje

como no tenia claro como usar sort antes de la clase yo mismo me hice mi propio sort junto con las funciones restantes heehe

 

 

 
si quieren checar el código completo esta en mi github también ya desplegué la page por si quieren probarlo

Revisando la documentación oficial JS Sort, encontre esta misma logica, la función ordernarLista es opcional, los parametros a, b siempre hacen una diferencia pero en base al valor UNICODE. Si usamos array.sort() en el caso de un array [1,10,2,20] seria correcto por sus valores UNICODE, pero en este caso nuestra funcion ordernarLista es lo correcto para hacer un ordenamiento real de numeros.
Les dejo el enlace JavaScript - Sort 🚀

Dejo mis apuntes de la clase por si te sirven de algo ✨

Apuntes chidos 📝

Implemente le método Sort para que ordene de menor a mayor, recomiendo el curso de manejo de arrays con js, de verdad que hacerlo, me ha ayudado mucho a entender este.

////Función para hallar el Promedio
function average(array){
    console.log('Los datos que ingreso fueron: ',array)
    const suma= array.reduce((sum,item)=>item+sum,0);
    return averageResult=suma/(array.length)
}

/// Función para saber si es par o impar 
function median(array){
    console.log('la lista desordenada es:', array)
    let orderedList=array.sort((a,b)=>a-b)
    console.log('la lista ordenada es:', orderedList);
    const number=(orderedList.length)%2; 
    if(number==0){
        //es par
        let iUno= Math.floor((orderedList.length/2));
        let iDos= Math.floor((orderedList.length/2)+1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }else{
        //es impar
        let iUno=Math.floor((orderedList.length/2));
        let iDos=Math.floor((orderedList.length/2)-1);
        let resultmedian=average([iUno,iDos]);
        console.log('El resultado de la mediana es:',resultmedian )
    }
};
median([1,6,3,8,5,9,7]); 

Un aporte, hay que tener en cuenta que el metodo sort() modifica nuestro array original y si por alguna razón necesitamos la lista en el orden original vamos a tener problemas despues.
Por tanto utilizaria el operador de propagacion, que me crea una copia con una referencia en memoria diferente, por tanto la lista original queda igual.
La función calcularMediana me quedaría asi

//es par
const isEven= (arr)=> arr.length%2 === 0 ? true : false;

//es impar
const isOdd = (arr)=> !isEven(arr);

//calcular Mediana
function calcularMediana(arr){
    const arrOrdenado=[...arr].sort((a,b)=>a-b)
    console.log(arrOrdenado);
    let mediana
    if(isEven(arrOrdenado)){
        mediana = (arrOrdenado[arrOrdenado.length/2]+arrOrdenado[(arrOrdenado.length/2)-1])/ 2
        return mediana
    }
    else {
        mediana = arrOrdenado[(arrOrdenado.length-1)/ 2]
        return mediana
    }
}

Con el método sort, cuando se trata de strings no es necesario pasar argumentos:

let names = ['Charles','John', 'Peter', 'Adam', 'Christian']
names.sort ();
console.log (names);

// Con números no da el resultado sin pasar argumentos por la forma en la que Javascript le da jerarquía a las letras y los números (tabla ascii)
numbers2.sort ();
console.log (numbers2);

El método sort con números entonces también se puede pasar con una función flecha, de forma acscendente o descendente:

let numbers2 = [200, 50, 1000, 20, 30, 8]

const ascendente = numbers2.sort ((a,b) => a - b);
console.log (ascendente);

const descendente = numbers2.sort ((a,b) => b - a);
console.log (descendente);

Así realicé mis algoritmos

// ! Explanation of the reduce method.

const arrayTest = [1,2,3,4,5,6,7,8,9];
// Esta función se va a enviar como parámetro.

function reduceEngine(initialValue, SumValue){
    // The initial value is a value that is the position that is sent to the method
    // Sum is the result of the process.
    return initialValue + SumValue ;
}

// Here we put the function of how the engine works in the reduce method 
const reduceMethodWithArrays = arrayTest.reduce(reduceEngine);

// ! End of the explanation of the reduce method.


//! Calculation of the median

// Second challenge to know if a number is odd or even.
const checkEven = (number) => (number % 2 != 0) ? false : true;

// Engine to the sort function works!
// * Basically works using the a, as the initial position and b, as the second position. If b is higher ll be reposition the a as b and reverse. 
function sortEngine(a, b) {
    return a - b ;
};

// If the array is on its length odd, ll be return the position as the middle character of the array and, if its even ll return two positions the middle and the middle plus one.

let positionA;
let positionB;
function calculatePosition(array) {
    if (!checkEven(array.length)) {
        positionA = Math.floor(array.length / 2);
        return positionA
    } else {
        positionA = Math.floor(array.length / 2);
        positionB = Math.floor(array.length / 2) - 1;
    }
};

// Result of the array sorted
const arraySorted = (array) => (array.sort(sortEngine));
const sortedArray = arraySorted(arrayTest);

// Median algorithm.

let medianValue;
function calculateMedian(array) {
    calculatePosition(array);
    indexOne = positionA;
    indexTwo = positionB;
    (!indexTwo) ? medianValue = array[indexOne] : medianValue = (array[indexOne] + array[indexTwo]) / 2 ;
    console.log(medianValue);
}

calculateMedian(sortedArray);

const lista = [1, 23, 39, 4, 67, 90];
let mediana = 0;

//Funcion para validar si un arreglo es par o impar 
function esPar(lista) {
    let validador = lista.length % 2 == 0 ? true : false;
    return validador;
}

//Funcion para ordenar los elementos del arreglo mediante sort 


function ordenarLista(listaDesordenada){
    return listaDesordenada.sort((valorAcumulado,valorNuevo) => {return valorAcumulado-valorNuevo}); 
}
function calcularMediana(lista) {
    if (esPar(lista)) {
        let ordenarListas = ordenarLista(lista); 
        const posicion1 = (lista.length / 2) - 1;
        const posicion2 = lista.length / 2;
        console.log(posicion1, posicion2);
        mediana = lista.reduce(() => {
            return (lista[posicion1] + lista[posicion2]) / 2
        });
        return mediana;
    } else {
        const posicion = Math.floor((lista.length / 2));
        mediana = lista[posicion];
        return mediana;
    }
}
calcularMediana(lista);

Ojala sigan haciendo más cursos que sean más enfocados a las soluciones en general, como el de diseño de patrones. Uno de algoritmos de ordenamiento estaría genial

• Si el resultado es negativo, a se ordena antes que b.

• Si el resultado es positivo, b se ordena antes de a.

• Si el resultado es 0, nada cambia.
  https://www.freecodecamp.org/espanol/news/ordenar-arreglos-en-javascript-como-usar-el-metodo-sort/

Mi solución:
const numbersArray = [40, 10, 50, 20,1000,4500];

function calculaPromedioReduce(numbers) {
const suma = numbers.reduce((sum, value) => sum + value);
return suma / numbers.length;
}

function isPar(numbers) {
return !(numbers.length % 2);
}

function calculaMediana(numbers) {
const arraySorted = numbers.sort((a, b) => a - b);
let pos = Math.floor(arraySorted.length / 2);
return isPar(arraySorted)
? calculaPromedioReduce([arraySorted[pos], arraySorted[pos - 1]])
: arraySorted[pos];
}

console.log(calculaMediana(numbersArray));

Pueden crear una función que haga el Sort

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

y así solo la invocan, recuerden que Sort es un método mutable y cambia el array original

let arraySalarios = [288, 92, 765, 437, 666, 495, 342, 123, 156, 992, 906, 732, 448, 331, 254, 454, 703, 745, 983, 473, 946, 714, 954, 691, 618, 892, 722, 505, 548, 429, 710, 27, 348, 514, 372, 264, 912, 534, 840, 888, 838, 954, 832, 559, 935, 847, 54, 491, 411, 905, 376, 141, 85, 641, 516, 710, 808, 409, 836, 437, 541, 902, 280, 693, 812, 731, 168, 151, 487, 290, 667, 643, 695, 738, 37, 809, 955, 758, 654, 497, 938, 576, 547, 708, 751, 84, 97, 726, 877, 278, 73, 767, 256, 745, 514, 950, 137, 129, 57, 104, 242, 24, 396, 459]


console.log(calcularMediana(sortList(arraySalarios)));

gracias al metodo reduce entendi el metodo sort 😄

Mis notas de la clase:

Método sort:

Ordena los elementos de un arreglo (array) localmente y devuelve el arreglo ordenado.

Sintaxis:

Este método recibe una función callback que se encargara de hacer la comparacion entre cada uno de los elementos del array.
arr.sort([compareFunction]):
arrayDesordenado.sort((a, b) => a - b);

Paso a paso de la clase:

Para encapsular nuestro codigo y poder reutilizarlo creamos la funcion ordenarArray dentro de la cual vamos a aplicar el metodo sort a nuestro array:

function ordenarArray(arrayDesordenado) {

	const arrayOrdenado = arrayDesordenado.sort();

	return arrayOrdenado;
}

En este ejemplo creamos la función que recibe el método sort fuera del mismo, en este caso llamadaordenarArraySort que recibe dos argumentos: valorAcumulado y nuevoValor. Dentro de esta funcion comparamos uno por uno los valores del array ingresando a cada una de sus posiciones de acuerdo a estos dos argumentos que recibe la funcion y retornando tres valores posibles dependiendo de la comparación realizada para cada uno:

function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		if(valorAcumulado > nuevoValor){
			return 1;
		} else if (valorAcumulado == nuevoValor) {
			return 0;
		} else if (valorAcumulado < nuevoValor) {
			return -1;
		}
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

• Se retorna 0 si queremos que el método no haga nada, pues, los valores son iguales, por ende, no importa el orden y no hace falta moverlos.
• Se retorna 1 si queremos que el nuevoValor (menor) pase a estar antes que el valorAcumulado (mayor). Esto quiere decir que el nuevoValor se colocará al principio, o hacia la izquierda de valorAcumulado.
• Se retorna -1 si queremos que nuevoValor (mayor) se quede en esa posición en la que se encuentra con respecto al valorAcumulado (menor). O sea, si al compararlos nuevoValor es mayor que valorAcumulado, el nuevoValor se quedara a la derecha de valorAcumulado.

Al retornar un valor negativo, cero o positivo para cada comparación, se van ordenando/posicionando de manera correcta los elementos del array.

Forma simplificada del código anterior:

function ordenarArray(arrayDesordenado) {

	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

• Si valorAcumulado es menor que nuevoValor la función va a retornar un numero negativo. Ejemplo: 5 - 10 = -5
• Si valorAcumulado es igual a nuevoValor, la función va a retornar 0. Ejemplo: 5 - 5 = 0
• Si valorAcumulado es mayor que nuevoValor, la función va a retornar un numero positivo.

Nota:

Si queremos que el método sort ordene el contenido del array de menor a mayor (ascendente) hacemos el calculo que retorna la funcion de la siguiente manera: arrayDesordenado.sort((a, b) => a - b);. Si queremos que el método sort ordene el contenido del array de mayor a menor (descendente) hacemos el calculo que retorna la funcion de la siguiente manera: arrayDesordenado.sort((a, b) => b - a);

Calcular mediana con el metodo sort:

const arrayDesordenado = [10, 20, 60, 40];

//Funcion para identificar si un array es par o impar:
function esPar(arrayDesordenado) {
	return !(arrayDesordenado.length % 2);
}

//Funcion para calcular la mediana:
function calcularMediana(arrayDesordenado) {
	//Pasar como parametro el array desordenado para que la funcion ordenarArray lo ordene:
	const array = ordenarArray(arrayDesordenado);

	const arrayPar = esPar(array);
	
	if(arrayPar) {
		//Calcular mediana par
		const indexMitad1 = array[(array.length / 2) - 1];
		const indexMitad2 = array[array.length / 2];

		const arrayMitades = [indexMitad1, indexMitad2];

		//Llamado a la funcion de calcularPromedio:
		const medianaArray = calcularPromedio(arrayMitades);

		//Retornar valor luego de calcular el promedio:
		return medianaArray;

	} else {
		//Calcular mediana impar
		const posicionNumeroIntermedio = Math.floor(array.length / 2);
		console.log(posicionNumeroIntermedio);
		
		//Asignar el valor del elemento intermedio encontrado a una variable:		
		const medianaImpar = array[posicionNumeroIntermedio];

		//Retornar elemento:
		return medianaImpar;
	}

}

//Funcion para calcular promedio:
function calcularPromedio(arrayItem) {
	function sumarElementos (valorAcumulado, nuevoValor) {
		return valorAcumulado + nuevoValor;
	}
	const sumaArray = arrayItem.reduce(sumarElementos);

	const promedio = sumaArray / arrayItem.length;
	return promedio;
}

//Funcion para ordenar array:
function ordenarArray(arrayDesordenado) {
	function ordenarArraySort(valorAcumulado, nuevoValor) {
		return valorAcumulado - nuevoValor;
	}

	const arrayOrdenado = arrayDesordenado.sort(ordenarArraySort);

	return arrayOrdenado;
}

console.log(calcularMediana(arrayDesordenado));

Excelente!

Mi solucion al Metodo Sort

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

En mi caso siento que en mucho más sencillo emplementar un arrow function así quedó
** JS**

// media

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

    let media = allnumbers.map(function (x){return parseInt(x, 10)});
    const mediaOrdenada = media.sort((a,b) => a-b);
    
        if (allnumbers.length % 2 === 0) {
            const medianapar1 = Math.floor(media.length / 2);
            const medianapar2 = Math.floor(media.length / 2) - 1;
            const medianaListapar = (mediaOrdenada[medianapar1] + mediaOrdenada[medianapar2]) / 2;
            console.log("La mediana es: " + medianaListapar);
            console.log("Y sus valores son: " + mediaOrdenada[medianapar1] +", "+ mediaOrdenada[medianapar2]);
            console.log(mediaOrdenada);
            return medianaListapar;
        } 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;
        }
    });

Mi solución:

let array = [10,2,30,5,4];

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

function calcularMediana (array){
    array.sort((a , b) => {
    if(a > b) return 1;
    if(a < b) return -1;
    return 0;
    });
// se puede simplificar array.sort((a,b) => a - b);
    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); 

Esta fue mi manera de hacer la función del cálculo de la mediana. Me reté a mi mismo hacerla de la manera mas corta posible, aunque sé que la manera más corta no siempre es la mejor si no es legible. En este caso, solo necesité 5 lineas de código:

function mediana(lista) {
    lista.sort((a, b) => a - b);
    return lista.length % 2 == 0 ? (lista[lista.length / 2 - 1] + lista[lista.length / 2]) / 2 : lista[Math.floor(lista.length / 2)];
};
mediana([10,20,300000000,30]); // 25

De esta forma utilicé el metodo sort, en donde por medio de un string podía asignar el orden ascendente o descendente del array.

function ordenar(numeros, string){

    if(string === "ascendente"){
        numeros.sort(function(a,b){return a - b });
        console.log(numeros);
                 
    }else if(string === "descendente"){
        numeros.sort(function(a,b){return b - a });
        console.log(numeros);
    };
    return numeros;
};

const lista = [1,2,5,3,7,6,8,9,10];
const newLista = lista .sort((a,b) => a - b);

una manera corta de ordenar listas

el metodo .sort ideal para ordenar Arrays de menor a mayor

Vi acá en los aportes que alguien creo su propia función para ordenar, simulando al método sort. Por lo que me uní y me di la tarea de imitar el método sort también.

// funcion para imitar el funcionamiento del metodo sort

const obtenElMayor=(array)=>{
    let numeroMayor=array[0]

    array.forEach(numero=> {

        if(numero>numeroMayor){
            numeroMayor = numero;
        }
        
    });

    return numeroMayor
}


const sort=(array)=>{

     let sortedArr=[]

     while (array.length > 0) {
        const numeroMayor = obtenElMayor(array);
        sortedArr.push(numeroMayor);
    
        const index = array.indexOf(numeroMayor);
        array.splice(index, 1);
      }

    return sortedArr

}

Les comparto mi código:

function parImpar(n){
return !(n.length % 2);
}

function mediana(array2){
const arraySort = array2.sort();
if(parImpar(arraySort)){
const res = arraySort.length / 2;
const resultado = (arraySort[res] + arraySort[res-1])/2;
return "La mediana es: "+resultado;
}else{
const resultado = Math.floor(arraySort.length / 2);
return "La mediana es: "+arraySort[resultado];
}
}

Ordena el array de menor - mayor

function ordenarArreglo(arr){
   
for(let i = 0; i < arr.length; i++ ){  
    for(let j = 0; j < arr.length; j++){
        if(arr[j] > arr[j + 1]){
            let aux = arr[j]
            arr[j] = arr[j + 1]
            arr[j + 1] = aux
            }   
        }
    }
return arr 
}

Puede profundizar un poco más viendo los ejemplos y leyendo de la documentación oficial en: sort - mdn web

Interesante explicación…antes de empezar el curso tenía dudas si era necesario llevar este curso para acelerar mi aprendizaje en JAVASCRIPT y me alegra no haberme salteado el curso…estos métodos no los sabía. Seguire en orden la ruta de JS A PROFUNDIDAD.

array.sort( ) - teoría

Ya sabemos que juan se queda 1 minuto en suspenso cuando termina los videos

queremos actualizacion de la ruta de java backend !!! para los que nos vamos por springboot jeje