Proyección de salarios por empresas

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;
    }
 }

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

 
código
 
page

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:

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

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 😅

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

en este punto las clases estan muyyy potentes

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.

.
Resultado mostrado en consola:

.
Código:

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.

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)
    ]
}

Yo lo hice así:

• Primero, aislé el código que nos da el siguiente salario en una sola función para poder reutilizarla en las dos funciones de proyección salarial:

function increasesAndDecreases(array) {
    const upsAndDowns = [];
    for (let i = 1; i < array.length; i++) {
        const actualSalary = array[i];
        const pastSalary = array[i - 1]
        let increse = actualSalary - pastSalary;
        let percentage = ( increse / pastSalary)// esto me da el porcentaje
        upsAndDowns.push(percentage)
    }
    let lastSalary = array.at(-1);
    let nextIncrease = PlatziMath.mediana(upsAndDowns)
    let finalIncrease = lastSalary * nextIncrease;
    let nextSalary = Math.ceil(lastSalary + finalIncrease);
    console.log({
        array, upsAndDowns, lastSalary, nextIncrease,
    });
    return nextSalary
}

• Así hice la función de la proyección salaria por empresa:

function projectionPerCompanie(companie) {
    if(!companies[companie]) {
        console.warn("La compañia no existe")
        return
    }
    const salaries = companies[companie];
    const medianSalaryByYear = [];
    for (const key in salaries) {
        let median = PlatziMath.mediana(salaries[key]);
        medianSalaryByYear.push(median)
    }
    return increasesAndDecreases(medianSalaryByYear)
}

Gracias por leer

Cree mi propia version. Me esta ayudando mucho a cambiar mi forma de programar. Antes los hacia mas ortodoxo, ahora gracias a platzi estoy mejorando

function ProyeccionSalarialEmpresarial(empresa){
    const empresas=proyeccionCostosEmpresarial_mejorado();
    const promedios=[];
    const anios=Object.keys(empresas[empresa]);
    for(let i=1;i<anios.length;i++){
        promedios.push((medianaEmpresaMejorado(empresa,anios[i])-medianaEmpresaMejorado(empresa,anios[i-1]))/medianaEmpresaMejorado(empresa,anios[i-1]));
    }
    console.log(empresas[empresa]);
    //ultimo valor del array  * razon de la formula+  
    
    console.log(Mathplatzi.mediana(empresas[empresa][anios[anios.length-1]])*Mathplatzi.mediana(promedios)+Mathplatzi.mediana(empresas[empresa][anios[anios.length-1]]));
    console.log(promedios);
}

**Esta es mi función para el analisis salarial tomando en cuanta los puntos de el video anterior **

function proyeccionEmpresa(nombreEmpresa){
  const salariosEmpresa = {};
  const arraySalarios = [];
  salariosEmpresa.salariosHistorial = [];

  for(year in empresas[nombreEmpresa]){
    salariosEmpresa[year] = [];
      for(salario of empresas[nombreEmpresa][year]){
      salariosEmpresa[year].push(salario)
      salariosEmpresa.salariosHistorial.push(salario)
    }
    salariosEmpresa[year] = PlatziMath.calcularMediana(salariosEmpresa[year])
    arraySalarios.push(salariosEmpresa[year])
  }

  const salariosPorAnhioMediana = Object.values(salariosEmpresa);
  const medianaAnhiosEmpresa = PlatziMath.calcularMediana(salariosPorAnhioMediana);
  
  salariosEmpresa.medianaDeSalarios = medianaAnhiosEmpresa;
  salariosEmpresa.diferenciaSalarios = [];
  salariosEmpresa.diferenciaSalariosPorcentaje = [];

  for(let i = 1; i<salariosPorAnhioMediana.length;i++){
    const salarioPasado = salariosPorAnhioMediana[i-1];
    const salarioActual = salariosPorAnhioMediana[i];
    const diferenciaSalarios = salarioActual - salarioPasado;
    const porcentajeDiferencia = (diferenciaSalarios /salarioPasado);
    salariosEmpresa.diferenciaSalarios.push(diferenciaSalarios);
    salariosEmpresa.diferenciaSalariosPorcentaje.push(porcentajeDiferencia);
  }
  salariosEmpresa.medianaSalarioPorcentaje = PlatziMath.calcularMediana(salariosEmpresa.diferenciaSalariosPorcentaje);
  const ultimoAño = arraySalarios[arraySalarios.length-1];
  const medianaSalarioPorcentaje = salariosEmpresa.medianaSalarioPorcentaje
  const diferenciaSalario = ultimoAño * medianaSalarioPorcentaje;
  const proyeccion = diferenciaSalario + ultimoAño;
  const salariosHistorial = salariosEmpresa.salariosHistorial;
  const salarioMaximo = PlatziMath.ordenarListaInversa(salariosHistorial)[0];
  const salarioMinimo = PlatziMath.ordenarLista(salariosHistorial)[0];
  salariosEmpresa.salarioMaximo = salarioMaximo;
  salariosEmpresa.salarioMinimo = salarioMinimo;
  salariosEmpresa.proyeccion = proyeccion;

  return salariosEmpresa;
}

Mi solución al reto:

function proyecSalariosEmpresaRango(nombreEmpresa){
    const empresa = encontrarEmpresa(nombreEmpresa);
    const rangoSalarios = [];

    for (let year in empresa) {
        PlatziMath.ordernar(empresa[year]);
        let rango = [empresa[year][0],empresa[year][empresa[year].length-1]];
        rangoSalarios.push(rango);
    }
    
    const arrayRangoPorcentaje1 = [];
    const arrayRangoPorcentaje2 = [];

    for (let i = 1; i<rangoSalarios.length;i++) {
        const rangoPorcentaje1 = (rangoSalarios[i][0]-rangoSalarios[i-1][0])/rangoSalarios[i-1][0];
        const rangoPorcentaje2 = (rangoSalarios[i][1]-rangoSalarios[i-1][1])/rangoSalarios[i-1][1];
        arrayRangoPorcentaje1.push(rangoPorcentaje1);
        arrayRangoPorcentaje2.push(rangoPorcentaje2);
    }
    
    ultimosRangos = rangoSalarios[rangoSalarios.length-1];

    const medianaRangoPorcentaje1 = PlatziMath.mediana(arrayRangoPorcentaje1);
    const medianaRangoPorcentaje2 = PlatziMath.mediana(arrayRangoPorcentaje2);


    const proximoRango1 = ultimosRangos[0] + (ultimosRangos[0]*medianaRangoPorcentaje1);
    const proximoRango2 = ultimosRangos[1] + (ultimosRangos[1]*medianaRangoPorcentaje2);

    const proximosRangos = [proximoRango1,proximoRango2];

    return proximosRangos;
} 

Toca estudiar varias veces esta clase 😛

Me han enseñado y motivado mucho estas clases. Me agrada que se utilicen ejemplos “reales”. La clase anterior tuve que verla más de una vez, y lo ha valido. Miren las clases las veces que sean necesarias e impriman en consola todo lo que necesiten XD

function proyeccionProxSalarioEmpresa (empresa){
    if(!empresas[empresa]){
        console.warn(`No hay registros de la empresa ${empresa}`)
    }else{
        const empresaYears = Object.keys(empresas[empresa])
        const listaMedianaYears = empresaYears.map((year)=>{
            return obtenerMedianaEmpresaByYear(empresa, year)
        })
        
        const listaInvertida = listaMedianaYears.sort((a, b)=> b - a)
    

        const medianaSalarioYearActual = listaInvertida[0]
        const medianaSalarioYearAnterior = listaInvertida.find((valor)=> valor !== medianaSalarioYearActual)

        const porcentaMedianajeSalarial = Number((((medianaSalarioYearActual - medianaSalarioYearAnterior)/medianaSalarioYearAnterior) * 100).toFixed(2))

        const medianaNuevoYearSalario = Number((medianaSalarioYearActual * ((1 + (porcentaMedianajeSalarial / 100)))).toFixed(2))
        return medianaNuevoYearSalario
    }
}

Sí, una posible implementación mas sería utilizar la función “map” para recorrer el objeto “empresas” y obtener los salarios más bajos de cada año, y utilizar la función “reduce” para calcular la mediana de los salarios más bajos y el porcentaje de crecimiento entre ellos. Utilice algunos ejemplos de codigo para analizar y enternder mejor el problema:

function proyeccionSalarioMasBajoEmpresa(nombre) {
    if(!empresas[nombre]){
        console.warn("La empresa no existe")
        return
    }else{
       const empresaYears =  Object.keys(empresas[nombre])
       let salariosBajos = empresaYears.map((year)=> PlatziMath.ordenarLista(empresas[nombre][year])[0])
       
       const sumaSalarios = salariosBajos.reduce((acum,val)=>acum+val,0)
       const mediaSalarios = sumaSalarios/salariosBajos.length;
       const porcentajeCrecimiento = salariosBajos.reduce((acum,val,index,arr)=>{
            if(index>0){
                return acum+(val-arr[index-1])/arr[index-1]
            }
            return acum
       },0)/(salariosBajos.length-1)
       console.log({mediaSalarios,porcentajeCrecimiento})
       const nuevoSalario = mediaSalarios*(1+porcentajeCrecimiento)
       return nuevoSalario
    }
}

Esta implementación utiliza menos ciclos “for” y variables adicionales. La función “map” permite recorrer el objeto “empresas” y obtener los salarios más bajos de cada año de manera simplificada. La función “reduce” permite calcular la suma de los salarios, la media y el porcentaje de crecimiento de manera eficiente y en una sola iteración. Además, se evita la necesidad de utilizar una variable adicional para almacenar el porcentaje de crecimiento y se utiliza directamente en el calculo del nuevo salario.

Usé la función calculateMedian() directamente, pero el resultado fue el mismo

function projectionPerCompany(companyName) {
    const companies = sortByCountries();

    if(!companies[companyName]) {
        console.warn('La empresa no existe');
        return;
    }
    else {
        const salariesPerYear = Object.entries(companies[companyName]);
        let mediansPerYear = [];

        for(year of salariesPerYear){
            mediansPerYear.push(PlatziMath.calculateMedian(year[1]));
        }

        let medianIncrease = [];
        for (let i = 1; i < mediansPerYear.length; i++) {
            const currentMedian = mediansPerYear[i];
            const previousMedian = mediansPerYear[i - 1];
            const increase = currentMedian - previousMedian;
            const growthRate = increase / previousMedian;
            
            medianIncrease.push(growthRate);
        }
        
        const medianGrowthPercentage = PlatziMath.calculateMedian(medianIncrease);
        const lastMedian = mediansPerYear[mediansPerYear.length - 1];
        const growth = lastMedian * medianGrowthPercentage;
        const newMedian = lastMedian + growth;

        return newMedian;
    }
}