Proyección salarial personal

OK listo lo del calculo de la proyección, tuve que modificar muchas cosas para que funcionara ;D
 

 
código
 
page

Para calcular directamente el nuevo salario podemos en una sola linea de codigo (en vez de 3) simplemente multiplicar el ultimo Salario * (1 + mediana). esta es una forma rapida de obtener un numero con el aumento de cierto valor. Es decir:

Si tenemos que incrementarle un 20% a 500 en vez de hacer:
aumento=500*20%;
nuevoSalario = ultimoSalario + aumento;

se puede hacer
nuevoSalario = ultimoSalario*(1+20%); y esto da lo mismo

Estuvo genial la clase, me di cuenta que me complique mas haciendo una media geométrica (había dejado mi código en la clase pasada), pero lo pude lograr.

// 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 (let 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));    
    }

    let multiplicarAumentos = aumentos.reduce((valorAcumulado, valorNuevo) => 
    valorAcumulado * valorNuevo);
    let indiceRaiz = 1 / aumentos.length;

// Aca estamos sacando una raiz con un indice que es igual a la cantidad de aumentos que tuvo la persona

    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");

Next version 😃

Pequeño recordatorio para todos:

2.4 = 240%
0.23 = 23%
0.19 = 19%

En los porcentajes para obtener un fracción hay que dividir la unidad en 100 pedacitos por eso 1 = 100% y .01 = 1%

Para la proyección salarial utilice una regresión lineal (Porqué me pareció la más sencilla), para lo cual implemente la siguiente formula obtenida de un video en Youtube: Video

código js
para la proyección del año 2024 es de 1636.66$

console.log(salarios[0]);
// Mediana una persona 

function findPerson(array,nameSearch){
    return (array.filter(function(articulo){
        return articulo.name == nameSearch;
    }));
}
function mediaPerson(array, nameSearch){
    const mediaP =findPerson(array,nameSearch)[0].trabajos.map(function (articulo){ return articulo.salario;}) ;
    return MathOperation.calcMediana(mediaP);
    
}
function proyectSalary(array, nameSearch, yearproyect){
    const yearAndSalary =findPerson(array,nameSearch)[0].trabajos.map(function(articulo){return [articulo.year,articulo.salario];});
    const yearandSalarySum = yearAndSalary.reduce(function(a,b){return [a[0]+b[0],a[1]+b[1]]});
    const yearCuad = yearAndSalary.reduce(function(a,b){
        return [a[0]+(b[0]**2)];
    }, [0,0]);
    const yearporsalary = yearAndSalary.reduce(function(a,b){return [a[0]+b[0]*b[1]]},[0,0]);
    yearandSalarySum.push(yearCuad[0],yearporsalary[0])
    const valueLinealA = Number(((yearAndSalary.length*yearandSalarySum[3]-yearandSalarySum[0]*yearandSalarySum[1])/(yearAndSalary.length*yearandSalarySum[2]-yearandSalarySum[0]**2)).toFixed(3));
    const valueLinealB = Number(((yearandSalarySum[1]-valueLinealA*yearandSalarySum[0])/(yearAndSalary.length)).toFixed(3));
    const resultlenalproyect = valueLinealA*(yearproyect)+(valueLinealB);
    return [yearAndSalary, yearandSalarySum, valueLinealA, valueLinealB, resultlenalproyect]
}
console.log([findPerson(salarios,"Juanita"),mediaPerson(salarios,"Juanita")]);
console.log(proyectSalary(salarios,"Juanita",2023));```

Aquí seguimos o//
Me han ayudo mucho los comentarios, muchas gracias o//

function proyeccionProxSalario(id){
    const trabajosPersona = encontrarPersona(id).trabajos
    const salarios = trabajosPersona.map((elemento)=> elemento.salario)

    const listaInvertida = salarios.sort((a, b)=> b - a)
    

    const salarioActual = listaInvertida[0]
    const salarioAnterior = listaInvertida.find((valor)=> valor !== salarioActual)

    const porcentajeSalarial = Number((((salarioActual - salarioAnterior)/salarioAnterior) * 100).toFixed(2))

    const nuevoSalario = Number((salarioActual * ((1 + (porcentajeSalarial / 100)))).toFixed(2))
    return nuevoSalario
}

Yo simplemente calcule una pendiente promedio, con respecto al ultimo y al primer salario. Despues use esa pendiente en la formula Y = mX + b.

• Y = salario proyectado
• m = pendiente promedio
• X = año para la proyección
• b = sueldo del primer año (2018)

// Analisis para persona

function calcularMedianaPorPersona(nombrePersona) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = filtrarSalarios(arrayTrabajos);
	const medianaSalarios = PlatziMath.calcMediana(arraySalarios);
	// console.log(salarios);
	// console.log(objPersona);
	// console.log(arrayTrabajos);
	// console.log(arraySalarios);
	// console.log(medianaSalarios);

	function filtrarSalarios(arr) {
		const arraySal = [];
		for (element of arr) {
			arraySal.push(element.salario);
		}
		return arraySal;
	}
}

//console.log(calcularMedianaPorPersona("Alex"));

// Analisis de proyeccion

function proyectarSalario(nombrePersona, añoProyectado) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = arrayTrabajos.map((element) => element.salario);

	console.log(arraySalarios);

	const pendiente =
		(arraySalarios[arraySalarios.length - 1] - arraySalarios[0]) /
		(arraySalarios.length - 1);
	const proyeccion = pendiente * (añoProyectado - 2018) + arraySalarios[0];
	console.log(proyeccion);
}
proyectarSalario("Alex", 2023);

Ahora es posible acceder al último elemento de un array sin tener que hacer la típica maniobra:

let lastSalary = array[array.length - 1] ;

Ahora podemos usar Array.prototype.at():

let lastSalary = array.at(-1);

Nunca me ha gustado el tema financiero xd…pero en sí al ver las clases, es increíble que se pueda desarrollar esto usando JavaScript.

Aqui una pequeña funcion que me ayudo a entender la logica del ejercicio:

function incrementSalary(currentSalary, incrementPercentage) {
  let incrementAmount = currentSalary * (incrementPercentage / 100);
  let newSalary = currentSalary + incrementAmount;
  return newSalary;
}

Holaaa, una observación es que vas demasiado rápido, he visto el vídeo varias veces para comprender pero de igual forma siento que falta explicarlo ded una forma más tranquila, tqm profe juan ❤️

DRY – Don’t Repeat Yourself.

Por si no lo notaron tanto en la funcion de medianaPorPersona como en proyeccionPorPersona para generar el array de los salarios, se repite codigo escribiendo practicamente las mismas lineas

const trabajos = EncontrarPersona(nombrePersona).trabajos;
const salarios = trabajos.map(item => item.salario);

Desde mi punto de vista, conviene mas crear una funcion que directamente nos devuelva el array de los salarios de cualqueir persona, sin tener que escribir las mismas lineas cada vez que se requiera.

Analisis de la proyecccion del salario de una persona:

function proyeccionPorPersona(nombrePersona) {
    // Filtrar por persona:
    const trabajos = personaBuscada(nombrePersona).trabajos;

    // Hacer un arreglo para guardar los incrementos que ha tenido la persona en sus salarios:
    let porcentajesCrecimiento = [];
    for (let i = 1; i < trabajos.length; i++){
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i - 1].salario;
        const crecimiento = salarioActual - salarioPasado;
        const porcentajeCrecimiento = crecimiento / salarioPasado;

        porcentajesCrecimiento.push(porcentajeCrecimiento);
    } 
    console.log(porcentajesCrecimiento);

    // Obtener la mediana de los porcentajes de  crecimiento:
    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcentajesCrecimiento);
    console.log(medianaPorcentajesCrecimiento);

    // Proyectar su nuevo aumento de salario encontrando su ultimo salario y multiplicarlo por el porcentaje de crecimiento:
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const aumento = ultimoSalario * medianaPorcentajesCrecimiento;

    // El resultado de la proyeccion de su salario sera la suma de su salario mas reciente y el aumento calculado:
    const nuevoSalario = ultimoSalario + aumento;
    return nuevoSalario;
};

Me enrede un poco para sacar los porcentajes pero al final llegue al mismo resultado 😆

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(nombre, arraySalarios){
    const salarios_persona = getSalarios(nombre, arraySalarios);
    const porcentajes_aumentos = [];
    for (const index in salarios_persona) {
       if(index < (salarios_persona.length-1)){
            const salarioActual = salarios_persona[parseInt(index) + 1];
            const salarioAnterior = salarios_persona[index];
            const aumento = ((salarioActual * 100) / salarioAnterior) - 100;
            porcentajes_aumentos.push(aumento);
       }
    }
    const proyeccion_porcentaje = PlatziMath.calcular_mediana(porcentajes_aumentos);
    const ultimo_salario = salarios_persona[salarios_persona.length -1];
    const aumento = (ultimo_salario*proyeccion_porcentaje)/100;
    const nuevo_salario = ultimo_salario + aumento;
    return nuevo_salario;
}

Hola, dejo aporte por si alguien le sirve!! Se que vienen áspera las mate. Agregué que retorne un objeto con la proyección de sueldos, por la misma cantidad de años de la información de origen de la persona.

function proyeccionSalarial(personaProyeccion) {
    const trabajos = encontrarPersonas(personaProyeccion).trabajos;    
    const proyeccionCrecimiento = []
    
    for( i=1; i<trabajos.length; i++) {
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i-1].salario;
        const porcentajeCrecimiento = (salarioActual - salarioPasado) / salarioPasado;
        proyeccionCrecimiento.push(porcentajeCrecimiento);       
    };

    const medianaPorcentajeCrecimiento = MhMath.calcularMediana(proyeccionCrecimiento);    
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const nuevoSalario = (ultimoSalario * medianaPorcentajeCrecimiento) + ultimoSalario;
    console.log(`Tu próximo nuevo salario 2024 estimado es u$ ${nuevoSalario}`);
    
    let proyeccion = [];
    let years = 2023;
    let sueldo = ultimoSalario;
    for( i=0; i<trabajos.length; i++) {
        years++;
        sueldo += sueldo * medianaPorcentajeCrecimiento;
        proyeccion.push({
            year: years,
            sueldo: sueldo,
        });
    };
    return proyeccion;
};

//funcion para calcular la proyeccion de un nuevo salario

const proyecSalPersona = (nombrePersona)=>{
  const trabajos = encontrarPersona(nombrePersona).trabajos;
  
  let listaPorcCrec = []
  for (let i =1; i<trabajos.length; i++){
    const salarioActual = trabajos[i].salario;
    const salarioPasado = trabajos[i-1].salario;
    const crecimiento = salarioActual - salarioPasado;
    const porcCrec = crecimiento / salarioPasado;
    listaPorcCrec.push(porcCrec);
    // console.log({listaPorcCrec ,salarioActual, salarioPasado, porcCrec});
  }

  const mediana = PlatziMath.calcularMediana(listaPorcCrec);
  const ultimoSalario = trabajos[trabajos.length-1].salario;
  const aumento = mediana * ultimoSalario;
  const nuevoSalario = ultimoSalario + aumento;

  return nuevoSalario;
}

Intente resolverlo con el map en vez del for

function projectionPerPerson(dataPerson,wantedPerson) {

    const trabajoPersona = findPerson(dataPerson,wantedPerson).trabajos
    const salarios = trabajoPersona.map((dataTrabajo)=>dataTrabajo.salario)
    const salariosEnOrden = salarios.sort((valorAnterior, valorActual)=> valorActual -valorAnterior)

    const incrementos = salariosEnOrden.map((salarios, indexsalio) => {
        const salarioActual = salariosEnOrden[indexsalio];
        const salarioAntiguo = salariosEnOrden[indexsalio+1];
        const crecimientoSalarial = salarioActual - salarioAntiguo
        return crecimientoSalarial / salarioAntiguo
    });

    const medianaPorcentajeDeCreciemiento = PlatziMath.calculateMedian(incrementos.slice(0,incrementos.length-1));
    const incrementoSalarial = trabajoPersona.at(-1).salario * medianaPorcentajeDeCreciemiento;
    const proyecciondesalario = trabajoPersona.at(-1).salario + incrementoSalarial
    console.log(proyecciondesalario.toFixed());
    return proyecciondesalario.toFixed()

}
projectionPerPerson(salarios,"Juanita")

yo durante el curso! Dioses del internet ayudenme!

Lo hice de esta forma también con otras formulas que encontré.

//* Prediciremos el salario del siguiente con dos formulas que requieren los siguientes datos:
//salario Inicial;
//salario Actual;
//cantidad de Años;
//Crecimiento Promedio Anual;

// Creciemiento Promedio Anual = (salario Actual - salario Inicial) / cantidadDeAños
// Salario Predicho = salario Actual + (crecimiento Promedio Anual * 1)

function predecirSalario(pronosticarPersona) {
    
    const cantidadDeAños = encontrarPersona(pronosticarPersona).trabajos.length;

    const arrayTrabajos = encontrarPersona(pronosticarPersona).trabajos;
    
    const arraySoloSalarios = arrayTrabajos.map((obtnerSalarios) => {
        return obtnerSalarios.salario
    }); 
    
    const salarioInicial = arraySoloSalarios[0];
    
    const salarioActual = arraySoloSalarios[arraySoloSalarios.length - 1];
    
    
    const creciemientoPromedioAnual = (salarioActual - salarioInicial) / cantidadDeAños;

    const salarioPredicho = salarioActual + (creciemientoPromedioAnual * 1);

    const salarioEstimado = Math.round(salarioPredicho)

  );

    console.log("El pronostico de tu salario para el proximo año es: " + salarioEstimado);
    return salarioPredicho;
}```

en el minuto 15 se ve que se toma como mediana de porcentaje .1904 que esta en la posición 3 pero eso es incorrecto ya que es un arreglo impar de 4 posiciones se debería de estar tomando la posición 2 0.23529411764705882

La final lo retorne de la siguiente manera para que sea mas facil de leer:

return `Tu nuevo salario es ${Math.floor(newSalary)} usd`

El Math.floor le quitara todos los decimales a newSalary

const proyeccionSalario = (name) => {
  const trabajos = findPerson(name).trabajos;
  const salarios = trabajos.map((element) => element.salario);
  const incrementos = salarios
    .slice(1)
    .map((element, index) =>
      Number((element / salarios[index] - 1).toFixed(2))
    );

  return (
    salarios[salarios.length - 1] +
    salarios[salarios.length - 1] * calculoMath.calculaMediana(incrementos)
  );
};

Les comparto mi codigo comentado por si a alguien le ayuda.

//Proyección de salario, Se aislan sólo los salarios de una persona en un Array, luego se saca la comparación en porcentaje de el primer dato contra el 2 y así hasta recorrer todo el array, este porcentaje se guarda en un array que posteriormente se le sacará la Mediana, una vez obtenida la mediana del porcentaje que ha aumentado su salario, se puede multiplicar este porcentaje por su ultimo salario y esa es la proyección de su futuro salario.
function proyeccionSalarial(personaBuscada){ //Recibe el argumento del nombre de la persona a sacar la proyección
    const persona = buscarPersona(personaBuscada); // Se busca a la persona individual de todo el objeto que tenemos
    const porcentajeAumentado = []; //Este array servirá para guardar el porcentaje de aumento de cada año
    if(persona){ //si existe la persona continuaremos, si no existe mandaremos un mensaje de error
        const historialSalarial = persona.trabajos.map(arrayHistorialSalarial => {//Aislaremos todos los salarios que ha tenido la persona en un sólo array que llevará el nombre historialSalarial
            return arrayHistorialSalarial.salario;
        })
        for (let i = 1; i < historialSalarial.length; i++){//Se recorre todo el historial salarial para ir comparando el porcentaje que ha aumentado año con año.
            const salarioActual = historialSalarial[i]; //Este será el salario en el que va el ciclo for (salario n)
            const salarioAnterior = historialSalarial[i-1]; //Este será el salario anterior (salario n-1)
            const diferenciaSalarial = salarioActual - salarioAnterior; //obtenemos la diferencia para saber cuanto aumentó su salario de un año al otro (AñoN - AñoN-1)
            const crecimiento = diferenciaSalarial / salarioAnterior; //Así obtenemos el % de cuanto aumentó de un año al otro
            porcentajeAumentado.push(crecimiento);//Guardamos ese porcentaje en el array para despues sacar la mediana de sus aumentos
        }
        const porcentajeAumentoProyectado = platziMath.calcularMediana(porcentajeAumentado);//Obtenemos la Mediana (en %) de todos sus aumentos en todos los años de trabajo 
        const aumentoProyectadoEnDlls = porcentajeAumentoProyectado*historialSalarial[historialSalarial.length-1];//Ya que tenemos la mediana de sus aumentos, multiplicamos esa mediana * el ultimo salario para saber cuanto debería subir el siguiente año
        const aumentoFuturo = historialSalarial[historialSalarial.length-1]+ aumentoProyectadoEnDlls;//Sumamos el aumento que debería subir el siguiente año + el ultimo salario.
        console.log(aumentoFuturo); //imprimimos la proyección del salario del siguiente año
    }
    else{ //Si no se encontró a la persona buscada, se enviará el siguiente mensaje de error al usuario
        console.log('La persona que busca no existe, por favor intentelo de nuevo con otro nombre');
    }
}

proyeccionSalarial('Juanita');

Extrañanamente esta clase no se me hizo dificil 😛

En mi opinión está errado el resultado, porque en el array de porcentajes de crecimiento incluye dos veces cero… y se está considerando, por lo que el porcentaje es menor… y OBVIAMENTE “cero” no es crecimiento… por lo que yo lo hice así:

PlatziMath.SiguienteSalarioConMediana=function(persona){
    let salarios=PlatziMath.encontrarSalariosDePersona(persona)
    console.log(salarios);
    let porcentajes=[];
    salarios.forEach((element,index,array) => {
        console.log(element);
        if(index !== salarios.lenght-2)
        if( (salarios[index+1]-salarios[index])/salarios[index] > 0)
         porcentajes.push( (salarios[index+1]-salarios[index])/salarios[index]  )    
        });
    let MedianaDeSalarios=PlatziMath.mediana(porcentajes)
    return (salarios[(salarios.length)-1]*(MedianaDeSalarios+1))