Salarios empresariales

Para los que no saben qué es Mokepón, es porque no han visto la película de Mokepón inc. (Nuevo curso de programación básica):

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

} 

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

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

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

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:

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

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

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
   
}

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

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

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
  }

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

Hola.

Les comparto mi código para proyectar los salarios:

Por Medianas

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

Por rangos

1. Código

   

2. 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.

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

}

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

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
}

const medianaEmpresaYear = (empresa, year) => {
  const empresas = analisisEmpresarial(salarios);
  const salariosEmpresa = empresas[empresa][year];

  if (!salariosEmpresa) {
    console.warn("Su búsqueda no encontró registros");
    return;
  }

  return calculoMath.calculaMediana(salariosEmpresa);
};

Mi solución al reto de la clase 25, adicionando los condicionales:

Comparto mi solución al reto de la clase anterior

• Mira las slides:
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

aAAA es demasiado conocimiento

¿Alguien con miedo a las finanzas?

/ calcular mediana x empresa/año
function calcularMedianaEmpresa(nomEmpresa, year){
    //validar si existe la empresa
    if(!empresas[nomEmpresa]){
       return console.error("Empresa no existe")
    }
    // validar si existe el año
    if(!empresas[nomEmpresa][year]){
        return console.error("Año no existe")
    }

    // seleccion de la empresa
    const empresaSeleccionada=empresas[nomEmpresa][year];
    console.log("Empresa seleccionada",empresaSeleccionada);
    // calcular mediana
    const medianaEmpresa = PlatziMath.calcularMediana(empresaSeleccionada)
    console.log("Mediana",medianaEmpresa);

    return medianaEmpresa;
}

Me di cuenta de mi error en la clase anterior y modifique mi codigo para que esta funcion no fuera tan enredada:

function calcularMedianaEmpresa(nombre, año) {
  let salarios = baseDatos2[nombre][año].map((data)=> data.salario)
  let medianaSalarios = encontrarMediana(salarios).value;

  return medianaSalarios;
}

Comparto mi solucion antes de ver la clase.
Me lie bastante para lograr ubicarme donde queria en cada nuevo asignacion pero logre retornar un nuevo objeto que contiene cada empresa de la lista con sus respectivos años y la mediana de cada año.

//En esta funcion tomamos el objeto empresas que contiene a las distintas empresas agrupadas con objetos , y que dichas empresas contienen los años agrupados en arrays
function medianaOfEachEmpresa(empresas) {
    const medianaDeEmpresas = {}
//En el primer for in iteramos sobre cada uno de los objetos empresa del objeto empresas
    for (const empresa in empresas) {
//Alojamos la informacion de la empresa que estamos iterando 
                const years = empresas[empresa];
//Verificamos si en nuestro objeto vacio "medianaDeEmpresas" existe esa empresa, y si no existe la creamos como propiedad con un objeto vacio dentro
                if(!medianaDeEmpresas[empresa]) {
                medianaDeEmpresas[empresa] = {};
                }
//Dentro del primer for creamos un segundo for donde iteramos sobre los arrays year de cada objeto empresa
        for (const year in years) {
//Alojamos la informacion de la propiedad year que estamos iterando en una variable 
        const periodo = years[year];
//Verificamos si dentro del objeto vacio de la propiedad empresa ya existe el year que estamos iterando, si no existe lo crea
        if (!medianaDeEmpresas[empresa][year]) {
            medianaDeEmpresas[empresa][year] = {};
        }
//Y aqui calculamos la mediana basandonos en el array year que estamos iterando devolviendolo a una nueva propiedad del objeto year
        medianaDeEmpresas[empresa][year] = PlatziMath.calcularMediana(periodo);
        }
    }
    return medianaDeEmpresas;
  }

El resultado final es:

Claramente no conocen MOKEPON:

Bueno, aquí les comparto mi aporte 👨‍💻 . La proyección 📈  la realicé solo teniendo en cuenta los salarios 💰  pagados por cada empresa anteriormente. Calculé la mediana por cada año y el incremento porcentual % por cada año. Seguidamente se calcula el promedio de los incrementos y ese es el dato que se utiliza para proyectar la mediana de los promedios del año siguiente 📆 . Sin hablar más, les presento mi código:

function calcularMedianaSalariosProximoYear(empresa){

  const vectorYearEmpresa = Object.keys(empresas[empresa]); // this is correct

  const vectorMedianaSalariosEmpresa = [];

  for (let year of vectorYearEmpresa){
    let medianaEmpesaYear = calcularMedianaEmpesaYear (empresa, year);
    vectorMedianaSalariosEmpresa.push(medianaEmpesaYear);
  };
  // ya tengo la mediana de todos los años por empresa: vectorMedianaSalariosEmpresa
  // ahora toca calcular el incremento de salarios por cada año en relación al año anterior
  
  const vectorIncrementoPorcentualSalarioEmpresaYear = [];

  for (let i= 1; i < vectorMedianaSalariosEmpresa.length; i++){
    let incrementoBrutoSalarioEmpresaYear = vectorMedianaSalariosEmpresa[i] - vectorMedianaSalariosEmpresa[i-1]
    let incrementoPorcentualSalarioEmpresaYear = incrementoBrutoSalarioEmpresaYear / vectorMedianaSalariosEmpresa[i-1];
    vectorIncrementoPorcentualSalarioEmpresaYear.push(incrementoPorcentualSalarioEmpresaYear);
  };
  // console.log(vectorIncrementoPorcentualSalarioEmpresaYear);
  const promedioIncrementoEmpresaYear = PlatziMath.calcularPromedio(vectorIncrementoPorcentualSalarioEmpresaYear);
  const medianaSalariosProximoYear = vectorMedianaSalariosEmpresa[vectorMedianaSalariosEmpresa.length-1] * (1 + promedioIncrementoEmpresaYear);

  const nextYear = Number(vectorYearEmpresa[vectorYearEmpresa.length-1]) + 1;
  return console.log('La mediana de salarios en la empresa ' + empresa + ' para el próximo año ' + nextYear + ' se proyecta en $' + medianaSalariosProximoYear); 
  
}