Análisis salarial con JavaScript

Se supone que era por terminal, pero… haaa no tenia que complicarlo mas 😅
 

 
Aun no he hecho lo de la proyección salarial por que me demore haciendo la grafica desde cero.
 
Desconozco si exista alguna herramienta para hacerla pero pues ya la hice, en fin quería hacer algo mas visual y he aquí el resultado.
 
si quieren checar el código y/o copiarlo pueden verlo en mi github y si lo quieren probar les dejo la github page

Una vez en el enlace me aparecía un poco desorganizada la información de los salarios, acá se las dejo para copiar y pegar.

const salarios=[];
salarios.push({
    name:'Juanita',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:250,},
        {year:2019,empresa:'Freelance',salario:250,},
        {year:2020,empresa:'Industrias Mokepon',salario:850,},
        {year:2021,empresa:'Industrias Mokepon',salario:1050,},
        {year:2022,empresa:'Industrias Mokepon',salario:1250,},
        {year:2023,empresa:'Industrias Mokepon',salario:1250,},
    ],
});
salarios.push({
    name:'Alex',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:450,},
        {year:2019,empresa:'Freelance',salario:550,},
        {year:2020,empresa:'Freelance',salario:400,},
        {year:2021,empresa:'Industrias Mokepon',salario:1050,},
        {year:2022,empresa:'Industrias Mokepon',salario:1250,},
        {year:2023,empresa:'Industrias Mokepon',salario:1250,},
    ],
});
salarios.push({
    name:'Nath',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:600,},
        {year:2019,empresa:'Freelance',salario:625,},
        {year:2020,empresa:'Freelance',salario:575,},
        {year:2021,empresa:'MarketerosCOL',salario:1000,},
        {year:2022,empresa:'MarketerosCOL',salario:1000,},
        {year:2023,empresa:'MarketerosCOL',salario:1100,},
    ],
});
salarios.push({
    name:'Julia',
    trabajos:[
        {year:2018,empresa:'MarketerosCOL',salario:1000,},
        {year:2019,empresa:'MarketerosCOL',salario:2000,},
        {year:2020,empresa:'MarketerosCOL',salario:2000,},
        {year:2021,empresa:'MarketerosCOL',salario:2000,},
        {year:2022,empresa:'MarketerosCOL',salario:2000,},
        {year:2023,empresa:'MarketerosCOL',salario:2000,},
    ],
});
salarios.push({
    name:'Jonatan',
    trabajos:[
        {year:2019,empresa:'MarketerosCOL',salario:1000,},
        {year:2020,empresa:'MarketerosCOL',salario:1000,},
        {year:2021,empresa:'MarketerosCOL',salario:800,},
        {year:2022,empresa:'MarketerosCOL',salario:900,},
        {year:2023,empresa:'MarketerosCOL',salario:1000,},
    ],
});
salarios.push({
    name:'Armando',
    trabajos:[{year:2018,empresa:'Freelance',salario:750,},
    {year:2019,empresa:'Freelance',salario:750,},
    {year:2020,empresa:'Freelance',salario:750,},
    {year:2021,empresa:'Freelance',salario:850,},
    {year:2022,empresa:'Freelance',salario:850,},
    {year:2023,empresa:'Freelance',salario:850,},
],
});
salarios.push({
    name:'Dilan',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:500,},
        {year:2019,empresa:'Freelance',salario:500,},
        {year:2020,empresa:'Freelance',salario:600,},
        {year:2021,empresa:'Mokepon',salario:1100,},
        {year:2022,empresa:'Mokepon',salario:1100,},
        {year:2023,empresa:'Mokepon',salario:1100,},
    ],
});
salarios.push({
    name:'Zamir',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:400,},
        {year:2019,empresa:'Freelance',salario:500,},
        {year:2020,empresa:'Freelance',salario:500,},
        {year:2021,empresa:'Mokepon',salario:1100,},
        {year:2022,empresa:'Mokepon',salario:1100,},
        {year:2023,empresa:'Mokepon',salario:1200,},
    ],
});
salarios.push({
    name:'Daniela',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:500,},
        {year:2019,empresa:'Freelance',salario:500,},
        {year:2020,empresa:'Freelance',salario:500,},
        {year:2021,empresa:'Freelance',salario:550,},
        {year:2022,empresa:'Freelance',salario:550,},
        {year:2023,empresa:'MarketerosCOL',salario:850,},
    ],
});
salarios.push({
    name:'Daniel',
    trabajos:[
        {year:2020,empresa:'Freelance',salario:150,},
        {year:2021,empresa:'Freelance',salario:450,},
        {year:2022,empresa:'Freelance',salario:550,},
        {year:2023,empresa:'Freelance',salario:650,},
    ],
});
salarios.push({
    name:'Rigoberto',
    trabajos:[
        {year:2018,empresa:'MarketerosCOL',salario:700,},
        {year:2019,empresa:'MarketerosCOL',salario:700,},
        {year:2020,empresa:'MarketerosCOL',salario:700,},
        {year:2021,empresa:'MarketerosCOL',salario:750,},
        {year:2022,empresa:'MarketerosCOL',salario:750,},
        {year:2023,empresa:'MarketerosCOL',salario:750,},
    ],
});
salarios.push({
    name:'Alicia',
    trabajos:[
        {year:2018,empresa:'Inversionify',salario:300,},
        {year:2019,empresa:'Inversionify',salario:1700,},
        {year:2020,empresa:'Inversionify',salario:2700,},
        {year:2021,empresa:'Inversionify',salario:3750,},
        {year:2022,empresa:'Freelance',salario:1550,},
        {year:2023,empresa:'Freelance',salario:350,},
    ],
});
salarios.push({
    name:'Teodoro',
    trabajos:[
        {year:2018,empresa:'Freelance',salario:600,},
        {year:2019,empresa:'Freelance',salario:700,},
        {year:2020,empresa:'Inversionify',salario:1700,},
        {year:2021,empresa:'Inversionify',salario:1750,},
        {year:2022,empresa:'Freelance',salario:800,},
        {year:2023,empresa:'Freelance',salario:850,},
    ],
});
salarios.push({
    name:'Bruce',
    trabajos:[
        {year:2018,empresa:'Wayne Enterprises',salario:4600,},
        {year:2019,empresa:'Wayne Enterprises',salario:4700,},
        {year:2020,empresa:'Wayne Enterprises',salario:3700,},
        {year:2021,empresa:'Wayne Enterprises',salario:4150,},
        {year:2022,empresa:'Wayne Enterprises',salario:4400,},
        {year:2023,empresa:'Wayne Enterprises',salario:3850,},
    ],
});
salarios.push({
    name:'Alfred',
    trabajos:[
        {year:2018,empresa:'Wayne Enterprises',salario:2000,},
        {year:2019,empresa:'Wayne Enterprises',salario:2000,},
        {year:2020,empresa:'Wayne Enterprises',salario:1500,},
        {year:2021,empresa:'Wayne Enterprises',salario:1500,},
        {year:2022,empresa:'Wayne Enterprises',salario:2000,},
        {year:2023,empresa:'Wayne Enterprises',salario:1500,},
    ],
});
salarios.push({
    name:'Clark Kent',
    trabajos:[
        {year:2018,empresa:'Daily Planet',salario:1000,},
        {year:2019,empresa:'Daily Planet',salario:1500,},
        {year:2020,empresa:'Daily Planet',salario:1000,},
        {year:2021,empresa:'Daily Planet',salario:1500,},
        {year:2022,empresa:'Daily Planet',salario:2000,},
        {year:2023,empresa:'Daily Planet',salario:1500,},
    ],
});
salarios.push({
    name:'Lois Lane',
    trabajos:[
        {year:2018,empresa:'Daily Planet',salario:2000,},
        {year:2019,empresa:'Daily Planet',salario:2500,},
        {year:2020,empresa:'Daily Planet',salario:2000,},
        {year:2021,empresa:'Daily Planet',salario:2500,},
        {year:2022,empresa:'Daily Planet',salario:2500,},
        {year:2023,empresa:'Daily Planet',salario:2500,},
    ],
});
salarios.push({
    name:'Jimmy Olsen',
    trabajos:[
        {year:2018,empresa:'Daily Planet',salario:1500,},
        {year:2019,empresa:'Daily Planet',salario:2000,},
        {year:2020,empresa:'Daily Planet',salario:2000,},
        {year:2021,empresa:'Daily Planet',salario:2500,},
        {year:2022,empresa:'Daily Planet',salario:2500,},
        {year:2023,empresa:'Daily Planet',salario:1500,},
    ],
});
salarios.push({
    name:'Perry White',
    trabajos:[
        {year:2018,empresa:'Daily Planet',salario:3500,},
        {year:2019,empresa:'Daily Planet',salario:3700,},
        {year:2020,empresa:'Daily Planet',salario:3800,},
        {year:2021,empresa:'Daily Planet',salario:4000,},
        {year:2022,empresa:'Daily Planet',salario:4050,},
        {year:2023,empresa:'Daily Planet',salario:4050,},
    ],
});
salarios.push({
    name:'Lex Luthor',
    trabajos:[
        {year:2018,empresa:'LexCorp',salario:5000,},
        {year:2019,empresa:'LexCorp',salario:5300,},
        {year:2020,empresa:'LexCorp',salario:4000,},
        {year:2021,empresa:'LexCorp',salario:3000,},
        {year:2022,empresa:'LexCorp',salario:3500,},
        {year:2023,empresa:'LexCorp',salario:3050,},
    ],
});

Esto es lo que logré hasta ahora sobre la proyección salarial. Me basé en las siguientes lecturas:

• Cálculo de aumento de salario
• Media Geométrica - Usos

const salaryProjection = persona => {
    //Array de los porcentajes de incremento
    let incrementPercentage = [];

    const salarios_ = salarios
        .find(item => item.name === persona).trabajos
        .map(item => item.salario);

    //Sacando el procentaje de incremento de salarios
    const increment = salarios_.forEach((item, index, arr) => {
        if (index === (arr.length - 1)) {
            return;
        }
        //No lo he multiplicado por 100 porque después tendré que dividirlo por 10 de nuevo.
        let increment = ((arr[index + 1] - arr[index]) / arr[index]);
        incrementPercentage.push(increment + 1);
    });

    //Aplicando la media geometrica de los incrementos a 2 decimales.
    const mg = PlatziMath.mediaGeo(incrementPercentage).toFixed(2);

    //Obteniendo el porcentaje. Es decir: 1.45 => 45% fue el incremento.
    const percent = (mg - 1).toFixed(2);

    //Calculamos su proyeccion salarial con el porcentaje obtenido.
    const projSalarial = Math.trunc(salarios_[salarios_.length - 1] * (1 + (percent)));
    return projSalarial;
}

console.log(salaryProjection('Juanita'));
//Expected output => 12975

Hola a todos.
Realice de la forma siguiente una función para obtener la proyección salarial para el próximo año.

Resultado:

proyeccionSalarial('Juanita');
El procentaje de incremento es: 0.38
Tu nuevo salario seria de: 1725

Les recomiendo usar

console.table(// code)

para que se vean mejor impresos los objetos xd

es mi idea o al profe le gusta mucho DC? 🤔

Análisis del array SALARIOS

Este es mi aporte

function findPerson(findPerson){
return salarios.find((person)=>person.name==findPerson);
}

function incrementSalary(salary){
    const incrementSlary=salary.sort((a,b)=>a-b);
    let salaryMax= incrementSlary[incrementSlary.length-1];
    let salaryMin=incrementSlary[0];
    const percentageIncrement=(salaryMax-salaryMin)/(salaryMin*100);
    const averageSalary= Statistics.median(salary);
    const perspectiveSalary=averageSalary+(averageSalary*percentageIncrement)
    console.log('El incremento del salario es del', percentageIncrement*100,'% y el salario para el próximo año sería de ',perspectiveSalary);
}

function salaryPerson(person){
    const works= findPerson(person).trabajos;
    const salary= works.map((item)=>item.salario);
    Statistics.median(salary);
    Statistics.mode(salary);
    incrementSalary(salary);
}

Mi humilde solucion 😃

Cree un nuevo array y la recorri con un for, por cada elemento en en salario, lo agarraba y lo mete en mi nuevo array que declare

function medianaPorPersona(nombrePersona){
    const trabajos = encontrarPersona(nombrePersona).trabajos
    let salarioArr = []

    for(let i = 0; i < trabajos.length; i++){
        salarioArr.push(trabajos[i].salario)
    }

    console.log(trabajos)
    console.log(salarioArr)
    console.log(PlatziMath.calcularMediana(salarioArr))
}

antes de entrar a esta clase me puse a jugar con el código y me di cuenta del undefind por la funciones en platziMath. casi me arranco los pelos pero pude resolver el error que ahora explicas.

Les comparto la lista de salarios pero con IDs incorporados. 😄

const SALARIES = [];

SALARIES.push({
    name  : 'Juanita',
    id    : 1,
    works : [
        { year: 2018, company: 'Freelance', salary: 250, },
        { year: 2019, company: 'Freelance', salary: 250, },
        { year: 2020, company: 'Industrias Mokepon', salary: 850, },
        { year: 2021, company: 'Industrias Mokepon', salary: 1050, },
        { year: 2022, company: 'Industrias Mokepon', salary: 1250, },
        { year: 2023, company: 'Industrias Mokepon', salary: 1250, },
    ],
});

SALARIES.push({
    name  : 'Alex',
    id    : 2,
    works : [
        { year: 2018, company: 'Freelance', salary: 450, },
        { year: 2019, company: 'Freelance', salary: 550, },
        { year: 2020, company: 'Freelance', salary: 400, },
        { year: 2021, company: 'Industrias Mokepon', salary: 1050, },
        { year: 2022, company: 'Industrias Mokepon', salary: 1250, },
        { year: 2023, company: 'Industrias Mokepon', salary: 1250, },
    ],
});

SALARIES.push({
    name  : 'Nath',
    id    : 3,
    works : [
        { year: 2018, company: 'Freelance', salary: 600, },
        { year: 2019, company: 'Freelance', salary: 625, },
        { year: 2020, company: 'Freelance', salary: 575, },
        { year: 2021, company: 'MarketerosCOL', salary: 1000, },
        { year: 2022, company: 'MarketerosCOL', salary: 1000, },
        { year: 2023, company: 'MarketerosCOL', salary: 1100, },
    ],
});

SALARIES.push({
    name  : 'Julia',
    id    : 4,
    works : [
        { year: 2018, company: 'MarketerosCOL', salary: 1000, },
        { year: 2019, company: 'MarketerosCOL', salary: 2000, },
        { year: 2020, company: 'MarketerosCOL', salary: 2000, },
        { year: 2021, company: 'MarketerosCOL', salary: 2000, },
        { year: 2022, company: 'MarketerosCOL', salary: 2000, },
        { year: 2023, company: 'MarketerosCOL', salary: 2000, },
    ],
});

SALARIES.push({
    name  : 'Jonatan',
    id    : 5,
    works : [
        { year: 2019, company: 'MarketerosCOL', salary: 1000, },
        { year: 2020, company: 'MarketerosCOL', salary: 1000, },
        { year: 2021, company: 'MarketerosCOL', salary: 800, },
        { year: 2022, company: 'MarketerosCOL', salary: 900, },
        { year: 2023, company: 'MarketerosCOL', salary: 1000, },
    ],
});

SALARIES.push({
    name  : 'Armando',
    id    : 6,
    works : [
        { year: 2018, company: 'Freelance', salary: 750, },
        { year: 2019, company: 'Freelance', salary: 750, },
        { year: 2020, company: 'Freelance', salary: 750, },
        { year: 2021, company: 'Freelance', salary: 850, },
        { year: 2022, company: 'Freelance', salary: 850, },
        { year: 2023, company: 'Freelance', salary: 850, },
    ],
});

SALARIES.push({
    name  : 'Dilan',
    id    : 7,
    works : [
        { year: 2018, company: 'Freelance', salary: 500, },
        { year: 2019, company: 'Freelance', salary: 500, },
        { year: 2020, company: 'Freelance', salary: 600, },
        { year: 2021, company: 'Mokepon', salary: 1100, },
        { year: 2022, company: 'Mokepon', salary: 1100, },
        { year: 2023, company: 'Mokepon', salary: 1100, },
    ],
});

SALARIES.push({
    name  : 'Zamir',
    id    : 8,
    works : [
        { year: 2018, company: 'Freelance', salary: 400, },
        { year: 2019, company: 'Freelance', salary: 500, },
        { year: 2020, company: 'Freelance', salary: 500, },
        { year: 2021, company: 'Mokepon', salary: 1100, },
        { year: 2022, company: 'Mokepon', salary: 1100, },
        { year: 2023, company: 'Mokepon', salary: 1200, },
    ],
});

SALARIES.push({
    name  : 'Daniela',
    id    : 9,
    works : [
        { year: 2018, company: 'Freelance', salary: 500, },
        { year: 2019, company: 'Freelance', salary: 500, },
        { year: 2020, company: 'Freelance', salary: 500, },
        { year: 2021, company: 'Freelance', salary: 550, },
        { year: 2022, company: 'Freelance', salary: 550, },
        { year: 2023, company: 'MarketerosCOL', salary: 850, },
    ],
});

SALARIES.push({
    name  : 'Daniel',
    id    : 10,
    works : [
        { year: 2020, company: 'Freelance', salary: 150, },
        { year: 2021, company: 'Freelance', salary: 450, },
        { year: 2022, company: 'Freelance', salary: 550, },
        { year: 2023, company: 'Freelance', salary: 650, },
    ],
});

SALARIES.push({
    name  : 'Rigoberto',
    id    : 11,
    works : [
        { year: 2018, company: 'MarketerosCOL', salary: 700, },
        { year: 2019, company: 'MarketerosCOL', salary: 700, },
        { year: 2020, company: 'MarketerosCOL', salary: 700, },
        { year: 2021, company: 'MarketerosCOL', salary: 750, },
        { year: 2022, company: 'MarketerosCOL', salary: 750, },
        { year: 2023, company: 'MarketerosCOL', salary: 750, },
    ],
});

SALARIES.push({
    name  : 'Alicia',
    id    : 12,
    works : [
        { year: 2018, company: 'Inversionify', salary: 300, },
        { year: 2019, company: 'Inversionify', salary: 1700, },
        { year: 2020, company: 'Inversionify', salary: 2700, },
        { year: 2021, company: 'Inversionify', salary: 3750, },
        { year: 2022, company: 'Freelance', salary: 1550, },
        { year: 2023, company: 'Freelance', salary: 350, },
    ],
});

SALARIES.push({
    name  : 'Teodoro',
    id    : 13,
    works : [
        { year: 2018, company: 'Freelance', salary: 600, },
        { year: 2019, company: 'Freelance', salary: 700, },
        { year: 2020, company: 'Inversionify', salary: 1700, },
        { year: 2021, company: 'Inversionify', salary: 1750, },
        { year: 2022, company: 'Freelance', salary: 800, },
        { year: 2023, company: 'Freelance', salary: 850, },
    ],
});

SALARIES.push({
    name  : 'Bruce',
    id    : 14,
    works : [
        { year: 2018, company: 'Wayne Enterprises', salary: 4600, },
        { year: 2019, company: 'Wayne Enterprises', salary: 4700, },
        { year: 2020, company: 'Wayne Enterprises', salary: 3700, },
        { year: 2021, company: 'Wayne Enterprises', salary: 4150, },
        { year: 2022, company: 'Wayne Enterprises', salary: 4400, },
        { year: 2023, company: 'Wayne Enterprises', salary: 3850, },
    ],
});

SALARIES.push({
    name  : 'Alfred',
    id    : 15,
    works : [
        { year: 2018, company: 'Wayne Enterprises', salary: 2000, },
        { year: 2019, company: 'Wayne Enterprises', salary: 2000, },
        { year: 2020, company: 'Wayne Enterprises', salary: 1500, },
        { year: 2021, company: 'Wayne Enterprises', salary: 1500, },
        { year: 2022, company: 'Wayne Enterprises', salary: 2000, },
        { year: 2023, company: 'Wayne Enterprises', salary: 1500, },
    ],
});

SALARIES.push({
    name  : 'Clark Kent',
    id    : 16,
    works : [
        { year: 2018, company: 'Daily Planet', salary: 1000, },
        { year: 2019, company: 'Daily Planet', salary: 1500, },
        { year: 2020, company: 'Daily Planet', salary: 1000, },
        { year: 2021, company: 'Daily Planet', salary: 1500, },
        { year: 2022, company: 'Daily Planet', salary: 2000, },
        { year: 2023, company: 'Daily Planet', salary: 1500, },
    ],
});

SALARIES.push({
    name  : 'Lois Lane',
    id    : 17,
    works : [
        { year: 2018, company: 'Daily Planet', salary: 2000, },
        { year: 2019, company: 'Daily Planet', salary: 2500, },
        { year: 2020, company: 'Daily Planet', salary: 2000, },
        { year: 2021, company: 'Daily Planet', salary: 2500, },
        { year: 2022, company: 'Daily Planet', salary: 2500, },
        { year: 2023, company: 'Daily Planet', salary: 2500, },
    ],
});

SALARIES.push({
    name  : 'Jimmy Olsen',
    id    : 18,
    works : [
        { year: 2018, company: 'Daily Planet', salary: 1500, },
        { year: 2019, company: 'Daily Planet', salary: 2000, },
        { year: 2020, company: 'Daily Planet', salary: 2000, },
        { year: 2021, company: 'Daily Planet', salary: 2500, },
        { year: 2022, company: 'Daily Planet', salary: 2500, },
        { year: 2023, company: 'Daily Planet', salary: 1500, },
    ],
});

SALARIES.push({
    name  : 'Perry White',
    id    : 19,
    works : [
        { year: 2018, company: 'Daily Planet', salary: 3500, },
        { year: 2019, company: 'Daily Planet', salary: 3700, },
        { year: 2020, company: 'Daily Planet', salary: 3800, },
        { year: 2021, company: 'Daily Planet', salary: 4000, },
        { year: 2022, company: 'Daily Planet', salary: 4050, },
        { year: 2023, company: 'Daily Planet', salary: 4050, },
    ],
});

SALARIES.push({
    name  : 'Lex Luthor',
    id    : 20,
    works : [
        { year: 2018, company: 'LexCorp', salary: 5000, },
        { year: 2019, company: 'LexCorp', salary: 5300, },
        { year: 2020, company: 'LexCorp', salary: 4000, },
        { year: 2021, company: 'LexCorp', salary: 3000, },
        { year: 2022, company: 'LexCorp', salary: 3500, },
        { year: 2023, company: 'LexCorp', salary: 3050, },
    ],
});

🚩 Paso a paso para calcular la mediana de los salarios de cualquier empleado registrado

• Paso1️⃣
  
  
• Paso2️⃣
  
  
• Paso 3️⃣
  
  
• Paso 4️⃣
  
  
• Paso 5️⃣
  
  
• Bonus 💰💰
  
  

Yo decidí sacar la diferencia entre el salario más grande menos el salario anterior al mismo, para evitar los salarios repetidos utilicé el objeto Set. Referencia

const proyectionSalaryPerPerson = (personName) => {
	const arr = findPersonByName(personName).works.map((el) => el.salary);
	// El objeto Set solo almacena valores únicos 
	const uniqueSalaries = [...new Set(arr)];
	const arrLength = uniqueSalaries.length;
/*
Para calcular la proyección, primero se evalúa con un ternario si existe más de un elemento en el arreglo, si sí, se resta tanto el último como el penúltimo elemento, si no, simplemente se calcula el 10% del único elemento y se suma con el mismo.
*/
	const proyection =
		arrLength > 1
			? uniqueSalaries[arrLength - 1] - uniqueSalaries[arrLength - 2]
			: uniqueSalaries * 0.1;
	return uniqueSalaries[arrLength - 1] + proyection;
};

Para calcular la proyección, se me ocurrió calcularlo con una media geometrica, tal vez no sea lo mas optimo para una proyeccion, pero me gusto el reto porque tuve que aplicar una raíz con un indice de 4 y aplicar varios condicionales para cumplir las reglas de esta media en especifico, tambien use reduce, para multiplicar todos los elementos de un array.
Media Geometría :

> La media geométrica se calcula como un producto conjunto. Es decir, que todos los valores se multiplican entre sí. De modo que si uno de ellos fuera cero, el producto total sería cero. Por ello, debemos siempre tener en cuenta que a la hora de calcular la media geométrica necesitamos números que sean únicamente positivos

Ahora todo eso en js

// Haremos la proyeccion salarial usando una media geometrica
// Necesitamos el porcentaje de aumento de cada año, para calcular la media geometrica
// %aumento = (salarioNuevo - salarioViejo) / salarioViejo + 1

const aumentos = [];

function calcularMediaGeometrica (person) {
    const array = listaSalarios(person);



    for (i=1; i<array.length; i++){
    
        let aumentoPorAnnio = (array[i] - array[i-1]) / array[i-1];
// condicional para cumplir reglas de la Media Geometrica (Si hay un aumento de 0% no sumarle el +1)
        if (aumentoPorAnnio === 0){
            aumentoPorAnnio = 0;
        } else {
            aumentoPorAnnio++;
        }
        aumentos.push(aumentoPorAnnio.toFixed(2));    
    }
    console.log(aumentos);
    let multiplicarAumentos = aumentos.reduce((valorAcumulado, valorNuevo) => 
    valorAcumulado * valorNuevo);
    let indiceRaiz = 1 / aumentos.length;
    let mediaGeometrica = multiplicarAumentos ** indiceRaiz;
    let proyeccion = mediaGeometrica * array[array.length-1];
    console.log(mediaGeometrica.toFixed(2));
    if (mediaGeometrica === 0) {
            console.log(`${person} para el año que viene proyectamos que no tendras un aumento salarial.`);
    } else {
        console.log(`${person} para el año que viene proyectamos que tendras un salario de $${proyeccion.toFixed(0)}.`);
    }
    return mediaGeometrica.toFixed(2); 
}

calcularMediaGeometrica("Daniel");

Que tal en una pagina 😄

Para calcular la proyeccion de un nuevo salario se me ocurrio sacar un promedio de las diferencias entre los salarios de año tras año, se que no es un calculo que se pueda aplicar en la vida real, simplemente se me ocurrio asi de golpe y me puse a escribir codigo saljksjksasd

function getSalarios(nombre, arraySalarios){
    const persona = arraySalarios.find(salario => salario.name == nombre);
    const salarios_persona = persona.trabajos.map(trabajo => trabajo.salario);
    return salarios_persona;
};

function proyectarSalarios(salarios_persona){
    const aumentos_salario = [];
    salarios_persona.sort((prev,next) => {
        aumentos_salario.push(prev - next);
    });
    const promedio_aumento = PlatziMath.calcular_promedio(aumentos_salario);
    const nuevo_salario = salarios_persona[salarios_persona.length - 1] + promedio_aumento;
    return {aumento: promedio_aumento, nuevo_salario: nuevo_salario};
}

const proyeccion = proyectarSalarios(getSalarios('Alex', salarios));
console.log(proyeccion);

Yo resolví este reto mediante una formula que compartio un compañero, la cuál es esta:

Para saber el porcentaje de aumento:

Para saberel proximo aumento:

Y aqui está resuleto con estas formúlas con código JS.

Output:

Hace tiempo no le meto a la matemática así que no se si esta bien la lógica en el calculo pero BUENO, la vida es una. Acá va mi código.

function calcularPorcentajeDeAumentoAnual(nombrePersona){
    const trabajos= encontrarPersona(nombrePersona).trabajos;
    const salarios= trabajos.map(function(elemento){
        return elemento.salario
    })
    // console.log(salarios);
    const porcentajeDeAumento = ((salarios[salarios.length-1]- salarios[0])/salarios[0] / salarios.length);
    console.log(porcentajeDeAumento);
    return porcentajeDeAumento;
}
function calcularAumentoDeSalario(nombrePersona,cantidadDeAños){
    const trabajos= encontrarPersona(nombrePersona).trabajos;
    const salarios= trabajos.map(function(elemento){
        return elemento.salario
    })
    const porcentajeDeAumento= calcularPorcentajeDeAumentoAnual(nombrePersona);
    const calcularAumentoSueldo = salarios[salarios.length-1]*(1+porcentajeDeAumento)*cantidadDeAños;
    console.log(calcularAumentoSueldo)
}

Realice la funcion pero de una forma mas complicada jajaja el .map hace la vida mas easy.

Queriendo practicar y entender las diferentes formas de recorrer el array cree las funciones encontrar persona de diferentes maneras.

function encontrarPersona (nombre){//recorriendo array con metodo for, se requiere validar el objeto con el indice para entrar al atributo name.
  for (let i = 0; i < salarios.length; i++) {
    
    if(salarios[i].name == nombre){
      return salarios[i];
    }
  }
}

function encontrarPersona (nombre){
  for (const persona of salarios) {
    persona.name == nombre;
    return persona ;
  }
}

Mi solución 😃

function findPerson(dataPerson, wantedPerson) {
    return dataPerson.find((data)=>data.name === wantedPerson)
}
function personalMedian(dataPerson,wantedPerson) {
    const person = findPerson(dataPerson,wantedPerson)
    const salaries = person.trabajos.map((trabajoData)=>trabajoData.salario)
    console.log(PlatziMath.calculateMedian(salaries));

}
personalMedian(salarios,"Juanita")

woo

para hacer el arreglo de los salarios use un metodo un poco mas largo pero igual de efectivo

 const salaryYear = []
    for (let i = 0; i < trabajos.length; i++) {
        let salary = trabajos[i].salario
        salaryYear.push(salary)
    }
    return salaryYear```

Siguiendo principios SOLID:

const person = "Juanita";
const id = 1;

const find_person_byName = (name, array) => {
    return array.find( person => person.name === name);
}

const find_person_byID = (id, array) => {
    return array.find(person => person.id === id);
}

const find_salary_byID = (idPerson, array) => {
    const jobs = find_person_byID(idPerson, array).trabajos;
    const salary = jobs.map(job => job.salario);
    return salary;
}

console.log(BasicStadistics.median(find_salary_byID(1, salarios)));

Mi solucion al reto es la siguiente

  const tasaCrecimiento = [];
  for (let i = 0; i < salariosPersona.length - 1; i++) {
    tasaCrecimiento.push(
      1 + (salariosPersona[i + 1] - salariosPersona[i]) / salariosPersona[i]
    );
  }
  const tasaMedia = PlatziMath.calcularMediaGeometrica(tasaCrecimiento);
  const proximoSalario =
    salariosPersona[salariosPersona.length - 1] * tasaMedia;

  console.log({
    mediana: medianaSalarios,
    tasa: tasaMedia,
    tasaCrecimiento,
    proximoSalario,
  });
}

Hola hice mi proyección de salario basándome en el promedio de los aumentos salariales que ha tenido durante el tiempo que lleva trabajando, por lo que cálculo este promedio y ese valor lo sumo a el ultimo salario para hallar el próximo.
Así esta mi código.

function proximoSalario(nombrePersona) {
    const trabajos = encontrarPersona(nombrePersona).trabajos;
    
    const salarios = trabajos.map(function(elemento){
        return elemento.salario
    })
    console.log(salarios);

    const diferenciasSalarios = [];

    for(i=0; i < (salarios.length-1); i++){
        const valor = salarios[i+1] - salarios[i];
        diferenciasSalarios.push(valor)
    }
    console.log(diferenciasSalarios);

    const valorAAumentar = diferenciasSalarios.reduce(function (a, b){return a + b})/diferenciasSalarios.length;

    console.log(valorAAumentar);
    const ultimoSalario = salarios.length
    const nuevoSalario = valorAAumentar + salarios[ultimoSalario-1];
    console.log(nuevoSalario);
}

Hi, les comparto mi estructura utilizando TS:

type Trabajo = {
                  year: number,
                  empresa: string,
                  salario: number
                };
type Salario = {name: string, trabajos: Trabajo[]}[];


const salarios: Salario  = [ ... ]

Cada vez más las funciones se vuelven más potentes y más útiles

Para crear el numero de documento para cada objeto, utilice esta function

function createRandomId(){
  let id = ' ';
  for (let i = 0; i < 12; i++) {
    id += Math.floor(Math.random() * 10)
  };
  console.log(id);
  return id;
}

Luego fui a cada objeto y luego del nombre agregue la llave ‘id’ con el valor de la function, asi: ‘id: createRandomId()’

Utilice el promedio geométrico basado en el cambio de los salarios de un año a otro. primero determino los cambios, en un arreglo, luego saco el promedio geométrico y luego aplico el promedio para calcular el siguiente salario

function proyecionSalario(nombrePersona){
    const trabajos = buscarPersoma(nombrePersona).trabajos;    
    const salarios = trabajos.map((persona) => {return persona.salario});
    let cambios = [];
        for (let i = 1; i < salarios.length; i++) {
        let cambio = (salarios[i] / salarios[i-1]) - 1;
        cambios.push(cambio);
        }
    console.log(cambios);
    let producto = 1;
        for (let i = 0; i < cambios.length; i++) {
        producto = producto * (1 + cambios[i]);
        }
    let promedioGeometrico = Math.pow(producto, 1 / cambios.length) - 1;
    console.log(promedioGeometrico);
    let salarioActual = salarios[salarios.length - 1];
    let salarioProyectado = salarioActual * (1 + promedioGeometrico);
    console.log(salarioProyectado);
}

Para calcular la proyección del salario de una persona usando JavaScript, se pueden seguir los siguientes pasos:
Defina las variables necesarias, como el salario actual, el porcentaje de aumento y el número de años para la proyección.
Utilice un ciclo for para calcular el nuevo salario en cada año de la proyección. Dentro del ciclo, multiplique el salario actual por el porcentaje de aumento (expresado como un decimal) y sume ese valor al salario actual.
Imprima o devuelva el salario proyectado después del número de años especificado.
Ejemplo de código:

function salaryProjection(currentSalary, raisePercent, years) {
  for (let i = 1; i <= years; i++) {
    currentSalary += currentSalary * (raisePercent / 100);
  }
  return currentSalary;
}
console.log(salaryProjection(50000, 3, 5));

Mi solución.

function proyeccionSalario(persona){
  const salario =encontrarSalarios(persona);
  let porcentajeAumentoDeSalario = ((salario[salario.length-1] - salario[salario.length-2]) / salario[salario.length-1]) * 100;
  const aumentoFinalSalario=(porcentajeAumentoDeSalario*salario[salario.length-1]) /100;
  const salarioFinal=salario[salario.length-1]+aumentoFinalSalario;
 
  return "Tu salario para el siguiente año debería ser "+ salarioFinal+" dolares,es decir,un aumento de "+aumentoFinalSalario+" dolares";
}