No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Salarios empresariales

26/30
Recursos

Aportes 26

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

} 

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

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

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.

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, ao) {
  let salarios = baseDatos2[nombre][ao].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); 
  
}