Proyección de salarios por empresas

Taller Práctico de JavaScript: Matemáticas y Estadística Básica

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Práctico de JavaScript?
08:20 min

Matemáticas en JavaScript

Porcentajes

Estadística básica

Análisis de salarios

Próximos pasos

27
Toma el Taller Práctico de JavaScript: Videojuegos
04:27 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0022:29

Proyección de salarios por empresas

Taller Práctico de JavaScript: Matemáticas y Estadística Básica

Clase 24 de 27

Clase 24 / 27

Comentarios (29)29 comentarios

marco antonio

Hace 4 años

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

Elizabeth Vega Rosas

Hace 4 años

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

Alessandro Vido

Hace 4 años

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:

Humberto Guardado

Hace 3 años

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.

Miguel Angel Hernandez Colombo

Hace 4 años

te quiero mucho juanDC_Batman

Jorge Campero

Hace 4 años

en este punto las clases estan muyyy potentes

Sebastian Pacheco Lopez

Hace 4 años

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

Elío Diez

Hace 4 años

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

Humberto Guardado

Hace 3 años

interesante

Ricardo Alfonso Chavez Vilcapoma

Hace 4 años

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 😅

Humberto Guardado

Hace 3 años

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

Joserph Camacho

Hace 4 años

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:

Brando Jose Gutierrez Cobis

Hace 4 años

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

++MAYORES SALARIOS:++

}

++MENORES SALARIOS:++

----- ----

Hace 4 años

Toca estudiar varias veces esta clase :P

Enrique Carrillo Vásquez

Hace 3 años

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

CRISTIAN DARIO AGUDELO PORRAS

Hace 3 años

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!

Ivan de jesus Romero leal

Hace 4 años

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


}

Leopoldo Martinez

Hace 4 años

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
  }

Juan Fernando Yepes Muñoz

Hace 4 años

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

});

Eliezer Hernandez

Hace 4 años

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.

Jefred Bedoya

Hace 6 meses

Mi solucion

function proyeccionPorEmpresa(nombreEmpresa) {
    const empresa = empresas[nombreEmpresa]

    if (!empresa) {
        console.warn('La empresa no existe')
        return
    }

    const anios = obtenerAniosOrdenados(empresa)
    const medianasPorYear = anios.map((year) =>
        PlatziMath.calcularMediana(empresa[year])
    )

    const salarioProyectado = proyectarSiguienteValor(medianasPorYear)

    if (salarioProyectado === undefined) {
        return
    }

    return `El salario proyectado para ${formatearNombre(nombreEmpresa)} en el siguiente anio es de ${salarioProyectado.toFixed(2)}`
}

Julio Peña

Hace 4 años

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

}
};

Rafael Vivenzio

Hace 4 años

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

Johnner Alexander Gambacica Ortiz

Hace 3 años

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.

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

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

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

``
// 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);

```  }
```

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

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)

}

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

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


}

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
  }

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

});

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

function proyeccionPorEmpresa(nombreEmpresa) {
    const empresa = empresas[nombreEmpresa]

    if (!empresa) {
        console.warn('La empresa no existe')
        return
    }

    const anios = obtenerAniosOrdenados(empresa)
    const medianasPorYear = anios.map((year) =>
        PlatziMath.calcularMediana(empresa[year])
    )

    const salarioProyectado = proyectarSiguienteValor(medianasPorYear)

    if (salarioProyectado === undefined) {
        return
    }

    return `El salario proyectado para ${formatearNombre(nombreEmpresa)} en el siguiente anio es de ${salarioProyectado.toFixed(2)}`
}

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

}
};

Introducción

¿Ya tomaste el Curso Práctico de JavaScript?

Matemáticas en JavaScript

Fórmulas matemáticas en JavaScript

Math en JavaScript

Reto: altura de un triángulo

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Estadística básica

Qué es promedio, moda y mediana

Calculando el promedio

Método reduce

Calculando la mediana en una lista impar

Calculando la mediana en una lista par

Método sort

Calculando la moda: objetos a partir de arrays

Calculando la moda: arrays a partir de objetos

Promedio Ponderado en JavaScript: Fórmulas y Casos de Uso

PlatziMath: clases y métodos estáticos

Análisis de salarios

Cómo estructurar información en proyectos de software

Análisis salarial con JavaScript

Proyección salarial personal

Reestructurando información sobre la marcha

Salarios empresariales

Proyección de salarios por empresas

Top 10% de salarios

Análisis de la Mediana Salarial con HTML, CSS y JavaScript

Próximos pasos

Toma el Taller Práctico de JavaScript: Videojuegos

Proyección de salarios por empresas