Top 10% de salarios

Yo use un .sort en las medianasOrdenadas para ordenar el array de mayor a menor, invirtiendo la función interna del .map con b - a, y así poder usar el index desde la primera posición (0).

function medianaTop10(){
  const listaMediana = salarios.map(persona => medianaPorPersona(persona.name));
  const medianasOrdenadas = PlatziMath.ordenarLista(listaMediana).sort((a,b)=> b - a);
  const limite = listaMediana.length / 10;
  const top10= medianasOrdenadas.slice(0,limite);
  const medianaTop10 = PlatziMath.calcularMediana(top10)
  return medianaTop10;
}

Método slice ( )

Método splice ( )

Aca saque mi propia mediana del 10% mas rico, esto lo hice antes de ver el video, por lo cual me siento orgulloso 😃

function medianaTop10PerCent(){
    const nombres = salarios.map(persona => persona.name)
    console.log(nombres)

    const medianaPerHabitante = nombres.map(nombre => medianaPorPersona(nombre) )
    const sueldosOrdenados = PlatziMath.ordenarLista(medianaPerHabitante)

    console.log ({medianaPerHabitante, sueldosOrdenados})

    const numeroIntegrantesDiezPercent = Math.ceil(sueldosOrdenados.length / 10)

    console.log("Integrantes al top10%: " + numeroIntegrantesDiezPercent)

    let topTenPerCentArray = []

    for(let i = 1; i <= numeroIntegrantesDiezPercent ;i++){
        let integranteTopTenPercent = sueldosOrdenados[sueldosOrdenados.length - i]

       topTenPerCentArray.push(integranteTopTenPercent)
    }

    console.log(topTenPerCentArray)

    const medianaTopTenPercent = PlatziMath.calcularMediana(topTenPerCentArray)

    return medianaTopTenPercent
}

todo venia tan bien, y justo esta clase me sale NaN en la mediana general -_-! , no tengo una sola idea de por que ocurre y vengo de que todo salió bien en las clases anteriores, y con lo spaguetti que estan esos archivos no tengo idea de como corregir

Usando un ciclo for

function medianaTop10 (listaSalarios) {
const topSalarios = [];
const cantidadPersonas = listaSalarios.length * 0.1;

for(let i = 1; i <= cantidadPersonas; i++){
    topSalarios.push(listaSalarios[listaSalarios.length - i])
}
console.log(topSalarios);

//Mediana del top 10% de salarios
const medianaTop10 = MathCalculos.calcularMediana(topSalarios);
console.log(medianaTop10);
return medianaTop10;

}

medianaTop10(medianaListaOrdenada);

Me pareció excepcional este curso. El profe Juan David no me deja de sorprender con sus conocimientos. Soy profe de Matemática y es un placer escucharlo.
Felicitaciones por tremendo curso. Me gusto muchísimo!

Lo que yo hice fue hacer una funcion llamada medianaTopX, para poder ver el porcentaje top que queramos.
De igual manera, en la solucion lo que hice fue ordenar mi lista de mayor a menor y extraer hasta la posicion X, dependiendo del porcentaje que hayamos indicado, me pareció mas sencillo.
De igual manera podriamos indicar el 100% para ver el valor de la medianaGeneral 😀

function medianaTopX(porcentaje){
    const listaMedianas = salarios.map(persona=>medianaPorPersona(persona.name));
    const listaMedianasOrdenada=[...listaMedianas].sort((a,b)=>b-a)

    const cantidad = Math.round(listaMedianas.length*(porcentaje/100));
    const topX = listaMedianasOrdenada.slice(0,cantidad);

    const medianaTopX = Platzimath.calcularMediana(topX)
    return medianaTopX;
}

El método .slice() es una función integrada de JavaScript que se utiliza para extraer una porción de una matriz (array) o una cadena (string). Este método no modifica la matriz o cadena original, sino que devuelve una nueva matriz o cadena que contiene los elementos seleccionados.

La sintaxis básica del método .slice() es la siguiente:

array.slice(inicio, fin

Donde “array” es la matriz original, “inicio” es el índice del elemento donde comenzar a extraer (inclusive), y “fin” es el índice del elemento donde detener la extracción (no inclusivo). Si no se especifica el parámetro “fin”, se extraen todos los elementos desde el índice “inicio” hasta el final de la matriz.

Por ejemplo, si tenemos la siguiente matriz:

const frutas = ['manzana', 'naranja', 'pera', 'uva', 'mango'];

Podemos utilizar el método .slice() para extraer una porción de la matriz, como en los siguientes ejemplos:

const frutas1 = frutas.slice(1, 3); // ['naranja', 'pera']
const frutas2 = frutas.slice(2); // ['pera', 'uva', 'mango']

También podemos utilizar el método .slice() para extraer una porción de una cadena, como en el siguiente ejemplo:

const nombre = 'Juan Perez';
const apellido = nombre.slice(5); // 'Perez'

En este ejemplo, la función .slice() extrae todos los caracteres de la cadena “nombre” desde el índice 5 hasta el final, lo que resulta en la cadena “Perez”.

const medianaTop10percent = () => {
  const medianasOrdenadas = salarios
    .map((persona) => {
      return medianaPorPersona(persona.name);
    })
    .sort((a, b) => b - a);

  const top10 = medianasOrdenadas.slice(0, medianasOrdenadas.length / 10);

  return calculoMath.calculaMediana(top10);
};

Aqui mi solucion a tomar el top 10 de la lista de medianas.

let i = medianasOrdenadas.length - 1;
const a = i - cantidadTop10; 
const medianasTop10 = [];
 for (i; i > a; i-- ){
        medianasTop10.push(medianasOrdenadas[i])
    }

Yo lo hice con un ciclo while porque me odio 😄 adentro nada más le puse un shift, para quitarle el primer valor hasta que nomás queden los dos del final.

const cantidad = listaMedianas.length / 10;

    const result = medianasOrdenadas;

    while(result.length > cantidad) {
        result.shift();
    }

    console.log(result);

Hace bastantes clases que estoy intentando buscar la solucion yo mismo antes de que el profesor la explique, y da la coincidencia que muchas veces tenemos la misma.

function medianTop10(){
    const medianPerPerson = salaryList.map(person => calculateMedianOfPerson(person.name));
    
    const orderMedians = medianPerPerson.sort((a, b) => b - a)

    const tenPercent = Math.floor(orderMedians.length * 0.1);

    return orderMedians.slice(0, tenPercent)
}

No pude seguir los pasos del profesor en este último módulo, pero haré un proyecto con lo aprendido los anteriores módulos…aquí mi cabecera 😅

Yo realicé el ejercicio de está manera:

Output:

Yo usé un .sort para reordenar el arreglo de medianas de mayor a menor, después calculé el 10% del total de las medianas y apliqué Math.trunc() para eliminar la parte decimal (esto tendría utilidad si en algún momento cambia la cantidad de personas dentro del arreglo salarios).

Por último apliqué el método .slice desde la posición 0 hasta el 10% (sin decimales) y calcule de nuevo la mediana.

function topTenPercentMedian() {
    const peopleMedians = salarios.map(person => {
        return medianPerPerson(person.name);
    });

    const sortPeopleMedians = peopleMedians.sort((a, b) => { return b - a; });
    const tenPercent = (sortPeopleMedians.length * 10) / 100;
    const topTen = sortPeopleMedians.slice(0, Math.trunc(tenPercent));

    return PlatziMath.calculateMedian(topTen);
}

function medianaGeneral() {
	const names = salarios.map((person) => {
		return person.name;
	});
	const medianaForEachName = names.map((person) => {
		return personMediana1(person);
	});
	const generalMediana = mediana(medianaForEachName);
	const medianaOrder = medianaForEachName.sort((a, b) => b - a);
	const amountTopTen = Math.ceil(medianaOrder.length * 0.1);
	const topTen = medianaOrder.slice(0, amountTopTen);
	const topTenMediana = mediana(topTen);
	return `La mediana general es de $${generalMediana}, la mediana del top 10 $${topTenMediana}`;
}

Hice algo similar a lo del profe, pero quise compactarlo en menos líneas para ver que tan compuesto podría armarlo.

function medianaTop() {
    const listaMedianas = salarios.map((persona) =>
        medianaPorPersona(persona.name)
    );

    const medianaTop = PlatziMath.calcularMediana(
        PlatziMath.ordenarLista(listaMedianas).slice(listaMedianas.length * 0.9)
    );

    return medianaTop;
}

Estuve pensando en como seleccionar los elementos top acorde a su numero, es decir, si en el top hay 2. Tomar las ultimas dos posiciones del arreglo por la orden de este de menor a mayor. Pero mejor ordene de mayor a menor y después utilice el método slice(), para comenzar en una posición 0 y después enviarle el numero de top10. No he terminado de ver la clase por el reto pero allá vamos 😃

function medianaTopDiez(){
    const listaMedianasPorPersona = salarios.map((persona)=> medianaPorPersona(persona.name));
    const listaMedianaOrdenada = listaMedianasPorPersona.sort((a,b)=> b - a);
    const topCantidad = (listaMedianaOrdenada.length/10);
    console.log(topCantidad);
    console.log(listaMedianaOrdenada);
    const topDiezMediana = listaMedianaOrdenada.slice(0,topCantidad);
    return topDiezMediana;
}

Realice el ejercicio de extraer el top 10 usando el siclo for aquí mi código

function medianaGeneral() {
    const ListaMedianas = salarios.map( persona => medianaPorPersona(persona.name));
    console.log({ListaMedianas})

    const medianaDelPueblo = PlatziMath.calcularMediana(ListaMedianas);
    console.log({medianaDelPueblo})
}


function medianaTop10() {
    const ListaMedianasT10 = salarios.map(
        persona => medianaPorPersona(persona.name)
        );

    const medianasOrdenadas = PlatziMath.ordenarLista(ListaMedianasT10)

    const cantidad = medianasOrdenadas.length / 10;

    top10 = []

    for (i = (medianasOrdenadas.length-cantidad); i < medianasOrdenadas.length ; i ++) {
        top10.push(medianasOrdenadas[i])
    }
    
    console.log({medianasOrdenadas, top10})
}

Recomendaciones: ✌😃

1. Me gustaría que cerraran el panel de la izquierda, esto para tener un poquito más de visión del código.
2. Estaría cool un poco más de orden al hacer cada clase.

Quizá debería ser un estándar dentro de cada curso el organizar cada tema por separado, así no tenemos todo en un mismo archivo, esto con el fin de hacerlo más didáctico y entendible. Ya luego, en un proyecto real, habiendo entendido todo si deseamos por decisión propia, podemos mezclar todo. ❤

Yo me organicé de la siguiente manera, pero ver al profe trabajar mezclando muchas cosas si es un poquito mareador 😥

Calculo de la mediana del top10% de las medianas de los salarios

He utilizado:

• Ciclo for

• Array Method: push( )

• Array Method: pop( )

Mira las slides:

El codigo:

function topTenMedian() {
    const medianAll = []
    salarios.map(person =>{
        const personName = person.name;
        const median =  medianByPerson(person.name);
        medianAll.push({name: personName, median: median});
        return medianByPerson(person.name);
    } );
    console.table(medianAll.sort(((a,b)=>b.median - a.median)));
}

Inicialmente calculé la mediana de los salarios de todas las personas, y la ordené de mayor a menor con el metodo sort. Luego esa lista la dividí entre 10 para obtener el top de mejor salarios a la que llame “top10”; e hice un ciclo for donde “index” aumentaría siempre y cuando fuese menor a top10, y esos valores los guarde en un array., para luego calcular su mediana.

function medianaTop10Personas (){
    const identidadPersonas = salarios.map(id => id.id).map((medianaId)=> {
        return medianaPorPersona(medianaId)
    })

    const listMayorMenor = identidadPersonas.sort((a, b) => b - a)
    const top10 = identidadPersonas.length / 10 
    const topElement = [];

    for (let index = 0; index < top10; index++) {
        topElement.push(listMayorMenor[index])    
    }

    return PlatziMath.calcularMediana(topElement)

}

Sólo se me ocurrió hacer un ciclo for para sacar la lista top10 de medianas.

const top10Porciento = Math.round(listaMedianas.length / 10);

  let listaMedianasTop10 = [];
  for(let i = 0; i < top10Porciento; i++) {
    let mediana = listaMedianas[listaMedianas.length-1-i];
    listaMedianasTop10.push(mediana);
    }
    
  return listaMedianasTop10;

Este ejemplo me sirvio para analizar y entender mejor el problema, explicacion despues del codigo:

 function medianaTop10(){
  let medianas = [];
  salarios.reduce((prev,persona)=> {
    medianas.push(medianaPorPersona(persona.name));
    return medianas;
  },[]);
  medianas.sort((a,b)=> b - a);
  let top10 = [];
  for(let i = 0; i < 10; i++){
    top10.push(medianas[i])
  }
  return PlatziMath.calcularMediana(top10);
}

Se define una variable vacía llamada “medianas” que se utilizará para almacenar las medianas de salario de las personas.

Se utiliza el método reduce de los arreglos para recorrer cada elemento de la lista “salarios” y calcular su mediana de salario utilizando la función “medianaPorPersona” y agregando el resultado a la lista “medianas”.

Se utiliza el método sort para ordenar la lista “medianas” en orden descendente.

Se define una variable vacía llamada “top10” que se utilizará para almacenar los 10 mayores salarios.

Se utiliza un for para recorrer solo los primeros 10 elementos de la lista “medianas” y se agrega cada elemento a la lista “top10”.

Se utiliza la función “calcularMediana” de PlatziMath para calcular la mediana de la lista “top10” y se devuelve el resultado.

Con esta implementación se reduce el uso de variables y se utiliza métodos más eficientes para el ordenamiento y recorrido de los elementos de la lista, mejorando así la eficiencia del código.

Mi solución con siclo:

const lista = [1000, 1100, 1200, 1300, 
    1400, 1500, 1600, 1770, 
    1800, 1900, 2000, 2100, 2200, 
    2300, 2400, 2500, 2600,
    2700,
    2800, 2900];

 let diezPorciento = [];

    const conteo = lista.length - (lista.length / 10);

for( let i = conteo; i < lista.length; i++){

    diezPorciento.push(lista[i])

}

<code> 

no es el codigo mas bonito pero es mi codigo:

function medianaTop10() {
    
    const listaMedianas = salarios.map((persona) => medianaPorPersona(persona.name));

    const medianasOrdenadas = PlatziMath.ordenarLista(listaMedianas);

    const cantidad = Math.floor(medianasOrdenadas.length / 10)
    let element = [];

    const limite = medianasOrdenadas.length - cantidad;

    for (let i = limite; i < medianasOrdenadas.length; i++) {
        
        element.push(medianasOrdenadas[i])
    }
    
    const medianaTop = PlatziMath.calcularMediana(element);
    return medianaTop;

}

Agradecido de tener tan buen profesor, logre entender como funcionan los métodos de arrays y las bases detrás de los mismos con este curso.

Interesante, aunque sigo algo confuso :S