Salarios empresariales

Cursos Empresas Blog Live Conf Precios

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

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

Tomar examen

Salarios empresariales

Comentarios

Juan David Cardona Lopez

student

Aquí les dejo la solución que hice antes de ver la clase y quedó un poco parecida a la del profe

function mediaEmpresa(nombreEmpresa, year){

    if(empresas[nombreEmpresa]){
        if(empresas[nombreEmpresa][year]){
            return PlatziMath.identificarLista(empresas[nombreEmpresa][year])
        }else{
            console.log("Nadie trabajo durante " + year + " en la empresa")
        }
    }else{
        console.log("La empresa " + nombreEmpresa + " no existe")
    }

}

CRISTIAN DARIO AGUDELO PORRAS

student

podrias ahorrarte el 2do condicional con el operador && de la siguiente manera:

if (empresas[nombreEmpresa] && empresas[nombreEmpresa][year]

en ese caso, si cumple ambas condiciones continua con tu logica.

marco antonio

student

yo hice las operaciones de forma individual por año y la proyección de forma general

no tiene nada que ver con la clase pero me lie con la grafica pero al final la hice funcionar como quiero
código
page

Uriel Solis Salinas

student

Holaaa, oye me gustaron mucho tus gráficas, una duda, ¿como hiciste los GIFs?

marco antonio

student

@euss99 gracias +w+, bueno los gifs los hice grabando la pantalla con el obs después edite el video y lo convertí en gif en ezgif es una web que te permite convertir un video en gif y ya por ultimo lo subí a Giphy para poder insertarlo aquí en platzi

Sergio Javier Lopez Olivera

student

Reto completado: . . . Proyección salarial por empresa

function projectionByBusiness(name) {
	let salariesOfYears = Object.entries(empresas[name]);

  let lowTierSalaries = [];
        for (year of salariesOfYears) {
            lowTierSalaries.push(year[1][0]);
        }   
    let lowTierSalariesSorted = lowTierSalaries.sort( (a, b) => a - b);
    let growFactorLowTier = [];
    calculateGrowFactor(lowTierSalariesSorted, growFactorLowTier);

    let lowTierMedianFactor = PlatziMath.median(growFactorLowTier);
    let lowTierProjection = calculateProjection(lowTierMedianFactor, lowTierSalaries);

        //I leaved lowTierSalaries as an argument in the previous function to address specifically last element of the array
        // calculateGrowFactor and calculateProjection are both functions used to clean lines of code inside this function of salaries projection by business
        //at this point we have calculated the low tier salary projection for next period


    let highTierSalaries = [];

    for (year of salariesOfYears) {
        highTierSalaries.push(year[1][year[1].length - 1]);
        //year[1] is an array. We enter in the position that is its own length - 1: ie = last number
    }
    let highTierSalariesSorted = highTierSalaries.sort( (a, b) => a - b);

    let growFactorHighTier = [];

    calculateGrowFactor(highTierSalariesSorted, growFactorHighTier);
    let highTierMedianFactor = PlatziMath.median(growFactorHighTier);

    let highTierProjection = calculateProjection(highTierMedianFactor, highTierSalaries);

    let rangeArray = [];
    rangeArray.push(lowTierProjection);
    rangeArray.push(highTierProjection);

    return rangeArray;
}

//additional functions to calculate grow factor and projection

function calculateGrowFactor(array, array2) {
    for (let i = 1; i < array.length; i++) {
        let presentSalary = array[i];
        let pastSalary = array[i - 1];
        let difference = presentSalary - pastSalary;
        let growFactor = Number((difference / pastSalary).toFixed(3));
        array2.push(growFactor);
    }
}

function calculateProjection(factor, array) {
    return (factor * array[array.length - 1]) + array[array.length - 1];
}

Eliezer Hernandez

student

Mi solución para calcular la mediana por año de una empresa

Gualberto Montiel

student

Claramente no conocen MOKEPON:

!mokepon

Ricardo Alfonso Chavez Vilcapoma

student

¿Alguien con miedo a las finanzas?

Irving Saenz

student

Este es el código de la clase pasada donde hice la mediana de un año en específico.

Estos son los resultados de la re-estructuración de la información:

Y este es el resultado de la mediana

Y esto fue lo que hice para calcular la projección de cuánto será lo que se invierte en salarios para el siguiente año:

En este caso utilicé a Freelance y estas son las ganancias a lo largo de sus años:

Y esta es la proyección del total de sueldos para el siguiente año:

Jose Angel Esquivel Cisneros

student

function medianaPorEmpresa(empresa) {
    var medianaPorAnho = [];
    var medianaEmpresa = [];
    if (!empresas[empresa]) {
        return "no hay empresa con ese nombre"
    } else {
        for (let anho = 2018; anho <= 2023; anho++) {
            var mediana = PlatziMath.calcularMediana(empresas[empresa][String(anho)]);
            medianaPorAnho.push(mediana);
        }
        return PlatziMath.calcularMediana(medianaPorAnho)
    }
}

function medianaPorAnhoEnEmpresa(empresa,anho) {
    var medianaPorAnho = [];
    if (!empresas[empresa]) {
        return "no hay empresa con ese nombre"
    } else if(!empresas[empresa][String(anho)]){
        return "no hay existe ese año en la empresa"
    } else {
        var mediana = PlatziMath.calcularMediana(empresas[empresa][String(anho)]);
    medianaPorAnho.push({ anho, mediana }); 
    return  medianaPorAnho 
    }
}

Leonardo Dillon

student

Buenas. Dejo mi aporte. Yo lo que hice fue calcular la mediana de cada año y agregarla cómo dato luego del ultimo cómo un objeto. Quedaría así cuando llamas al objeto. 2018: Array(8) 0: 250 - 1: 450 - 2: 600 - 3: 750 - 4: 500 - 5: 400 - 6: 500 - 7: 600 - Mediana: [625] ( Los innerText son de una de la página de donde voy haciendo todos los ejercicios )

let 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]["Mediana"] = []
                  }
                  empresas[trabajo.empresa][trabajo.year].push(trabajo.salario)
            }
      }
      if(!(empresas[nombreEmpresa][anioEmpresa13C]==undefined)){
            for(persona of salarios){
                  for( trabajo of persona.trabajos){
                        empresas[trabajo.empresa][trabajo.year]["Mediana"] = ( [calcularMediana(empresas[trabajo.empresa][trabajo.year])] )
                  }
            }
            respuesta.innerText = `Respuesta = La mediana de ${nombreEmpresa} para el año ${anioEmpresa13C} es de ${empresas[nombreEmpresa][anioEmpresa13C]["Mediana"]} `
      }else{

            respuesta.innerText = `La empresa no registra salarios en ${anioEmpresa13C}`
      }

Alan Muñoz Badillo

student

Hola. les dejo la versión para consultar por una empresa especifica, la hice ante y la única diferencia es que pido por parámetro la fuente de los datos, y luego hice recorriendo los objetos para sacar automáticamente la media de todos los años de todas las empresas.

Código empresa específicaÑ

<function mediaAnioEmpresaEspacifica(listaEmpresas, nombre, year) {
    if(!listaEmpresas[nombre]) {
        return 'No existe empresa'
    }
    if(!listaEmpresas[nombre][year]) {
        return 'No exite el anio'
    }
    let salarioAnioEspecifico = listaEmpresas[nombre][year]
    let mediaAnioEsoecifico = AlanMath.Mediana(salarioAnioEspecifico)
    return mediaAnioEsoecifico
}

Código para consulta de todas la empresas y la media de todos sus años:

function mediaAniosEmpresa() {
    const datosEmpresas = datosSalarialesEmpresa(salarios);
    let mediaPorAnios = {};
    for(let empresa of Object.keys(datosEmpresas)) {
            mediaPorAnios[empresa] = {}
        for(let year of Object.keys(datosEmpresas[empresa])) {
            mediaPorAnios[empresa][year] = AlanMath.Mediana(datosEmpresas[empresa][year]); 
        }
    }
    return mediaPorAnios
   
}

Manuel Perez

student


let calcularMedianaEmpresas =  (nombreEmpresa, ano) => {
    
    if(!empresas[nombreEmpresa]){
        console.warn('la empresa no existe');
        return;
    }
    if(!empresas[nombreEmpresa][ano]){
        console.warn('El año no existe');
        return;
    }
    let empresaSeleccionada = empresas[nombreEmpresa][ano];
    let medianaEmpresa = CalculadoraDePromedios.calcularMediana(empresaSeleccionada)
    return medianaEmpresa;

}

console.log(calcularMedianaEmpresas('Freelance',2018));

Felipe Moreno

student

Mi solución: Realicé una función que recibe 2 argumentos, uno que recibe el nombre de la empresa y el otro recibe 1 o 0, donde al pasarle 1 retornará proyección de salario como rango y al pasarle 0 retornará dicha proyección como valor absoluto.

function proyeccionSalarioEmpresas(empresa, option=0){
    if(!empresas[empresa]){
        console.warn('No existe información de la empresa referenciada');
    }else if(empresas[empresa] && option == 0){
        const mediana_salarios = [];
        const aumentos = [];
        for (const year in empresas[empresa]) {
            mediana_salarios.push(PlatziMath.calcular_mediana(empresas[empresa][year]));
        };
        for (let i = 1; i < mediana_salarios.length; i++) {
            aumentos.push(mediana_salarios[i] - mediana_salarios[i-1]);
        };
        const mediana_aumentos = PlatziMath.calcular_mediana(aumentos);
        const proyeccion = mediana_salarios[mediana_salarios.length - 1] + mediana_aumentos;
        return proyeccion;
    }else if(empresas[empresa] && option == 1){
        const lowest_salarios = [];
        const highest_salarios = [];
        for (const year in empresas[empresa]) {
            const salarios_ordenados = empresas[empresa][year].sort((a,b) => a - b);
            lowest_salarios.push(salarios_ordenados[0]);
            highest_salarios.push(salarios_ordenados[salarios_ordenados.length -1]);
        };
        return {
            lower: PlatziMath.calcular_mediana(lowest_salarios),
            higher: PlatziMath.calcular_mediana(highest_salarios)
        }
    }
}

Leopoldo Martinez

student

Esta fue la solucion al reto de la proyeccion anual por empresa

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
  }

Paula Inés Cudicio

student

Bueno, aquí va mi aporte

En donde dice datos en la primer función la idea es pasarle salarios

function findAllCompanies(datos) {
    const companies = {}
    for(person of datos) {
        for(trabajo of person.trabajos) {
            if(!companies[trabajo.empresa]) {
                companies[trabajo.empresa] = {};
            }

            if(!companies[trabajo.empresa][trabajo.year]) {
                companies[trabajo.empresa][trabajo.year] = [];
            }

            companies[trabajo.empresa][trabajo.year].push(trabajo.salario);
        }
    } 

    return companies
} 

//Ahora queremos sacar la mediana de salario de cada empresa por año

function yearMediana(year, companyName) {
    let companies = findAllCompanies(salarios);
    let companyData = companies[companyName];
    if(companyData) {
        let salaries = companyData[year]
        if(salaries) return PlatziMath.medianaCalculator(salaries);
        else return 'Año no trabajado'
    } else return 'Empresa no encontrada'
   
}

Antonio Mora

student

Hola.

Les comparto mi código para proyectar los salarios:

Por Medianas

Código
Resultado MarketerosCOL: Estima un aumento de salarios del 3.303780411393231 %

Por rangos

Código
Resultado MarketerosCOL : Los salarios proyectados para el proximo year son: Menor 760.42 y Mayor 2297.4

Nota: Utilice la media geométrica, ya que es la recomendada para porcentajes. Fuente de información Media geométrica.

Anthony Arellano

student

Según lo que entendí del reto planteado, la idea era crear un rango de salarios entre los cuales podría estar el salario a pagar por la empresa. Creé 2 listas ordenadas, en las cuales en una guardé os salarios más bajos y otra con los salarios más altos. Luego creé una lista con 2 valores hechos en base a las medianas de ambas listas y así obtener un rango entre los cuales podría estar el salario del próximo año.function companyRangeSalaryProjection(companyName){ const lowerSalaries = [] const higherSalaries = [] if(companies[companyName]){ const companyToEvaluate = companies[companyName] Object.values(companyToEvaluate).forEach(year => { year.sort((x,y) => - y + x) lowerSalaries.push(year[0]) higherSalaries.push(year[year.length - 1]) }) const rangeProjection = [YnohtsMath.calculateMedian(lowerSalaries), YnohtsMath.calculateMedian(higherSalaries)] return rangeProjection } else { return La empresa ${companyName} no se encuentra en la base de datos. }}

function companyRangeSalaryProjection(companyName){
  const lowerSalaries = []
  const higherSalaries = []
  if(companies[companyName]){
    const companyToEvaluate = companies[companyName]
    Object.values(companyToEvaluate).forEach(year => {
      year.sort((x,y) => - y + x)
      lowerSalaries.push(year[0])
      higherSalaries.push(year[year.length - 1])
    })
    const rangeProjection = [YnohtsMath.calculateMedian(lowerSalaries), YnohtsMath.calculateMedian(higherSalaries)]
    return rangeProjection
  } else {
    return `La empresa ${companyName} no se encuentra en la base de datos.`
  }
}

Ulqernesh Karvenae

student

class Enterprise {
  constructor (nameCompany) {
    if (!enterprise[nameCompany]) throw new Error('Nombre de empresa no encontrado');
    this.nameCompany = nameCompany
    this.dataCompany = enterprise[this.nameCompany]
    this.years = Object.keys(this.dataCompany).map((value) => parseInt(value))
    this.salaries =  Object.values(this.dataCompany).map((element) => element.sort((a , b) => a - b))
  }

  median = (year) => {
    if (!this.dataCompany[year]) {
      return 'No se encontro data para el año seleccionado \nIntenta generar una prediccion';
    }
    return MathEstadistic.mediana(this.dataCompany[year]);
  }

  predictData = (year) => {

    const minSalary = this.salaries.map((values) => values[0])
    const maxSalary = this.salaries.map((values) => values[values.length - 1])

    const linearRegressionMin = linearRegression(this.years, minSalary, year)
    const linearRegressionMax = linearRegression(this.years, maxSalary, year)
    return { linearRegressionMin , linearRegressionMax}
  }

  predictNextYear = () => {

    const minSalary = this.salaries.map((values) => values[0])
    const maxSalary = this.salaries.map((values) => values[values.length - 1])

    const medianMinYear = medianProjectionNextYear(this.years, minSalary)
    const medianMaxYear = medianProjectionNextYear(this.years, maxSalary)

    return { medianMinYear, medianMaxYear}
  }
}

try {
  const COMPANY_1 = new Enterprise('MarketerosCOL');
  const median = COMPANY_1.median(2021);
  const predictDataC = COMPANY_1.predictData(2024);
  const predictNextYearC = COMPANY_1.predictNextYear()
  console.log(median);
  console.log(predictDataC);
  console.log(predictNextYearC)

} catch (error) {
  console.error(error.message);
}

```Se aplicaron ambos metodos la regresion lineal y por la media de aumento y es mas optimista la regresion lineal

{ linearRegressionMin: '770.000', linearRegressionMax: '2333.333' }

{ medianMinYear: '750.000', medianMaxYear: '2000.000' }

Andres Montes

student

asi solucione el reto, agrege condicional por si la empresa que se busca no existe, indique que no existe, y lo mismo con el año

function calcularEmpresaMediana(nombreEmpresa, yearEmpresa) {
    if (empresas[nombreEmpresa]) {
        let empresa = empresas[nombreEmpresa]
        if (empresa[yearEmpresa]) {
            let yearARevisar = empresa[yearEmpresa]
            const mediaEmpresaYear = PlatziMath.calcularMediana(yearARevisar)
            return mediaEmpresaYear

        } else {
            console.warn('año no valido de la empresa')
        }
    } else {
        console.warn('esa empresa no esta en la base de datos')
    }

}

Kevin Cantú Gómez

student

Mi solución antes de ver la clase completa, prácticamente igual a la del profe :)

function calcularMedianaEmpresaSalarios(nombreEmpresa, yearU){
    if(empresas[nombreEmpresa][yearU]){
        const salariosArray = empresas[nombreEmpresa][yearU];
        return ObjectMath.calcularMediana(salariosArray);
    }
}

Nestor Rios Garcia

student

Asi mi solucion

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

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

function mediaEmpresa(nombreEmpresa, year){

    if(empresas[nombreEmpresa]){
        if(empresas[nombreEmpresa][year]){
            return PlatziMath.identificarLista(empresas[nombreEmpresa][year])
        }else{
            console.log("Nadie trabajo durante " + year + " en la empresa")
        }
    }else{
        console.log("La empresa " + nombreEmpresa + " no existe")
    }

} 

function projectionByBusiness(name) {
	let salariesOfYears = Object.entries(empresas[name]);

  let lowTierSalaries = [];
        for (year of salariesOfYears) {
            lowTierSalaries.push(year[1][0]);
        }   
    let lowTierSalariesSorted = lowTierSalaries.sort( (a, b) => a - b);
    let growFactorLowTier = [];
    calculateGrowFactor(lowTierSalariesSorted, growFactorLowTier);

    let lowTierMedianFactor = PlatziMath.median(growFactorLowTier);
    let lowTierProjection = calculateProjection(lowTierMedianFactor, lowTierSalaries);

        //I leaved lowTierSalaries as an argument in the previous function to address specifically last element of the array
        // calculateGrowFactor and calculateProjection are both functions used to clean lines of code inside this function of salaries projection by business
        //at this point we have calculated the low tier salary projection for next period


    let highTierSalaries = [];

    for (year of salariesOfYears) {
        highTierSalaries.push(year[1][year[1].length - 1]);
        //year[1] is an array. We enter in the position that is its own length - 1: ie = last number
    }
    let highTierSalariesSorted = highTierSalaries.sort( (a, b) => a - b);

    let growFactorHighTier = [];

    calculateGrowFactor(highTierSalariesSorted, growFactorHighTier);
    let highTierMedianFactor = PlatziMath.median(growFactorHighTier);

    let highTierProjection = calculateProjection(highTierMedianFactor, highTierSalaries);

    let rangeArray = [];
    rangeArray.push(lowTierProjection);
    rangeArray.push(highTierProjection);

    return rangeArray;
}

//additional functions to calculate grow factor and projection

function calculateGrowFactor(array, array2) {
    for (let i = 1; i < array.length; i++) {
        let presentSalary = array[i];
        let pastSalary = array[i - 1];
        let difference = presentSalary - pastSalary;
        let growFactor = Number((difference / pastSalary).toFixed(3));
        array2.push(growFactor);
    }
}

function calculateProjection(factor, array) {
    return (factor * array[array.length - 1]) + array[array.length - 1];
}

function medianaPorEmpresa(empresa) {
    var medianaPorAnho = [];
    var medianaEmpresa = [];
    if (!empresas[empresa]) {
        return "no hay empresa con ese nombre"
    } else {
        for (let anho = 2018; anho <= 2023; anho++) {
            var mediana = PlatziMath.calcularMediana(empresas[empresa][String(anho)]);
            medianaPorAnho.push(mediana);
        }
        return PlatziMath.calcularMediana(medianaPorAnho)
    }
}

function medianaPorAnhoEnEmpresa(empresa,anho) {
    var medianaPorAnho = [];
    if (!empresas[empresa]) {
        return "no hay empresa con ese nombre"
    } else if(!empresas[empresa][String(anho)]){
        return "no hay existe ese año en la empresa"
    } else {
        var mediana = PlatziMath.calcularMediana(empresas[empresa][String(anho)]);
    medianaPorAnho.push({ anho, mediana }); 
    return  medianaPorAnho 
    }
}

let 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]["Mediana"] = []
                  }
                  empresas[trabajo.empresa][trabajo.year].push(trabajo.salario)
            }
      }
      if(!(empresas[nombreEmpresa][anioEmpresa13C]==undefined)){
            for(persona of salarios){
                  for( trabajo of persona.trabajos){
                        empresas[trabajo.empresa][trabajo.year]["Mediana"] = ( [calcularMediana(empresas[trabajo.empresa][trabajo.year])] )
                  }
            }
            respuesta.innerText = `Respuesta = La mediana de ${nombreEmpresa} para el año ${anioEmpresa13C} es de ${empresas[nombreEmpresa][anioEmpresa13C]["Mediana"]} `
      }else{

            respuesta.innerText = `La empresa no registra salarios en ${anioEmpresa13C}`
      }

<function mediaAnioEmpresaEspacifica(listaEmpresas, nombre, year) {
    if(!listaEmpresas[nombre]) {
        return 'No existe empresa'
    }
    if(!listaEmpresas[nombre][year]) {
        return 'No exite el anio'
    }
    let salarioAnioEspecifico = listaEmpresas[nombre][year]
    let mediaAnioEsoecifico = AlanMath.Mediana(salarioAnioEspecifico)
    return mediaAnioEsoecifico
}

function mediaAniosEmpresa() {
    const datosEmpresas = datosSalarialesEmpresa(salarios);
    let mediaPorAnios = {};
    for(let empresa of Object.keys(datosEmpresas)) {
            mediaPorAnios[empresa] = {}
        for(let year of Object.keys(datosEmpresas[empresa])) {
            mediaPorAnios[empresa][year] = AlanMath.Mediana(datosEmpresas[empresa][year]); 
        }
    }
    return mediaPorAnios
   
}

let calcularMedianaEmpresas =  (nombreEmpresa, ano) => {
    
    if(!empresas[nombreEmpresa]){
        console.warn('la empresa no existe');
        return;
    }
    if(!empresas[nombreEmpresa][ano]){
        console.warn('El año no existe');
        return;
    }
    let empresaSeleccionada = empresas[nombreEmpresa][ano];
    let medianaEmpresa = CalculadoraDePromedios.calcularMediana(empresaSeleccionada)
    return medianaEmpresa;

}

console.log(calcularMedianaEmpresas('Freelance',2018));

function proyeccionSalarioEmpresas(empresa, option=0){
    if(!empresas[empresa]){
        console.warn('No existe información de la empresa referenciada');
    }else if(empresas[empresa] && option == 0){
        const mediana_salarios = [];
        const aumentos = [];
        for (const year in empresas[empresa]) {
            mediana_salarios.push(PlatziMath.calcular_mediana(empresas[empresa][year]));
        };
        for (let i = 1; i < mediana_salarios.length; i++) {
            aumentos.push(mediana_salarios[i] - mediana_salarios[i-1]);
        };
        const mediana_aumentos = PlatziMath.calcular_mediana(aumentos);
        const proyeccion = mediana_salarios[mediana_salarios.length - 1] + mediana_aumentos;
        return proyeccion;
    }else if(empresas[empresa] && option == 1){
        const lowest_salarios = [];
        const highest_salarios = [];
        for (const year in empresas[empresa]) {
            const salarios_ordenados = empresas[empresa][year].sort((a,b) => a - b);
            lowest_salarios.push(salarios_ordenados[0]);
            highest_salarios.push(salarios_ordenados[salarios_ordenados.length -1]);
        };
        return {
            lower: PlatziMath.calcular_mediana(lowest_salarios),
            higher: PlatziMath.calcular_mediana(highest_salarios)
        }
    }
}

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
  }

function findAllCompanies(datos) {
    const companies = {}
    for(person of datos) {
        for(trabajo of person.trabajos) {
            if(!companies[trabajo.empresa]) {
                companies[trabajo.empresa] = {};
            }

            if(!companies[trabajo.empresa][trabajo.year]) {
                companies[trabajo.empresa][trabajo.year] = [];
            }

            companies[trabajo.empresa][trabajo.year].push(trabajo.salario);
        }
    } 

    return companies
} 

//Ahora queremos sacar la mediana de salario de cada empresa por año

function yearMediana(year, companyName) {
    let companies = findAllCompanies(salarios);
    let companyData = companies[companyName];
    if(companyData) {
        let salaries = companyData[year]
        if(salaries) return PlatziMath.medianaCalculator(salaries);
        else return 'Año no trabajado'
    } else return 'Empresa no encontrada'
   
}

function companyRangeSalaryProjection(companyName){
  const lowerSalaries = []
  const higherSalaries = []
  if(companies[companyName]){
    const companyToEvaluate = companies[companyName]
    Object.values(companyToEvaluate).forEach(year => {
      year.sort((x,y) => - y + x)
      lowerSalaries.push(year[0])
      higherSalaries.push(year[year.length - 1])
    })
    const rangeProjection = [YnohtsMath.calculateMedian(lowerSalaries), YnohtsMath.calculateMedian(higherSalaries)]
    return rangeProjection
  } else {
    return `La empresa ${companyName} no se encuentra en la base de datos.`
  }
}

class Enterprise {
  constructor (nameCompany) {
    if (!enterprise[nameCompany]) throw new Error('Nombre de empresa no encontrado');
    this.nameCompany = nameCompany
    this.dataCompany = enterprise[this.nameCompany]
    this.years = Object.keys(this.dataCompany).map((value) => parseInt(value))
    this.salaries =  Object.values(this.dataCompany).map((element) => element.sort((a , b) => a - b))
  }

  median = (year) => {
    if (!this.dataCompany[year]) {
      return 'No se encontro data para el año seleccionado \nIntenta generar una prediccion';
    }
    return MathEstadistic.mediana(this.dataCompany[year]);
  }

  predictData = (year) => {

    const minSalary = this.salaries.map((values) => values[0])
    const maxSalary = this.salaries.map((values) => values[values.length - 1])

    const linearRegressionMin = linearRegression(this.years, minSalary, year)
    const linearRegressionMax = linearRegression(this.years, maxSalary, year)
    return { linearRegressionMin , linearRegressionMax}
  }

  predictNextYear = () => {

    const minSalary = this.salaries.map((values) => values[0])
    const maxSalary = this.salaries.map((values) => values[values.length - 1])

    const medianMinYear = medianProjectionNextYear(this.years, minSalary)
    const medianMaxYear = medianProjectionNextYear(this.years, maxSalary)

    return { medianMinYear, medianMaxYear}
  }
}

try {
  const COMPANY_1 = new Enterprise('MarketerosCOL');
  const median = COMPANY_1.median(2021);
  const predictDataC = COMPANY_1.predictData(2024);
  const predictNextYearC = COMPANY_1.predictNextYear()
  console.log(median);
  console.log(predictDataC);
  console.log(predictNextYearC)

} catch (error) {
  console.error(error.message);
}

```Se aplicaron ambos metodos la regresion lineal y por la media de aumento y es mas optimista la regresion lineal

{ linearRegressionMin: '770.000', linearRegressionMax: '2333.333' }

{ medianMinYear: '750.000', medianMaxYear: '2000.000' }

function calcularEmpresaMediana(nombreEmpresa, yearEmpresa) {
    if (empresas[nombreEmpresa]) {
        let empresa = empresas[nombreEmpresa]
        if (empresa[yearEmpresa]) {
            let yearARevisar = empresa[yearEmpresa]
            const mediaEmpresaYear = PlatziMath.calcularMediana(yearARevisar)
            return mediaEmpresaYear

        } else {
            console.warn('año no valido de la empresa')
        }
    } else {
        console.warn('esa empresa no esta en la base de datos')
    }

}

function calcularMedianaEmpresaSalarios(nombreEmpresa, yearU){
    if(empresas[nombreEmpresa][yearU]){
        const salariosArray = empresas[nombreEmpresa][yearU];
        return ObjectMath.calcularMediana(salariosArray);
    }
}

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

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

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

Playground: Calcula la Altura de un Triángulo Escaleno

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Playground: Encuentra el ID

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

Playground: Transforma Objetos en Arrays

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