No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Práctico de JavaScript

Curso Práctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Calculando el top 10% de salarios

21/24
Recursos

Aportes 79

Preguntas 14

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Este es un gran video donde se pueden ver 3 de los principales métodos para arrays.

MAP, FILTER y REDUCE EN JAVASCRIPT

en ese video se habla mas a afondo de map , filter y reduce 3 conceptos que son muy útiles para cualquier desarrollador en JS.
Esta imagen también es muy ilustrada acerca de estos métodos:

el profesor de pequeño

https://youtu.be/pizgd1wM-LI

Hay un detalle con el método splice, y es que “saca” del array original los valores que se dieron.
Veamos un ejemplo.
Supongamos que tenemos los siguientes valores:

let numeros = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Supongamos que ahora necesito los últimos 3 números del arreglo. Utilizando el método splice, quedaría de la siguiente forma:

let ultNumSplice = numeros.splice(7, 3) 

Ahora nuestra variable ultNum tiene como valor [7, 8, 9] , pero hay un problema…
‎
Al momento de utilizar el método splice, lo que hacemos es extraer del arreglo original los valores, por lo que el valor actual de nuestro arreglo original numeros es: [0, 1, 2, 3, 4, 5, 6] y no [0, 1, 2, 3, 4, 5, 6, 7, 8, 9].
‏‏‎ ‎
Esto nos representa un problema, ya que si quisiéramos utilizar nuevamente nuestro arreglo numeros, ahora solo trabajaremos sobre el nuevo valor, no sobre el original.
‏‏‎ ‎
Para solucionar este problema, en lugar de utilizar en método splice, usaremos el método slice
Slice nos permite extraer valores dentro de un array sin alterarlo. Esté método toma dos parámetros, el punto de inicio y el punto final.

.slice(inicio, final)

Hagamos el mismo ejercicio que antes y obtengamos los últimos 3 números de nuestro arreglo.

let ultNumSlice = numeros.slice(7, numeros.length)

Como numeros.length tiene un valor de 10, el método slice seleccionará los valores desde el 7 hasta el 10, dando como resultado: [7, 8, 9] sin modificar nuestro arreglo original.
‎
Más información sobre slice

cunado estaba recien aprendiendo javascript tomaba los metodos de los arrays y objetos como una herramiento util, los anotaba, y luego decia, bueno si los necesito, reviso mis apuntes y ya…
Pero ahora veo la importancia de concer los metodos mas importate de memoria. Estos nos ayudan a tener mas opciones al momento de analizar y resolver problemas.

Es como querer clavar un clavo, y ya sabes que tienes el martillo, en cambio si solo lo anotas por ahi, es como si tuvieras que ir a la caja de herramientas a ver cual es la que mas te sirve

dejo mi codigo por si a alguien le sirve

const sueldosChile = chile.map((persona) => {
    return persona.sueldo
})

const sueldosOrdenados = sueldosChile.sort((a, b) => a - b)

function par(numero){
    return (numero % 2 === 0)
}

const promedio = (a, b) => {
    const suma = a + b / 2
    console.log(`la mediana de sueldos en chile es ${suma}`)
}

const medianaSueldos = (listaSueldos) => {
    const mitad = parseInt(listaSueldos.length / 2)
    if(par(listaSueldos.length)){
        const personaMitad1 = listaSueldos[mitad - 1]
        const personaMitad2 = listaSueldos[mitad]
        promedio(personaMitad1,personaMitad2)
    }
    else{
        const personaMitad = listaSueldos[mitad]
        console.log(`la mediana de sueldos en chile es ${personaMitad}`)
    }
}

const sueldoGeneral = medianaSueldos(sueldosOrdenados)


const spliceStart = (sueldosOrdenados.length * 90) / 100
const spliceCount = sueldosOrdenados.length - spliceStart
const sueldos10 = sueldosOrdenados.splice(spliceStart, spliceCount)
const sueldoTop10 = medianaSueldos(sueldos10)

Mucha suerte

Solo algo que corregir en el código del master Juan DC. En el valor de spliceStart, hay que añadir la función de parseInt para que cuando el array sea impar no nos de errores de cálculo, así:

const spliceStart = parseInt(salarioColSorted.length * (90 / 100));
const spliceCount = salarioColSorted.length - spliceStart;

Si por alguna razon su objetivo no es modificar el array original de salarios (porque lo vamos a ocupar mas adelante), pueden usar el metodo slice, este les devuelve un nuevo array con la cantidad que le mandemos como parametro, si le enviamos un valor negativo, empieza a contar desde el final, lo que resulta mas facil obtener el top en un array que ya esta ordenado.

.
Asi nos podemos ahorrar los calculos que hacemos con el splice para saber desde donde y hasta donde cortar. 😃

Solo como nota. El método splice nos permite omitir el segundo parámetro, en cuyo caso cortará hasta el final del array. Espero que les sea útil saberlo

La función splice admite valores negativos e indica que empezemos a contar desde el final.

[1,2,3,4,5,6,7].slice(-3) // [5, 6, 7]

Con lo que no tendríamos que calcular en inicio y el final.

También podríamos multiplicar por -1 el resultado de la función sort() y nos quedaría ordenado de forma inversa.

JavaScript: Método Splice

Mi aporte por si alguien quiere guiarse 😄

Otra forma de hacerlo es usando un ciclo for, en cada iteración agregas un elemento a un nuevo array.

const salariosMexDescendente = salariosMexico.sort((a, b) => b - a);

const SalariosTop = []

const Top10Salarios = array => {
    let resultado;
    let Top10 = (array.length * .10);
    console.log(Top10);

    for(let i = 0; i < Top10; i++){
    SalariosTop.push(array[i])
    }
    console.log(SalariosTop)
    return resultado = calcularMedianaSalarios(SalariosTop)
}
console.log(Top10Salarios(salariosMexDescendente))

Hola, les adjunto la imagen del proyecto, el codigo HTML y JS. El texto es impreso desde JS

NOTA: No incluyo el codigo de los datos de los sueldos.

HTML

<section>
            <h2>Mediana de Salarios</h2>
            <p id="salariesColombia"></p>
            <p id="medianaSalariesColombia"></p>
            <p>En la consola pudes ver el console.log() del proceso, se puede observar el array de objetos, el filtrado de los sueldos y el calculo de la mediana.</p>

            <h2>Mediana Top 10%</h2>
            <p id="salariesTop10Col"></p>
            <p id="medianaSalariesTop10Col"></p>
        </section>
	<script src="./salarios.js"></script>
    	<script src="./analisis.js"></script>

JS

//Funciones Helpers
function esPar(numero){
    (numero % 2 ===0);
}

function calcularMediaAritmetica(lista) {
    const sumaLista = lista.reduce(
        function(valorAcumulado = 0, nuevoElemento){
            return valorAcumulado + nuevoElemento;
        }
    );
    const promedioLista = sumaLista / lista.length;
    return promedioLista;
}

console.group("Persons and his Salaries");
console.log(typeof(colombia))
console.log(colombia);
console.groupEnd();

//Calculadora Mediana
function medianaSalaries(lista) {
    const mitad = parseInt(lista.length / 2);
    if (esPar(lista.length)) {
        const personaMitad1 = lista[mitad - 1];
        const personaMitad2 = lista[mitad];

        const mediana = calcularMediaAritmetica([personaMitad1, personaMitad2]);
        return mediana;

    } else {
        const personaMitad = lista[mitad];
        return personaMitad;
    }
}

//Mediana General
const salariosCol = colombia.map(
    function(persona) {
        return persona.salary;
    }
);
console.group("Just Salaries");
console.log(typeof(salariosCol))
console.log(salariosCol);
console.groupEnd();

const salariosColSorted = salariosCol.sort(
    function (salaryA, SalaryB){
        return salaryA - SalaryB;
    }
);
console.group("Organized Salaries");
console.log(typeof(salariosColSorted))
console.log(salariosColSorted);
console.groupEnd();

const medianaGeneralCol = medianaSalaries(salariosColSorted);

//Mediana Top 10%

const spliceStart = (salariosColSorted.length * 90)/100;
const spliceCount = (salariosColSorted.length) - spliceStart;
const salariosColTop10 = salariosColSorted.splice(
    spliceStart,
    spliceCount,
);

const medianaTop10Col = medianaSalaries(salariosColTop10);

console.group("Mediana de salarios");
console.log(typeof(medianaGeneralCol));
console.log(typeof(medianaTop10Col))
console.log ({
    medianaGeneralCol,
    medianaTop10Col,
});

const printSalaries = document.getElementById("salariesColombia");
printSalaries.innerText = "Los salarios colombianos dentro de la base de datos son: " + "$" + salariosCol[0] + ", $" + salariosCol[1]  + ", $" + salariosCol[2]  + ", $" + salariosCol[3]  + ", $" + salariosCol[4]  + ", $" + salariosCol[5]  + ", $" + salariosCol[6]  + ", $" + salariosCol[7]  + ", $" + salariosCol[8]  + ", $" + salariosCol[9]  + ", $" + salariosCol[10]  + ", $" + salariosCol[11]  + ", $" + salariosCol[12]  + ", $" + salariosCol[13]  + ", $" + salariosCol[14]  + ", $" + salariosCol[15]  + ", $" + salariosCol[16]  + ", $" + salariosCol[17]  + ", $" + salariosCol[18]  + ", $" + salariosCol[19] + ".";

const medianaSalariesOfColombia = document.getElementById("medianaSalariesColombia");
medianaSalariesOfColombia.innerText = "La mediana de estos salarios es: $" + medianaGeneralCol + ".";

const printSalariesTop10 = document.getElementById("salariesTop10Col")
printSalariesTop10.innerText = "El top 10% de salarios en colombia segun la base de datos es: " + salariosColTop10[0] + ", " + salariosColTop10[1] + ".";

const printMedianaSalariesTop10 = document.getElementById("medianaSalariesTop10Col")
printMedianaSalariesTop10.innerText = "La mediana del top 10% de los salarios de la base de datos es: " + medianaTop10Col;

Debemos añadir el parseInt para evitar fallas cuando el arreglo de salarios tiene longitud impar

const spliceStart=parseInt((salariosColSorted.length * 90)/100);

Good class. I need to practice a lot! 🔥👨🏻‍💻

Ya está 😄, no conocía el método .splice. Siempre se aprende algo nuevo.

// Analisis Salarial

// Poniendo a un array los salarios y a otro los nombres
let nombres = [];
let salarios = [];

for (i in peru) {
  nombres.push(peru[i].name);
}
for (i in peru) {
  salarios.push(peru[i].salary);
}
console.log(salarios);

// Promedio, Mediana y Moda del salario top 10%

// Primero ponemos el top 10% en un array

// Funciona con array de numeros
function sacarTopDiezPorCiento(array) {
  let salariosReverse = ordenarMayoraMenor(array); // Ordenamos de mayor a menor
  let cantidadSalarios = array.length;
  let diezPorCiento = (10 / 100) * cantidadSalarios;
  let listaTopDiezPorciento = [];
  for (i = 0; i < diezPorCiento; i++) {
    let salario = salariosReverse[i];
    listaTopDiezPorciento.push(salario);
  }
  listaTopDiezPorciento = ordenarMenoraMayor(listaTopDiezPorciento); // Ordenamos de menor a mayor
  return listaTopDiezPorciento;
}

let topDiezPorciento = sacarTopDiezPorCiento(salarios);
console.log(`Salarios ordenados: ${ordenarMenoraMayor(salarios)}`);
console.log(`Top 10%: ${topDiezPorciento}`);

// Luego sacamos el promedio, mediana y moda de los salarios totales y del Top 10%

let promedioGeneral = promedio(salarios);
let medianaGeneral = mediana(salarios);
let modaGeneral = moda(salarios);

let promedioTop10 = promedio(topDiezPorciento);
let medianaTop10 = mediana(topDiezPorciento);
let modaTop10 = moda(topDiezPorciento);

console.log(`El promedio general: ${promedioGeneral}`);
console.log(`La mediana general: ${medianaGeneral}`);
console.log(modaGeneral);

console.log(`El promedio del top 10%: ${promedioTop10}`);
console.log(`La mediana del top 10%: ${medianaTop10}`);
console.log(modaTop10);

Creo que hay una equivocación en la explicación del método .splice de este ejemplo:

Como se puede ver en el ejemplo, el profe comenta que después del 5 se tomarán se contaran dos valores, y esos dos valores son los que contendrá la variable EJEMPLO, [6.7]. Pero revisando información en mozilla, explican que el primer parámetro ingresado (en este caso 5) se refiere a la posición, no al valor, entonces si se escogió la posición (5,2) los valores a tomar serían los que están después del 4, dando como respuesta a [5,6].

Antes de ver la clase intenté hacerla y me funcionó

Antes de ver el video hice esta función para calcular el porcentaje que queramos de nuestra lista de arrays. No se bien si mi pensamiento lógico está bien o no, pero según yo, si lo hace. veamos 👀


console.log(medianaSalarios(salariosColSorted))

const porcentajeSalarios = (lista, porcentaje = 10) => {
    // Por default es el top 10%
    const porcentajeIni = 100 - porcentaje
  //Sigo la lógica que vimos en el taller de descuento
    const valorTotal = lista.reduce( (acum, valor) => acum + valor)
    const valorPorcentaje = (valorTotal *  porcentajeIni) / 100
    
    const listaPorcentaje = lista.filter( i => i >= valorPorcentaje)

    return listaPorcentaje
}

console.log(porcentajeSalarios(salariosColSorted, 90))

No sabia que podia usar funciones declaradas en otro archivo sin hacer un import ni nada por el estilo. me parece util para un codigo peque;o pero creo que seria problematica debuggear en un codigo mas grande

Las constantes spliceStart y spliceCount pueden dar numeros decimales y eso provocaría un error.
Para solucionarlo habría que hacerle un IntegerParseInt para que funcione cuando el total de personas no sea número par, por ejemplo, si son 19 personas el 90% serían 17.1, entonces al pasarlo a entero darían 17 personas que pertenecen al 90% y el top 10% serían 19 - 17 = 2

El número no corresponde a "500 millones" como se menciona en el video, en realidad serían 50'001.700 Saludos, excelente curso

Se podría sustituir para sacar el 90%

const spliceStart = parseInt(salariosColSorted.length * .9);

Excelente clase!!

Se debe parsear esas constantes para que el código funcione con cualquier cantidad de objetos dados en el array colombia.

const spliceStart = parseInt((salariesColSorted.length * 90) / 100);
const spliceCount = parseInt(salariesColSorted.length - spliceStart);

Ambas son listas ordenadas tanto salariosColSorted como salariosCol
si los comparamos nos dara igual a true

Código en TS:

import colombia from "./salarios"

//* Helpers
function esPar(numerito:number) {
  return numerito % 2 === 0
}

const calculaMediaAritmetica = (lista: Array<number>): number => {
  const sumaLista: number = lista.reduce(
    function(valorAcumulado: number = 0, nuevoElemento: number){
      return valorAcumulado + nuevoElemento
    }
  )

  const promedioLista: number = sumaLista / lista.length
  return promedioLista
}

//*Mediana general
const salariosColombia = colombia.map(
  function (personita) {
    return personita.salary
  }
)

const salariosColombiaOrdenados = salariosColombia.sort(
  function (salaryA: number, salaryB: number): number {
    return salaryA - salaryB
  }
)

//* Calculadora de mediana
function medianaSalarios(lista: Array<number>) {
  const mitad = Math.floor(lista.length / 2)

  if (esPar(lista.length)) {
    const personitaMitad1 = lista[mitad - 1]
    const personitaMitad2 = lista[mitad]
    const media = calculaMediaAritmetica([personitaMitad1, personitaMitad2])
    return media
  } else {
    const personitaMitad = lista[mitad]
    return personitaMitad
  }
}

const medianaGeneralColombia = medianaSalarios(salariosColombiaOrdenados)


//* Mediana del top 10%
const spliceStart: number = (salariosColombiaOrdenados.length * 90) / 100
const spliceCount: number = salariosColombiaOrdenados.length - spliceStart

const salariosColombiaTop10 = salariosColombiaOrdenados.splice(spliceStart, spliceCount)
const medianaTop10Colombia = medianaSalarios(salariosColombiaTop10)

console.log({
  'Mediana general de salarios en Colombia:' : medianaGeneralColombia,
  'Mediana del top 10% de salario en Colombia:' : medianaTop10Colombia
})

Reto completado 😄
Les comparto mi código por si les llega a servir de algo.

Código

/*
    Analizando los salarios de México
*/

//Obteniendo los salarios unicamente.
const obtenerSalarios = arreglo =>{
    return arreglo.map( ele =>{
        return ele.salary;
    })
};
//console.log(obtenerSalarios(salariosMexico));
// (24) [37000, 28434, 34274, 18364, 18700, 12400, 16560, 18373, 19373, 17823, 19734, 27473, 19372, 10834, 16723, 18947, 36427, 19374, 36821, 36482, 26483, 18492, 46283, 25372]

//Ordenando los salarios
const ordenarSalarios = obtenerSalarios(salariosMexico).sort((elementoA, elementoB) =>{
    return elementoA - elementoB;
});
// console.log(ordenarSalarios);
// (24) [10834, 12400, 16560, 16723, 17823, 18364, 18373, 18492, 18700, 18947, 19372, 19373, 19374, 19734, 25372, 26483, 27473, 28434, 34274, 36427, 36482, 36821, 37000, 46283]

/* 
    Calculando la Mediana 
*/
const esPar = arreglo =>{
    if(arreglo.length % 2 === 0){
        return true
    }else{
        return false
    }
}

const obtenerMedio = array => {
    return parseInt((array.length) / 2);
}

let $mediana = 0;

const mediana = array => {
    if(esPar(array)){
        let valorActual = array[obtenerMedio(array)];
        let valorAnterior = array[obtenerMedio(array) - 1];
        // console.log(`Valor actual: ${valorActual}, valorAnterior: ${valorAnterior}`);
        $mediana = ( valorActual + valorAnterior ) / 2;
    }else{
        $mediana = array[obtenerMedio(array)];
    }
    return $mediana;
}

console.log(`La mediana es: ${mediana(ordenarSalarios)}`);
//La mediana es: 19373.5

/*
    Obteniendo el 10% superior de salarios en mexico
*/

const salariosTop = ordenarSalarios.slice((ordenarSalarios.length * (100 - 10)) / 100, ordenarSalarios.length);
const salariosTopMediana = mediana(salariosTop);

console.log(`La mediana de los salarios top es: ${salariosTopMediana}`);

Reultados

//          ===Helpers or Utils===
/**
 *función que verfica sí  un numero es par o no
 * @param {*} p_number, un valor entero
 * @returns true: si  es par,
 *          false: si no es par
 */
function isEven(p_number) {
	result = p_number % 2 === 0;

	console.group('isEven');
	console.log({
		result,
	});
	console.groupEnd();

	return result;
}

/**
 * Ordena una lista de números enteros ascendentemente
 * @param {*} p_list lista de números enteros
 */
function orderList(p_list) {
	// ordena lista de salarios
	const listOrdered = p_list.sort(function (a, b) {
		return a - b;
	});
	return listOrdered;
}
////////////////////////////////

//          ===Mediana===
/**
 * Función encargada de calcular el la media aritmética
 * @param {*} p_list,  recibe un lista de numeros enteros
 * @returns  valueAverage , promedio
 */
function arithmeticAverage(p_list) {
	let valueAcum = 0;
	let valueAverage = 0;

	// Realiza la sumatorias de valores
	valueAcum = p_list.reduce(function (valueAcumulate = 0, valueCurrent) {
		return valueAcumulate + valueCurrent;
	});

	// realiza el calculo de la media aritmética
	valueAverage = valueAcum / p_list.length;

	console.group('arithmeticAverage');
	console.log({
		valueAverage,
	});
	console.groupEnd();

	return valueAverage;
}

/**
 *Calcular la mediana
 * @param {*} p_list:
 * @returns resultMedian: Mediana
 */
function arithmeticMedian(p_list) {
	let valueA = 0;
	let valueB = 0;
	let resultMedian = 0;
	// Se obtiene  la mitad de la lista
	const midList = parseInt(p_list.length / 2);
	// Se Ordena la lista
	p_list = orderList(p_list);

	if (isEven(p_list.length)) {
		// si el tamaño de la lista es par, entonces:
		// se toma el valor de la mitad de la lista
		// y un valor anterior para sacar el promedio
		valueA = p_list[midList - 1];
		valueB = p_list[midList];
		resultMedian = arithmeticAverage([valueA, valueB]);
	} else {
		// Si lista de elementos es impar:
		// se retorna el elemento de la mitad de la lista
		resultMedian = p_list[midList];
	}

	console.group('arithmeticMedian');
	console.log({
		midList,
		resultMedian,
	});
	console.log(p_list);
	console.groupEnd();

	return resultMedian;
}

function arithmeticMedianTop10(listSorted) {
	listSorted = orderList(listSorted);
	const valueStart = (listSorted.length * 90) / 100;
	const valueEnd = listSorted.length - valueStart;

	let listTop10 = listSorted.splice(valueStart, valueEnd);

	let medianaTop10 = arithmeticMedian(listTop10);

	console.group('arithmeticMedianTop10');
	console.log(listSorted);
	console.log({
		valueStart,
		valueEnd,
		medianaTop10,
	});
	console.log(listTop10);
	console.groupEnd();

	return medianaTop10;
}

// se obtiene los salarios de la lista
let listOnlySalaryColombia = colombia.map(function (person) {
	return person.salary;
});

let medianaSalarialGeneralColombia = 0;
let medianaSalarialTop10Colombia = 0;

medianaSalarialGeneralColombia = arithmeticMedian(listOnlySalaryColombia);
medianaSalarialTop10Colombia = arithmeticMedianTop10(listOnlySalaryColombia);

console.group('Result');
console.log({
	medianaSalarialGeneralColombia,
	medianaSalarialTop10Colombia,
});
console.groupEnd();

const salariesArray = (arr) => arr.map((element) => element.salary)
const salariosColombia = salariesArray(colombia)
console.log(salariosColombia)

const sortArray = (arr) => arr.sort((x, y) => x - y)
const salariosColOrdenados = sortArray(salariosColombia)
console.log(salariosColOrdenados)

function calcularMediana (arr) {
    const esPar = (num) => (num % 2 === 0)
    const half = parseInt(arr.length / 2)
    if (esPar(arr.length)) {
        const half2 = half - 1
        const mediumOfHalfs = (arr[half ]+ arr[half2]) / 2 
        return mediumOfHalfs
    } else {
        const halfElement = arr[half]
        return halfElement
    }
}

const medianaSalariosColombia = calcularMediana(salariosColOrdenados)
console.log(medianaSalariosColombia)

const topTenPercent = (arr) => {
    const tenPercent = parseInt(arr.length * 0.1)    
    const startIndex = arr.length - tenPercent
    return arr.splice(startIndex, tenPercent)
} 

const topTenPercentColombiaSalaries = topTenPercent(salariosColOrdenados)
console.log(topTenPercentColombiaSalaries)

console.log(calcularMediana(topTenPercentColombiaSalaries))
<code> 

Esta buena la clase , toca checar el codigo y mirarlo bien. Para entender que hace cada que

Creo que esta forma de realizar el desafío es mas optima, que opinan?

const arrSalariosOrd = arrSalarios.sort((a, b)=>{
    return b - a; //invertiendo los parametros conseguimos un orden descendente y facilita mas buscar el top
})

const numPersonasTop10 = arrSalariosOrd.length * 0.1; //aqui decimos que queremos el 10% del total de los elementos

const arrPersonasTop10 = arrSalarios.splice(0, numPersonasTop10);

console.log(medianaSalarios(arrPersonasTop10));

Le agregue estas funciones al código, pues cuando se hace el calculo de cuantas personas hay en el top 10, puede que se obtengan números decimales (float) para algunas cantidades de salarios, y cuando esto pasa, el código no da los resultados esperados, pues el método splice no esta recibiendo los argumentos correctos.
Math.floor redondea el numero que se le entrega como argumento al numero entero inferior mas cercano.
Y Math.ceil redondea el numero que se le entrega como argumento al numero entero superior mas cercano.

  const salariosColTop10 = salariosColSorted.splice(
    Math.floor(spliceStart),
    Math.ceil(spliceCount)
  );

Mi diseño para este taller!

🦄Amigos con una conexión con HTML me quedó una buena aplicación n.n✨

Repositorio completo en mi GitGub ✨

https://codepen.io/edmundo0994/pen/LYOOEee

Es un poco más complicado todo lo que hice pero comente para que se entienda un poco mejor, suerte c:

Con .Splice(); puedes quitar elementos** y agregar nuevos al mismo tiempo**. A continuación un ejemplo:

let months = ["January", "February", "Monday", "Tuesday"];
let days = months.splice(2, 2, "March", "April");

console.log(days); // ["Monday", "Tuesday"]
console.log(months); // ["January", "February", "March", "April"]

Datos Oficiales Colombia
Yo estuve trabajando con este archivo el cual obtuve del DANE para el 2021 y aquí van mis resultados en cuanto a esas medianas en los salarios

  • $ 909.500 (un salario mínimo del 2021)
    Es la mediana en general de todos los salarios en esa lista (hay como 6300)

  • $ 3.600.000
    Es la mediana del top 10% de salarios en Colombia

He visto ofertas en linkedin y otras plataformas donde puestos para desarrollo de software ofrecen salarios incluso aun mayores a los reflejados en esa mediana del top 10.
Interesantes conclusiones que Freddy Vega ya ha mencionado en algunos videos sobre la posibilidad de tener los salarios mas altos si somos parte de la industria TI y por otro lado la situación del trabajo formal en el pais, que describe como muchos hogares tienen que sobrevivir con un salario mínimo mensual e incluso menos que eso

Solo como dato:
Hay otra función parecida a splice llamada slice, que se me hace mucho más cómoda:

El método slice () devuelve un subarray de un array usando dos indices como argumentos: [start, end) (el elemento en la posición end se excluye)

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2, 4));  //recuerda que el elemento  en el indice 4 no se incluye

Resultado esperado: Array [“camel”, “duck”]

Por lo tanto, seleccionar el 10% se pudo haber hecho asi:

const salariosColTop10 = salariosColSortes.slice(spliceStart, salariosColSortes.length);

Cambie el método splice() por el método filter() de esta manera:

onst start = salariosSorted[ salarios.length * 0.9];
const top10 = salariosSorted.filter(
    function(elemento){
        return elemento >= start;
    }
)

No digo que sea mejor, pero yo queria imprimir la lista de salarios y con splice tenia el inconveniente que modifica el array salariosSorted. Por eso usé filter.

Codigo JS:

//Helpers

const esPar = (numero)=> numero%2===0;

function calcularPromedio(lista) {
    const sumaLista = lista.reduce(
        function (valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado + nuevoElemento;
        }
    );

    const promedioLista =  sumaLista/lista.length;

    return promedioLista;
}

// Calculadora  de medianas
function medianaSalarios(lista) {
    const mitad = parseInt(lista.length / 2);
    let mediana;

    if(esPar(lista.length)){
        const elem1 = lista[mitad - 1];
        const elem2 = lista[mitad];
        const promElem1y2 = calcularPromedio([
            elem1,
            elem2
        ]);
        mediana = promElem1y2;
    }else{
        mediana = lista[mitad]
    }
    return mediana;
}

// Mediana general
const salariosCol = colombia.map((per)=>{
    return per.salary;
})

const salariosColSorted = salariosCol.sort((salaryA,salaryB)=>salaryA-salaryB);

const medianaGeneralCol = medianaSalarios(salariosColSorted);

// Mediana del top 10%

const spliceStart = (salariosColSorted.length * 90) / 100;

const spliceCount = salariosColSorted.length - spliceStart;

const salariosColTop10 = salariosColSorted.splice(spliceStart,spliceCount);

const medianaTop10Col = medianaSalarios(salariosColTop10);

console.log(
    medianaGeneralCol,
    medianaTop10Col
)

Les comparto la resolucion de calcular el top 10% en una linea de codigo

Pensado en la siguiente fomula:
No necesitamos expresar una division simplemente anteponemos el punto decimal

valor*.porcentajeQueQueremos-valor
Ejemplo: 100*.90-100

const top10Country = listMedianaNeat.slice(listMedianaNeat.length*.90-listMedianaNeat.length)

Excelente explicación del método splice.

Por si a alguien le resultó la variable medianaTop10Col como NAN acá una posible solución:

const salariosColTop10 = salariosColSorted.splice( 
	Math.round( spliceStart ),
	Math.round( spliceCount ),
);

Humilde, pero honesto 😄

// Helpers
function esPar(numero) {
    return (numero % 2 === 0);
}

function calcularMediaAritmetica(lista) {

    const sumaLista = lista.reduce(
        function (valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado + nuevoElemento;
        }
    );

    const promedioLista = sumaLista / lista.length;

    return promedioLista;
}



const salariosCol = colombia.map(

    function (persona) {

        return persona.salary

    }
);

// Calculadora de mediana 

function medianaSalarios(lista){
    const mitad = parseInt(lista.length / 2);

    if(esPar(lista.length)){
        const personaMitad1 = lista[mitad - 1];
        const personaMitad2 = lista[mitad];


        const mediana = calcularMediaAritmetica([personaMitad1, personaMitad2]);
        return mediana;
    } else {
        const personaMitad = lista[mitad];
        return personaMitad;
    }
}

// Mediana General
const salariosColSorted = salariosCol.sort(
    function (salaryA, SalaryB) {

        return salaryA - SalaryB;

    }
);


const medianaGeneralCol = medianaSalarios(salariosColSorted);


// Mediana de top 10%
// (120 * (100 - 15)) / 100 

const spliceStart = (salariosColSorted.length * 90) / 100;
const spliceCount = salariosColSorted.length - spliceStart;

const salariosColTop10 = salariosColSorted.splice(
    spliceStart,
    spliceCount,
);


const medianaTop10Col = medianaSalarios(salariosColTop10);


console.log({
    medianaGeneralCol,
    medianaTop10Col,
});

Ejercicio de la Clase

const medianaGeneralCol = medianaSalarios(salarioColSorted);

//Mediana del Top 10%

const spliceStart = (salarioColSorted.length * 90) / 100;
const spliceCount = salarioColSorted.length - spliceStart;

const salariosColTop10 = salarioColSorted.splice(
    spliceStart,
    spliceCount
);

const medianTop10Col = medianaSalarios(salariosColTop10);

console.log({
    medianaGeneralCol,
    medianTop10Col
});

Hice el código que retorna el top 10% y el público general, pero de una manera algo direfente a como lo hizo el profe.
Sin embargo, me falta agregar una validación para cuando se pasa sueldos que son menores que 0 o cuando se pone data sin sueldo.

function dataSort (dataList) {
    dataList.sort(function(previousIter, subsequentlyIter) {
        return previousIter - subsequentlyIter;
    });
    return dataList;
}

function generalSalary (dataList) {
    // const tenPercent = Math.round(dataList * 0.1);
    const dataListLenght = dataList.length;
    const ninetyPercert = Math.round(dataListLenght * 0.9);
    // console.log(ninetyPercert);
    // console.log(dataListLenght)
    const dataListSorted = dataSort(dataList);
    // const topTenPercent = [];
    const generalSalary = [];
    for (let i = 0; i < ninetyPercert; i++) {
        generalSalary.push(dataListSorted[i]);
    }
    return generalSalary;
}

function topSalary (dataList) {
    // const tenPercent = parseInt(dataList * 0.1);
    const dataListLenght = dataList.length;
    const ninetyPercert = Math.round(dataListLenght * 0.9);
    // console.log(ninetyPercert);
    const dataListSorted = dataSort(dataList);
    const topTenPercent = [];
    // const generalSalary = [];
    if (ninetyPercert !== dataListLenght) {
        for (let i = ninetyPercert; i < dataListLenght; i++) {
            topTenPercent.push(dataListSorted[i]);
        }
        return topTenPercent;
    }
    else {
        console.log("There's not enough data.")
    }
    
}

excelente ejercicio, lo trate de hacer el ejercicio antes de ver la clase completa y en vez de utilizar split, utilice push para ir guardando el top 10% de los salarios:

const cantidadSalaros = salariosMx.length;
const topSalarios = [];
let i = 0;
const topLevel = parseInt(cantidadSalaros * .10);
console.log(topLevel);
while (i < topLevel) {
    i++;
    topSalarios.push(salarySorted[cantidadSalaros - i]);
}
// helpers
function esPar(numerito) {
    return (numerito % 2 === 0);
}
function calcularMediaAritmetica(lista) {
    const sumaLista = lista.reduce(
        function (valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado + nuevoElemento;
        }
    );
    const promedioLista = sumaLista / lista.length;

    return promedioLista;
}

// Calculadora de mediana
function medianaSalarios(lista) {

    const mitadLista = parseInt(lista.length / 2);
    if (esPar(lista.length)) {
        const personitaMitad1 = lista[mitadLista - 1];
        const personitaMitad2 = lista[mitadLista];
        const mediana = calcularMediaAritmetica([personitaMitad1, personitaMitad2])
        return mediana
    } else {
        const personitaMitad = lista[mitadLista];
        return personitaMitad;
    }
}

// Mediana General

const salariosCol = colombia.map(
    function (personita) {
        return personita.salary
    }
);

const salariosColSorted = salariosCol.sort(
    function (salaryA, salaryB) {
       return salaryA - salaryB;
    }
);

const medianaGeneralCol = medianaSalarios(salariosColSorted);

// Mediana del top 10%
const spliceStart = (salariosColSorted.length *  0.9);
const spliceCount = salariosColSorted.length - spliceStart;

const salariosColTop10 = salariosColSorted.splice(
    spliceStart, 
    spliceCount
);
const medianaTop10Col = medianaSalarios(salariosColTop10);




console.log({
    medianaGeneralCol,
    medianaTop10Col,
});

Yo me rompí la cabeza con .filter y luego veo splice y slice :'l Lo bueno es que ahora y sé 2 maneras. Les dejo la forma que hice con .filter

let valorTop = salariosOrdenados.filter((elemento, posicion, arreglo) => {
    if (posicion >= arreglo.length - cantidadTop(10, salariosOrdenados)){
         return elemento;
     }
 });
function cantidadTop (porcentaje, arreglo) {
    return (porcentaje * arreglo.length) / 100;
}

Abajo es la función para sacar la cantidad de personas del TOP “X”% introduciendo cualquier array ordenado

Aquí esta mi solución , por si les ayuda.

const listado = [];  // Mi array de 20 objetos con las  personas  y salarios.  
const salaryOflist = listado.map(person => person.salary);
const salaryOrder = salaryOflist.sort((salarya, salaryb) => salarya - salaryb);

function getMedian(lista) {
    const middle = parseInt(lista.length / 2);
    if (lista.length % 2 === 0){
        const numbera = lista[middle - 1];
        const numberb = lista[middle];
        result =  (numbera + numberb) / 2;
/*         console.log(`Result ${result}  Middle es ${middle}, A es ${numbera}, B es ${numberb} `);*/
        return result;
    }else{
/*         console.log(`Result  else ${lista[middle]} Middle es :  ${middle}`);*/
        return lista[middle];
    }
}
console.log(salaryOrder);
const salaryMedian = getMedian(salaryOrder);
const listStar = parseInt(salaryOrder.length * .9);
const list10 = parseInt(salaryOrder.length - listStar);
const salarytop10 = salaryOrder.splice(listStar, list10);```

Les comaprto!

// salaries.js file loaded in HTML, I can use it here
const salariesOfColombia = colombia.map(
  function (person) {
    return person.salary;
  }
);

const isEven = (num) => num % 2 === 0 ? true : false;
const halfOfList = (list) => parseInt(list.length / 2);
const sortList = (list) => list.sort((elementA, elementB) => elementA - elementB );

const listAverage = (list) => {
  const reducedList = list.reduce(
    (accumValue = 0, nextValue) => accumValue + nextValue
  );
  return reducedList / list.length;
}
const medianOfList = (list) => {
  list = sortList(list);
  if (isEven(list.length)) {
    const firstHalf = list[halfOfList(list) - 1];
    const secondHalf = list[halfOfList(list)];
    return listAverage([firstHalf, secondHalf]);
  } else {
    return list[halfOfList(list)];
  }
}

const colombianSalaries = sortList(salariesOfColombia);

const get10Percentage = (list) => {
  const listLength = list.length;
  const get10PercentageOfList = (listLength * 90) / 100;
  const count = listLength - get10PercentageOfList;
  return list.splice(get10PercentageOfList, count);
}

const top10PercentageColombianSalaries = get10Percentage(colombianSalaries);

const generalMedianColombianSalaries = medianOfList(colombianSalaries);
const top10MedianColombianSalaries = medianOfList(top10PercentageColombianSalaries)

console.log('generalMedianColombianSalaries', generalMedianColombianSalaries);
console.log('top10MedianColombianSalaries', top10MedianColombianSalaries);

En la explicación del splice tiene un pequeño error, en verdad no toma el 6 y 7 sino el 5 y 6.

const array = [0,1,2,3,4,5,6,7,8,9,10];

array.splice(5, 2);
// devuelve [5, 6]
// y el array original queda de esta forma: [0, 1, 2, 3, 4, 7, 8, 9, 10]

Toca redondear Math.round() o utilizar un parseInt() en spliceStart porque si el array o la lista es impar los valores se pueden calcular mal, algo como esto:

const array = [0,1,2,3,4,5,6,7,8,9,10];

const spliceStart = (array.length * 90) / 100;
const spliceCount = array.length - spliceStart;
const medianaTop10Col = array.splice(spliceStart, spliceCount);

spliceStart = 9.9
spliceCount = 1.09999999996
medianaTop10Col = [9]

Explicación Método Splice

cuesta un poco al principio ubicarse con el nombre de las variables, pero nada fuera de limite toca ponerse firme la concentración…

hoy simplemente queria comentar mi codigo xd

// Helpers & Utils
function esPar(numerinchi) {
    return (numerinchi % 2 === 0);
}



const salariosCol = colombia.map(
    function (personita){
        return personita.salario;
    }
);

const salariosColSort = salariosCol.sort(
    function (a, b){
        return a - b;
    }
);


function CalcularPromedioAritmetica(lista) {
    const sumaLista = lista.reduce(
        function (valorAcumulado = 0, nuevoElemento) {
            return valorAcumulado + nuevoElemento;
        }
    );
    
    const promedioLista = sumaLista / lista.length;
    return promedioLista;
}

function medianaSalarios(lista) {
    const mitad = parseInt(lista.length / 2);

    if (esPar(lista.length)) {
        const personaMitad1 = lista[mitad - 1];
        const personaMitad2 = lista[mitad];
        const promediolistiñi = CalcularPromedioAritmetica([personaMitad1, personaMitad2]);
        return promediolistiñi;
    } else {
        const personaMitad = lista[mitad];
        return personaMitad
    }
}

const medianaGeneralCol = medianaSalarios(salariosColSort);


// Mediana del TOP 10%

const sliceStart = (salariosColSort.length * 90) / 100;
const slice1 = salariosColSort.length - sliceStart;
const slice2 = salariosColSort.length - slice1; 
const salariosColTop10 = salariosColSort.slice(slice2, salariosColSort.length);
const medianaTop10Col = medianaSalarios(salariosColTop10);


console.log({
    salariosColSort,
    medianaGeneralCol,
    salariosColTop10,
    medianaTop10Col,
});

Mi funcion para sacar el array con los elementos que corresponden al top 10%

// array con el 10% de los salarios mas altos
function diezPorciento(lista) {
    const diezPorciento = lista.slice(parseInt(lista.length * 0.9)); 
    return diezPorciento;
}

Yo lo hice de esta manera, creo que reduciendo bastante código:

const salarios = colombia.map(item => item.salary);
salarios.sort((a, b) => a - b);

const top10Salarios = salarios
    .sort((a, b) => b - a)
    .filter((item, i, array) => array.indexOf(item) === i)
    .slice(0, 10);

console.log("Salarios:", salarios);
console.log("Top 10:", top10Salarios);

Me resultó hacer parseInt al length de la lista para determinar el top 10. Dejo mi código:

/* Helpers */
const isEven = (a) => a % 2 === 0;

const calcMedia = (lista) =>
  lista.reduce((acum = 0, value) => acum + value) / lista.length;

const calcMediana = (lista) =>
  isEven(lista.length)
    ? calcMedia([
        lista[parseInt(lista.length / 2) - 1],
        lista[parseInt(lista.length / 2)],
      ])
    : lista[parseInt(lista.length / 2)];

/* Colombia */
const salariosCol = colombia.map((person) => person.salary)

const salariosColSort = salariosCol.sort((a,b)=> a-b);

/* General  */
const promedioGralCol = calcMedia(salariosColSort);

const medianaGralCol = calcMediana(salariosColSort);

/* Top10 */
const spliceStart = parseInt((salariosColSort.length * 90) / 100);
const spliceCount = salariosColSort.length - spliceStart;

const colTop10 = salariosColSort.splice(spliceStart, spliceCount);

const promedioTop10 = calcMedia(colTop10);

const medianaTop10 = calcMediana(colTop10);

/*Validation Logs: */
console.log(
  `Promedio general de salarios de Colombia: ${promedioGralCol}
  \nMediana general de salarios de Colombia: ${medianaGralCol}
  \nPromedio general del 10% más alto: ${promedioTop10}
  \nMediana del 10% más altos: ${medianaTop10}`
);

Método reduce() Explicacion
17:49 REDUCE

Mediana Salarios Top 10%

function calcularMedianaSalariosTop10(listaSalarios)
{
    const listaOrdenada = ordenarListaSalarios(listaSalarios);
    const spliceStart = parseInt(listaOrdenada.length * 0.90);
    const splicePositions = listaOrdenada.length - spliceStart;

    const SalariosTop10 = listaOrdenada.splice(spliceStart, splicePositions);
    console.log("El top 10 de salarios en el país son");
    console.log({SalariosTop10});

    const PosicionMitad = parseInt(SalariosTop10.length / 2);

    if (esPar(SalariosTop10.length))
    {
        const indexMitad1 = PosicionMitad - 1;
        const indexMitad2 = PosicionMitad;     
        const salariosMitad1 = SalariosTop10[indexMitad1];
        const salariosMitad2 = SalariosTop10[indexMitad2]; 
        const mediana = calcularMediaAritmetica([salariosMitad1, salariosMitad2]);
        return mediana;

    }
    else
    {     
        const mediana = SalariosTop10[PosicionMitad];           
        return mediana;
    }
}

Hola que tal compañeros de este maravilloso viaje de aprendizaje.
Analizando el método splice noté que el método no se comporta exactamente como se menciona en el minuto 4 47. Si bien se entiende quise hacerle una prueba al método.
Resulta que el cuchillo como lo llama el profesor no entra después sino antes como lo podemos ver en el siguiente código de ejemplo:

const arrayEjemplo = [0,1,2,3,4,"Francisco 5","Sandra 6",7,8,9,10];
const spliceEjemplo = arrayEjemplo.splice(5,3);

console.log(arrayEjemplo);
console.log(spliceEjemplo);

//resultado
//arrayEjemplo [0, 1, 2, 3, 4, 8, 9, 10] 
//spliceEjemplo ["Francisco 5", "Sandra 6", 7] 

/*[0,1,2,3,4,||||||cuchillo||||||"Francisco 5","Sandra 6",7,8,9,10]*/
/*splice(5,3) el 3 indica las posiciones a la derecha que tomaremos o sea se toma el indice 5 el 6 y el 7*/

Splice significa empalmar.
El método Splice modifica el array original.
Existe un método similar llamado slice sin la p.
Este método hace algo parecido pero no modifica el array original.
Slice significa rebanada.

El segundo argumento de slice “Rebanada” no opera de la misma manera que splice “Empalmar” cuidado.

Splice no trabaja con numero de posiciones a la derecha sino con desde que indice hasta que indice se hará el corte. Ejemplo:
[0,1,2,3,4,5,6,7,8,9]
slice(3, 7)
[0,1,2,|||||corte inicial|||||3,4,5,6,||||corte final|||||7,8,9]
Resultado [3,4,5,6] y el array original no se ve afectado.

function prueba()
{
const array = [0,1,2,3,4,5,6,7,8,9];
const arraySlice = array.slice(3, 7);
console.log("Array original " + array);
console.log("Array slice" + arraySlice);

}

prueba();
//Array original 0,1,2,3,4,5,6,7,8,9
//Array slice 3,4,5,6

Gracias por leer 😃

Mi código 😃

//helpers
function esPar(num)
{
    return num % 2 === 0;   

}

function calcularMediaAritmetica(array)
{
    const sumarArray = array.reduce(
        function (valorAcumulado, nuevoElemento)
        {
            valorAcumulado = valorAcumulado + nuevoElemento;
            return valorAcumulado;
        }        
    );
    
    const mediaArray = sumarArray / array.length;
    return mediaArray;    
}


//hallar la mediana del array de objetos salariosColombia
//pero primero debemos ordenar el array

const salariosCol = salariosColombia.map
(
    function (elemento)
    {
        return elemento.salario;
    }

);

const salariosColOrdenados = salariosCol.sort
(
    function (salarioA, SalarioB)
    {
        return salarioA - SalarioB;
    }
); 

let mediana;

const mitad = parseInt(salariosColOrdenados.length / 2);


if (esPar(salariosColOrdenados.length)) //ES LENGTH   TH AL FINAL!!!!!
{
    const mitad1 = mitad - 1;
    const mitad2 = mitad;
    const arrayDosMitades = [ salariosColOrdenados[mitad1], salariosColOrdenados[mitad2] ];
    console.log(arrayDosMitades);
    mediana = calcularMediaAritmetica(arrayDosMitades);    
}

else
{
    mediana = salariosColOrdenados[mitad]; 
}

console.log("Salarios Ordenados de menor a mayor a continuación")
console.log(salariosColOrdenados);
console.log("La MEDIANA de los salarios de toda Colombia es " + mediana);

// ahora hallaré la media aritmética del top 10% de salarios de Colombia
const porcentajeExcluido = 0.90;
const top10Indice = parseInt(salariosColOrdenados.length * porcentajeExcluido);

const salariosColTop10 = salariosColOrdenados.splice(top10Indice, salariosColOrdenados.length - 1);
console.log("El 10% de salarios más altos de Colombiaa continuación");
console.log(salariosColTop10);

const mediaAritmeticaTop10 = calcularMediaAritmetica(salariosColTop10);
console.log(`La media aritmética del top ${Math.ceil((1-porcentajeExcluido)*100)}
% es ${mediaAritmeticaTop10}`);

Excelente curso estoy muy contento de aprender estos metodos basicos pero necesarios.

dejo mi codigo con comentarios actualmente lo manejo todo en ingles.

//Helpers

//This one let me know if the number of data in the array it's even and odd

// So this entire function can be express in just one line  because the "true and false" are given be default  by this (number % 2 === 0)

// function esPar (number){ 
//     if (number % 2 === 0) {
//         return true;
//     }else{
//         return false;
//     }
// }

function esPar (number){
    return (number % 2 === 0);
}


// This one calculate the Average
function calculateAverage(list1){
    let sumaList = 0;
    for(let i=0; i< list1.length; i++){
        sumaList = sumaList + list1[i];
    }

    const average = sumaList / list1.length;
    return average;
}

//Calculate median
// This one calculate the Median
function medianSalary(list){
    const mid =parseInt(list.length/2);

    if (esPar(list.length)){
        const midPerson1 = list[mid -1];
        const midPerson2 = list[mid];

        const median = calculateAverage([midPerson1,midPerson2]);
        return median;
    }else{
        const midPerson = list[mid];
        return midPerson;
    }
}


//General Median

// This function make the array and take the salary for each one of the objects 
const salaryCol = Colombia.map(
    function(people){
        return people.salary;
    }
);

// This one sorted the salarys from the lowest to the highest
const salarySorted = salaryCol.sort(
    function(salaryA,SalaryB){
        return salaryA-SalaryB;
    }
);

// Top 10% median 
const spliceStart = (salarySorted.length *90 )/100;
const spliceCount = salarySorted.length - spliceStart;
const salaryTop10Col = salarySorted.splice(spliceStart,spliceCount);

const medianGeneral = medianSalary(salarySorted);
const medianTop10Col = medianSalary(salaryTop10Col);

console.log({
    medianGeneral,
    medianTop10Col,
});

Estuve haciendo el mismo código, pero vi que existían las funciones flecha y ayuda a tener un código más legible y con menos líneas, tal vez pueda mejorar mi código, pero aquí está cómo lo hice yo:

// Calculadora de mediana 
let esPar = number => number%2==0;
function medianaSalarios(lista){
    const mitadLista = Math.floor(lista.length/2);
    if(esPar(lista.length)) {
        return (lista[mitadLista -1] + lista[mitadLista])/2;
    } else {
        return lista[mitadLista];
    }
}
//Mediana General}
const salarios = colombia.map(obj => obj.salary);
const salariosSorted = salarios.slice().sort((a,b) => a-b);
const medianaGeneral = medianaSalarios(salariosSorted);
//Mediana Top 10%
const spliceStart = Math.floor((salariosSorted.length * 9) / 10);
const spliceCount = salariosSorted.length - spliceStart;
const salariosTop10 = salariosSorted.slice().splice(spliceStart, spliceCount);
const medianaTop10 = medianaSalarios(salariosTop10);
console.log({medianaGeneral, medianaTop10});

Para los que tal vez no están entendiendo mucho este curso, está bueno tomar primero el de Manipulación de Arrays, que ayuda a entender todos estos métodos

El método “slice” puede ser mejor en este caso. Este método sencillamente hace un nuevo array sin modificar el original. Toma dos parámetros: punto inicial y punto final.

Ejemplo:

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
const modifiedNumbers = numbers.slice(7, 10);
console.log(modifiedNumbers);
//El resultado será un nuevo array sin eliminar el original, con los números 8, 9, 10.

Splice => Si quieres modificar el array original.
Slice => Si quieres hacer un nuevo array modificado sin cambiar el original.

Alternativa de solución

Intenté resolver el problema de tomar el top 10% de salarios ante de ver como lo resuelve el profesor en la clase, comparto mi solución (hasta abajo en texto por si gustan copiarla)

//MEDIANA TOP 10%

const DiezPorCiento = arr => {
    const porcentajeValores = arr.length * .1;
    return porcentajeValores;
}

const topDiezPorCiento = arr => {
    const index = (DiezPorCiento(arr) + 1);
    const topDiez = arr.filter(item => arr.indexOf(item) > arr.length - index)
    return topDiez;
}

Muy buena clase!
Solo quiero puntualizar que el código de la clase puede que nos de respuestas incorrectas en algunos casos.
.
Especialmente quiero puntualizar esta sección del código:

const spliceStar = (salariosColSorted * 90) / 100;
const spliceCount = salariosColSorted.length - spliceStart;

Funciona muy bien para las longitudes de arrays que sean multiplos de 10 pero que pasa si nuestro array tiene una longitud de 12?
(12 * 90) / 100 = 10.8
12 - 10.8 = 1.2
Estariamos llamando al metodo .splice de esta manera:

salariosColSorted.splice(10.8, 1.2);
//¿Remueve 1.2 elementos del array?

Al final lo que termina pasando es que tal vez JS aplica una especie de funcionalidad Math.floor para obtener los números enteros más altos menores que 10.8 y 1.2 (que serían 10 y 1).
Nosotros quisieramos obtener los 2 ultimos elementos del array, no 1.
.
¿Solución?
Llamar precisamente a la función Math.floor (ó .parseInt) para que spliceStart sea entero:

const spliceStar = (salariosColSorted * 90) / 100;
const spliceCount = salariosColSorted.length - Math.floor(spliceStart);  //12 - 10

Se que 10 no es exactamente el 90% de 12, pero es preferible que sacar la media del salario de 1.2 personas.

Yo les recomiendo siempre comertar su codigo esto hace mas legible y da una pista de lo que estas haciendo

Hay dos cosas que me di cuenta realizando prácticas de los ejercicios de esta clase.

La función splice y la función sort MODIFICAN EL ARREGLO ORIGINAL incluso si se usan dentro de una función. Tomen esto en cuenta si más adelante necesitan los elementos del arreglo que se encuentren íntegros.

Otra cosa. En la declaración:

const salariosColSorted = salariosCol.sort(
  function (salaryA, salaryB) {
    return salaryA - salaryB;
  }
);

la parte de const salariosColSorted = no crea una copia del arreglo, sino un apuntador a los datos del arreglo original.
O sea, si modificamos salariosColSorted (realizar un push sobre el arreglo) esa acción también se verá reflejada en salariosCol

Falto el -1 en el cálculo del indexStart. Esta es la formula que usé usando el metodo slice y omitiendo el segundo parametro para que obtengan los valores hasta el indice final 😄

function mediaTop10 (arr){
    indexStart = Math.round((arr.length-1) - ((arr.length-1)*0.1))
    let orderArr = orderList(arr);  // ordenar lista
    let arrTop10 = orderArr.slice(indexStart);
    return arrTop10;
}

// Helpers
function esPar(numerito) {
  return (numerito % 2 === 0);
}

function calcularMediaAritmetica(lista) {
  const sumaLista = lista.reduce(
    function (valorAcumulado = 0, nuevoElemento) {
      return valorAcumulado + nuevoElemento;
    }
  );
  const promedioLista = sumaLista / lista.length;
  return promedioLista;
}

// Calculadora de mediana
function medianaSalarios(lista) {
  const mitad = parseInt(lista.length / 2);

  if (esPar(lista.length)) {
    const personitaMitad1 = lista[mitad - 1];
    const personitaMitad2 = lista[mitad];

    const mediana = calcularMediaAritmetica([personitaMitad1, personitaMitad2]);
    return mediana;
  } else {
    const personitaMitad = lista[mitad];
    return personitaMitad;
  }
}
<!DOCTYPE html>
<html lang="es">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Salarios</title>
</head>

<body>
    <h1>Salarios</h1>

    <script src="./salarios.js"></script>
    <script src="./analisis.js"></script>
</body>

</html>
function diezPorcientoSuperior (salarios){
    const diezPorciento = salariosOrdenados[Math.round(cantidad * 0.1)];
    return diezPorciento;
}

les dejo un buen video que explica los metodos de los array
https://www.youtube.com/watch?v=bkgXlQp5hbI

11:05 son cincuenta millones y no quinientos 😃