Proyección de salarios por empresas

Hice la modificación para hacer la proyección para la media, promedio, moda y la suma general de todos los salarios

Pues yo hice mi proyección un rango Medio de salarios con una función que ya había dejado lista en el PlatziMath, pero se las dejo por separado para que la integren.

El link donde encuentran la explicacion de lo que es un rango medio y como se calcula esta por aquí

Cuando vemos los datos, a veces queremos entender cómo se extienden: el espacio entre el número mayor y el número menor. Este es el rango de los datos. También es útil saber qué número está a la mitad entre el valor mínimo y el valor máximo del conjunto de datos. Este número se llama rango medio.

PlatziMath.calcularRangoM = function calcularRangoM(array){
    array.sort((a,b) => a - b , 0)
    const item1 = array [array.length - 1];
    const item2 = array[0];
    const rangoM = (item1 + item2)/2;
    return rangoM;
}

Por acá quedó la función de proyección de salarios.

function rangoMedioEmpresas(empresa) {
    if (!empresasList[empresa]) {
        console.warn('La empresa no existe');
    }else {
        const empresaAnual = Object.keys(empresasList[empresa])

        const listaMedianaAnual = empresaAnual.map(year => medianaEmpresasAnual(empresa,year));
        console.log(listaMedianaAnual);

        
        let crecimientoEmpresarial = [];
    
        for (let index = 1; index < listaMedianaAnual.length; index++) {
                const actual = listaMedianaAnual[index];
                const anterior = listaMedianaAnual[index - 1];
                const crecimiento = actual - anterior;
                const porcentajeCrecimiento = crecimiento / anterior;
                crecimientoEmpresarial.push(porcentajeCrecimiento);
            }
        console.log(crecimientoEmpresarial);

        const rangoMedioCrecimientoEmpresarial = PlatziMath.calcularRangoM(crecimientoEmpresarial);
        console.log('rango',rangoMedioCrecimientoEmpresarial);

        const ultimo = listaMedianaAnual[listaMedianaAnual.length -1];
        const aumento = ultimo * rangoMedioCrecimientoEmpresarial;
        const proyeccion = ultimo + aumento;
        return proyeccion;
    }
 }

Sinceramente me siento muy feliz.

Cuando empecé esta ruta de desarrollo web al principio (como a todos), me costó un poco aprender las tecnologías básicas pero con el tiempo me fui adaptando y acostumbrando a ellas, a pensar como ellas y adaptar mi lógica a su lógica.

Hasta que llegué a JavaScript y me topé con este curso. Prácticamente empecé genial pero clase a clase se me hacía dificil realizar los retos que nos ponía el profe, aunque si tenía una noción de la logíca de cada reto, no lograba llevarla a cabo y me bloqueaba. Pero dentro de mí, siempre me decía y me recordaba lo que dice el profe juan, sobre que esto es normal, toma su tiempo, su investigación, error tras error hasta ir creando la solución o respuesta a eso que quiero descifrar con un simple programa, paso a paso, y me costó.

No voy a negar que cada que no me salía el código veía como el profe lo resolvía e iba interactuando más con la lógica del lenguaje, cómo funcionan sus componentes, y como interactúan entre ellos.

Hasta que llegó la clase pasada y decidí ponerme firme, salir de mi zona de confort y codear la solución de esta clase. La verdad he quedado sorprendido sobre como la constancia se ve reflejada en lo que haces, así sea sobre un tema "Fácil o simple para otros", cuando te esfuerzas y ves el fruto de esa mejora, no hay mejor satisfacción.

He logrado mi cometido a mi manera, con mi lógica pero lo he logrado. Muchas gracias a todos los que comparten sus soluciones y aportan su granito de arena para que podamos entender y especialmente a ti, Juan, por tu labor en este curso, de enseñarnos y ayudarnos a no rendir y seguir así todo vaya mal.

Apunto mi código:

buen esfuerzo, creo que lo que falta acá, como en todos los programas de educacion para programadores, es una fase de diseño.

La elaboración de funciones y la aplicacion de ellas en el flujo del programa es mucho mas comprensible si existe una estructura previa llamada diseño.

te quiero mucho juanDC_Batman

Con la misma funcion de proyeccion y creando otra funcion para obtener los rangos de salarios, el mas bajo y el mas alto en un array, use la misma lógica para aplicar el porcentaje de crecimiento a este array con un .map

function rangoSalarios(nombre, year) {
  let arrayYear = empresas[nombre][year];
  arrayYear = PlatziMath.ordenarLista(arrayYear);
  const salarioMasAlto = arrayYear[arrayYear.length - 1];
  const salarioMasBajo = arrayYear[0];
  return [salarioMasBajo, salarioMasAlto];
}

function proyeccionPorEmpresa(nombre) {
  if (!empresas[nombre]) {
    console.warn('La empresa no existe');
  } else {
    const empresaYears = Object.keys(empresas[nombre]);
    const listaMedianaYears = empresaYears.map((year) => {
      return meadianaSalarioYear(nombre, year);
    });
    const listaRangoYears = empresaYears.map((year) => {
      return rangoSalarios(nombre, year);
    });
    
    let porcentajesCrecimiento = [];
  
    for (let i = 1; i < listaMedianaYears.length; i++) {
      const salarioActual = listaMedianaYears[i];
      const salarioPasado = listaMedianaYears[i - 1];
      const crecimiento = salarioActual - salarioPasado;
      const porcentajeCrecimiento = crecimiento / salarioPasado;
      porcentajesCrecimiento.push(porcentajeCrecimiento)
    }

    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcentajesCrecimiento);

    const ultimaMediana = listaMedianaYears[listaMedianaYears.length - 1];
    const aumento = ultimaMediana * medianaPorcentajesCrecimiento;
    const nuevoMediana = ultimaMediana + aumento;

    const ultimoRango = listaRangoYears[listaRangoYears.length - 1];
    const nuevoRango = ultimoRango.map(function (elemento) {
      const nuevoValor = elemento + (elemento * medianaPorcentajesCrecimiento);
      return nuevoValor
    });
    console.log(nuevoRango);
    return nuevoMediana;
  }
}

El resultado es una const ‘nuevoRango’ que contiene un array con el nuevo salario mas bajo y el nuevo mas alto

en este punto las clases estan muyyy potentes

Aquí mi solución al reto, ha sido duriiiiiiiísimo pero funciona más o menos:

``
// Proyeccion de salario por empresa

function proyeccionPorEmpresa (empresa) {
  
  let medianaSalariosEmpresaYear = [];
  let porcentajeDeCrecimiento = [];
  const empresaAnalisis = empresas[empresa];
 
  if (!empresas[empresa]) {
    console.warn('La empresa no existe');
  }else {
    for (year =2018; year<2024; year++){
      if (!empresaAnalisis[year]){
        console.log('No existen datos del año '+ year);
      }else{
      const salariosAnuales = empresaAnalisis[year];
      const medianaSalariosAnuales = PlatziMath.calcularMediana(salariosAnuales);
      medianaSalariosEmpresaYear.push(medianaSalariosAnuales);
      }
    } 
    for (let i=0; i<medianaSalariosEmpresaYear.length-1; i++){  
      const porcentajePorYear = (medianaSalariosEmpresaYear[i+1]-medianaSalariosEmpresaYear[i])/medianaSalariosEmpresaYear[i];
      porcentajeDeCrecimiento.push(porcentajePorYear); 
    }
    }
    const variacionMedianaSueldos = PlatziMath.calcularMediana(porcentajeDeCrecimiento);
    const ultimoCostesSalarios = medianaSalariosEmpresaYear[medianaSalariosEmpresaYear.length-1];
    const proyeccionSalarios2024 = ultimoCostesSalarios + (ultimoCostesSalarios* variacionMedianaSueldos); 
    console.log(medianaSalariosEmpresaYear);
    console.log (porcentajeDeCrecimiento);
    console.log(variacionMedianaSueldos);
    console.log ('La proyección de costes en salario medio por empleado de la empresa '+ empresa + ' en el próximo año sera de $'+proyeccionSalarios2024);

```  }
```

`` Calcula la proyección del salario medio de un empleado utilizando la mediana para encontrar el salario medio. Nunca creí que lo lograría pero con la ayuda de Juan_DC y de los "Dioses del internet" ¡Ha funcionado! Es medio chapucero y muy largo pero funciona... ¡Hace 1 mes no sabía nada de JavaScript!

¡Genial el curs

interesante

Honestidad...entiendo los métodos y su función...pero los términos de salarios se me hacen complicado....supongo que a todos no les gusta algo en aprender en su vida 😅

una cosa es conocer la sintaxis o la semántica de una función, el problema es llamarlos en un esqueleto que yo llamo diseño

Mi solución, aunque creó que no funcionó pero al menos lo intente, aui mi codigo y si alguien me puede dar un feedback, estaré atento a su respuesta:

Output:

_Me dio flojera seguir! Solo calcule los mayores y menores salarios de cada annio. _

++MAYORES SALARIOS:++

function mayoresSalariosEmpresasAnual(empresa){ if(!empresas[empresa]){ console.warn('No existe'); }else{ const arrAnnios = Object.keys(empresas[empresa]); const arrSalariosOrdenados = arrAnnios.map ((year) => PlatziMath.ordenarArray(empresas[empresa][year])) const arrMayoresSalarios = arrSalariosOrdenados.map ((salario) => salario[salario.length - 1]) return{"annios": arrAnnios, 'salarios': arrMayoresSalarios}; }

}

++MENORES SALARIOS:++

function menoresSalariosEmpresasAnual(empresa){ if(!empresas[empresa]){ console.warn('No existe'); }else{ const arrAnnios = Object.keys(empresas[empresa]); const arrSalariosOrdenados = arrAnnios.map ((year) => PlatziMath.ordenarArray(empresas[empresa][year])) const arrMenoresSalarios = arrSalariosOrdenados.map ((salario) => salario[0]) return{"annios": arrAnnios, 'salarios': arrMenoresSalarios}; }

const proyeccionSalarioEmpresa = (name) => {
  const empresas = analisisEmpresarial(salarios);

  const arrayMedianaYear = Object.keys(empresas[name]).map((year) => {
    return medianaEmpresaYear(name, year);
  });

  const incrementos = arrayMedianaYear
    .slice(1)
    .map((element, index) =>
      Number((element / arrayMedianaYear[index] - 1).toFixed(2))
    );

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

En un comentario previo resalte la importancia del concepto DRY, para este caso, el calculo de la proyeccion de incremento es el mismo en los diferentes casos.

function calculoIncremento(listaValoresProyectar){
    const incrementoMedianaSalarial = [];
    for (let i = 1; i < listaValoresProyectar.length; i++){
        const incremento = listaValoresProyectar[i]-listaValoresProyectar[i-1]
        const porcIncremento = incremento / listaValoresProyectar[i-1]
        incrementoMedianaSalarial.push(porcIncremento);
    }
    
    const proyeccionIncremento = Estadistica.calcularMediana(incrementoMedianaSalarial)
    const proyeccionSalarioEmpresa = listaValoresProyectar[listaValoresProyectar.length-1] *(1+proyeccionIncremento);
    return Math.floor(proyeccionSalarioEmpresa)

}

Para el caso de los rangos, solo hace falta obtener la lista con los valores minimos y maximos y ejecutar la funcion anterior para calcular asi, la proyeccion de los salarios minimos y maximos de cada empresa.

aqui presento mis resultados, usando mi funcion de calculoIncremento segun el caso!

Aca esta mis funciones que me regresan la proyeccion mediana del salario mas bajo :) , es impresionante ver lo que suben los mas altos en comparacion de los mas bajos, que no suben casi nada o no suben completamente nada.

SALARIO BAJO

function proyeccionSalarioMasBajoEmpresa(nombre){
    let salariosBajos = []
    if(!empresas[nombre]){
        console.warn("La empresa no existe")
        return
    }else{
       const empresaYears =  Object.keys(empresas[nombre])
    
       for(let i = 0; i < empresaYears.length ;i++){
        let bajo = PlatziMath.ordenarLista(empresas[nombre][empresaYears[i]])
        
        salariosBajos.push(bajo[0])
       }
       console.log(salariosBajos)
       console.log(empresaYears)
    }

       let porcetajesCrecimiento = []

       for(let i = 1; i < salariosBajos.length ;i++){
        const salarioActual = salariosBajos[i]
        const salarioPasado = salariosBajos[i - 1 ]
        const crecimientoSalarial = salarioActual - salarioPasado
        
        const unPorcentajeCrecimiento = crecimientoSalarial / salarioPasado

        porcetajesCrecimiento.push(unPorcentajeCrecimiento)
       }

        console.log(porcetajesCrecimiento)

        const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcetajesCrecimiento)

       console.log(medianaPorcentajesCrecimiento)

       const ultimaMedianaBaja = salariosBajos[salariosBajos.length - 1]
       const aumento = ultimaMedianaBaja * medianaPorcentajesCrecimiento
       const nuevaMediana = ultimaMedianaBaja + aumento
    
    console.log({ultimaMedianaBaja, aumento, nuevaMediana})

    return parseFloat(nuevaMediana.toFixed(2))
    
}

SALARIO ALTO

function proyeccionSalarioMasAlto(nombre){
    let salariosAltos = []

    if(!empresas[nombre]){
        console.warn("La empresa no existe")
        return
    }else{
       const empresaYears =  Object.keys(empresas[nombre])
    
       for(let i = 0; i < empresaYears.length ;i++){
        let alto = PlatziMath.ordenarLista(empresas[nombre][empresaYears[i]])
        
        salariosAltos.push(alto[alto.length - 1])
       }
       console.log(salariosAltos)
       console.log(empresaYears)
    }

    let porcetajesCrecimiento = []

       for(let i = 1; i < salariosAltos.length ;i++){
        const salarioActual = salariosAltos[i]
        const salarioPasado = salariosAltos[i - 1 ]
        const crecimientoSalarial = salarioActual - salarioPasado
        
        const unPorcentajeCrecimiento = crecimientoSalarial / salarioPasado

        porcetajesCrecimiento.push(unPorcentajeCrecimiento)
       }

    console.log(porcetajesCrecimiento)

    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcetajesCrecimiento)

    console.log(medianaPorcentajesCrecimiento)

    const ultimaMedianaAlta = salariosAltos[salariosAltos.length - 1]
    const aumento = ultimaMedianaAlta * medianaPorcentajesCrecimiento
    const nuevaMediana = ultimaMedianaAlta + aumento
    
    console.log({ultimaMedianaAlta, aumento, nuevaMediana})

    return parseFloat(nuevaMediana.toFixed(2))


}

Dejare por aqui mi solucion a este ejercicio, la del profe me enredo un poco asi que decidi usar las funciones anteriores y usar un ciclo For..in

function proyeccionSalarioEmpresasAnual(obj,emp){
    const medianasSalarios = []
    const empConsultar = obj[emp]
    for (let year in empConsultar) {
      const medianaEmpresas = PlatziMath.calcularMediana(empConsultar[year])
      medianasSalarios.push(medianaEmpresas)  
    }
    const salarioProyectado = AnalisisPlatzi.aumentoAnual(medianasSalarios)
    return salarioProyectado
  }

Hice esto aunque creo que no era exactamente la solución al reto porque en la proyección la hace es con base a un solo año, no con base a todos, pero bueno, funciona :]

Dejo el código por si me pueden dar alguna recomendación o lo que sea

const result = document.querySelector('.result');

function proyeccionSalarialEmpresa(nombreEmpresa, year){

    const trabajos = empresas[nombreEmpresa][year];

    let porcentajesCrecimiento = []

    for (let i = 1; i < trabajos.length; i++) {

        const salarioActual = trabajos[i];
        const salarioPasado = trabajos[i - 1];
        const crecimiento = salarioActual - salarioPasado;
        const porcentajeCrecimiento = crecimiento / salarioPasado;
        porcentajesCrecimiento.push(porcentajeCrecimiento);
    }
    
    const medianaCrecimiento = FormulasMath.calcularMediana(porcentajesCrecimiento);

    const ultimoSalario = trabajos[trabajos.length - 1];
    const aumento = ultimoSalario * medianaCrecimiento;

    const nuevoSalario = Math.round(ultimoSalario + aumento);
    
    
    const orden = trabajos.sort((a,b) => a - b);
    const sueldoMasBajo = orden[0]; 
    const sueldoMasAlto = orden[orden.length - 1];

    const p1 = document.createElement('p');
    p1.textContent = `El sueldo mas bajo para esta empresa fue: ${sueldoMasBajo}`;
    result.append(p1);

    const p2 = document.createElement('p');
    p2.textContent = `El sueldo mas alto para esta empresa fue: ${sueldoMasAlto}`;
    result.append(p2);
    
    const p3 = document.createElement('p');

    if (!nuevoSalario) {
        
        p3.textContent = 'No tenemos suficientes datos para darte el aumento del siguiente año';
        result.append(p3);
        
    }else{

        p3.textContent = `Es probable que sus sueldos tengan un aumento de: ${nuevoSalario} el proximo año`;
        result.append(p3);
    }
}

const btn = document.querySelector('.btn');

btn.addEventListener('click', () => {

    result.textContent = '';

    const options = document.querySelector('#bussines');
    const bussinesSelected = String(options.value);

    const years = document.querySelector('#years');
    const yearsSelected = Number(years.value);
    
    if(!empresas[bussinesSelected][yearsSelected]){

        result.textContent = 'Perdonanos, no tenemos informacion para ese año, intenta con otro';

    }else{

        console.log(bussinesSelected);
        console.log(yearsSelected);
        proyeccionSalarialEmpresa(bussinesSelected, yearsSelected);
    }

});

Mi solución para calcular la proyección a partir de las medianas.

function calcularMedianaPorYear(year, nombreEmpresa) {
  if (!empresas[nombreEmpresa]) {
    throw new Error(`El nombre de la empresa ${nombreEmpresa}, no existe`);
  }
  if (!empresas[nombreEmpresa][year]) {
    throw new Error(`El año ${year} introducido, no esta registrado`);
  }
  const empresa = empresas[nombreEmpresa];
  const mediana = Statistic.calcularMediana(empresa[year]);
  return mediana;
}

function calcularProyeccionSalarialEmpresa(nombreEmpresa) {
  if (!empresas[nombreEmpresa]) {
    throw new Error(
      `El nombre de la empresa ${nombreEmpresa} no coincide con ninguna empresa registrada`
    );
  }
  const empresa = empresas[nombreEmpresa];
  const arrEmpresaYears = Object.keys(empresa);
  const arrMedianasForYear = arrEmpresaYears.map((year) =>
    calcularMedianaPorYear(year, nombreEmpresa)
  );
  const proyeccionSalarial =
    Statistic.calcularProyeccionSalarial(arrMedianasForYear);
  return proyeccionSalarial;
}

console.log(calcularProyeccionSalarialEmpresa("Freelance"));

Nota: Recuerde que requiere el objeto “platziMath” en mi caso utilice una clase con métodos estáticos la cual nombre “Statistic”. Además requiere invocar la función que genera y cargar la estructura del objeto “empresas” la cual se desarrolló en clases anteriores.

Hola, no sé si me podrían ayudar a saber por qué cuando ejecuto la función proyeccionPorEmpresa el primer valor sale bien pero los demás dan undefined Aquí el código

//Proyección personal
function proyeccionPorPersona(nombrePersona){
    const trabajos = encontrarPersona(nombrePersona).trabajos;

    let porcentajesCrecimiento = [];

    for (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);
    }
    
    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcentajesCrecimiento);
    
    // console.log({porcentajesCrecimiento, medianaPorcentajesCrecimiento});

    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const aumentoSalario = ultimoSalario * medianaPorcentajesCrecimiento;
    const nuevoSalario = ultimoSalario + aumentoSalario;

    return nuevoSalario;

// Análisis empresarial
const empresas = {};

for (persona of salarios) {
    for (trabajo of persona.trabajos) {
        if(!empresas[trabajo.empresa]) {
            empresas[trabajo.empresa] = {};
        }

        if (!empresas[trabajo.empresa][trabajo.year]) {
            empresas[trabajo.empresa][trabajo.year] = [];
        }
        empresas[trabajo.empresa][trabajo.year].push(trabajo.salario)
    }
}

console.log({empresas});

//Mediana empresarial
function medianaEmpresaYear(nombre, year){
    if(!empresas[nombre]) {
        console.warn('No hay registros del nombre de la empresa.');
    } else if(!empresas[nombre][year]){
        console.warn('No hay registros salariales en este año');
    } else {
        return PlatziMath.calcularMediana(empresas[nombre][year]);
    }
};

//Proyección empresarial
function proyeccionPorEmpresa(nombre) {
    if (!empresas[nombre]) {
        console.warn('No hay registros del nombre de la empresa.');
    } else {
        const empresaYears = Object.keys(empresas[nombre]);
        const listaMedianaYears = empresaYears.map((year) => {
            return medianaEmpresaYear(nombre, year);
        });
        console.log(listaMedianaYears);
    }

}
};

Creo que el console.log(listaMedianaYears); debería estar poe fuera del if

Siguiendo con el tipo de proyección planteada, necesariamente así tendrían que haber siempre registros de cada año por empresa, en caso de que no pasara esto, habría que tener en cuenta la tasa de crecimiento sobre la diferencia en años, para hacer la proyección del siguiente año.

solucion del reto de calcular pa proyeccion del salario

codigo

function proyeccionEmpresa(empresaProyeccion) {
    let calcularProyeccionEmpresa = empresas[empresaProyeccion]
    let arrayDeMediasPoryear = []
    let convertidoaLista = Object.entries(calcularProyeccionEmpresa)
    
    for (let i = 0; i <convertidoaLista.length; i ++) {
        let sueldos = convertidoaLista[i][1]
        let medianaPoraño = PlatziMath.calcularMediana(sueldos)
        arrayDeMediasPoryear.push(medianaPoraño)
    }

    let porcentajeDeCrecimiento = []
    for (let i = 1; i < arrayDeMediasPoryear.length; i ++) {
        let primerSalario = arrayDeMediasPoryear[i]
        let salarioAnteriorEmpresa = arrayDeMediasPoryear[i - 1]

        let crecimientoYear = primerSalario - salarioAnteriorEmpresa
        let porcentajecrecimientoYear = crecimientoYear / salarioAnteriorEmpresa
        porcentajeDeCrecimiento.push(porcentajecrecimientoYear)        
    }

    let mediaDeCrecimientoPoryear = PlatziMath.calcularMediana(porcentajeDeCrecimiento)
    let ultimoSalarioDeEmpresa = arrayDeMediasPoryear [arrayDeMediasPoryear.length - 1]
   
    let proyecccionSalarioProximoYear = ultimoSalarioDeEmpresa + (ultimoSalarioDeEmpresa * mediaDeCrecimientoPoryear)

    return proyecccionSalarioProximoYear

}```

COMPAÑEROS, LO HICE ASÍ ANTES DE VER LA CLASE, ACEPTO CORRECCIONES

Lo de los rangos, los imagine como una lista de los menores salarios y otra lista con los mayores de cada año y hacer la proyección de cada uno de ellos

function proyeccionEmpresarial(empresa){

    let salarioAnual = crearEmpresa(salarios)
    let bajos = []
    let altos = []
    let todo = []

        console.log(salarioAnual[empresa])
    for(let x in salarioAnual[empresa]){
        todo.push(PlatziMath.mediana(salarioAnual[empresa][x]))
        bajos.push(PlatziMath.ordenar(salarioAnual[empresa][x])[0])
        altos.push(PlatziMath.ordenar(salarioAnual[empresa][x])[(salarioAnual[empresa][x].length)-1])
    }
    
    console.log(todo,bajos,altos,PlatziMath.mediana(bajos),PlatziMath.mediana(altos)  ,PlatziMath.mediana(todo))

    return [
        "proyeccion todo", todo[todo.length-1] + PlatziMath.mediana(todo),
        "proyeccion bajos",bajos[bajos.length-1] + PlatziMath.mediana(bajos),
        "proyeccion altos",altos[bajos.length-1]  + PlatziMath.mediana(altos)
    ]
}