Reestructurando información sobre la marcha

Ok, incluso a alguien que sabe de JS desde hace algún tiempo esto quema un poco el cerebro XD pero es bueno saber que uno aprende y mejora poco a poco.

llevo varias clases sin entender nada jaja 😦
esto es realmente complicado

mi cara! 😢

Explicación

Utilicé el método forEach():

/**Análisis empresarial */
const company = () => {
    const empresas = {};

    salarios
        .forEach(item => item.trabajos.forEach(item => {
            if (!empresas[item.empresa]) empresas[item.empresa] = {};
            else {
                if (!empresas[item.empresa][item.year]) empresas[item.empresa][item.year] = [];
                else empresas[item.empresa][item.year].push(item.salario);
            }
        }));
    return empresas;
}

console.log(company());

Comparto mis apuntes, espero se puedan ayudar a la comprensión de la restructuración hecha

Estoy así 😦

8:20 JAJAJA, de con razón todo en español excepto el ‘year’.

function meadianaSalarioYear(nombreEmpresa, year) {
  const arrayYear = empresas[nombreEmpresa][year];
  const medianaSalario = PlatziMath.calcularMediana(arrayYear);
  return medianaSalario
}

Usando la funcion de calcularMediana y obteniendo el array de salarios en x año del objeto empresas

Me gustó en cierto modo la solución del profesor pero la verdad es que es verbosa in extremis, acá un snippet mas funcional y compacta:

const empresas = salarios
  .map(persona => persona.trabajos)
  .reduce((prev, trabajos) => {
    trabajos.forEach(({ year, empresa, salario }) => {
      if (!prev[empresa]) prev[empresa] = {}
      if (!prev[empresa][year]) prev[empresa][year] = []
      prev[empresa][year].push(salario)
    })
    return prev;
  }, {});

Notas de la clase:

Analisis empresarial

Reordenaremos la informacion que tenemos de modo que tengamos un objeto con las distintas empresas, y en donde a su vez, cada una tendra un array por cada año registrado con los salarios que han tenido las personas en dichos años.

// Crear una variable de tipo objeto en donde tendremos la informacion ordenada por empresa:
const empresas = {};
// Recorrer el array de salarios:
for (persona of salarios) {
  // Recorrer cada uno de los trabajos que han tenido las personas:
  for (trabajo of persona.trabajos) {
    // Crear una propiedad dentro del objeto 'empresas' por cada una de las empresas. Si la empresa no existe dentro del objeto se crea la empresa como propiedad y su valor sera un objeto:
    if (!empresas[trabajo.empresa]) {
      empresas[trabajo.empresa] = {};
    }
    // Dentro de cada empresa se creará una propiedad por cada año que tengan registradas las personas que hayan trabajado en dicha empresa, y el valor de esta propiedad sera un array:
    if (!empresas[trabajo.empresa][trabajo.year]) {
      empresas[trabajo.empresa][trabajo.year] = [];
    }
    // Dentro del array de la propiedad de año se insertaran los salarios que se tengan registrados para dichos años:
    empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
  }
}

console.log(empresas);

yo utilice la misma logica pero con otra sintaxis, para practicar:

const empresas = {};
reestrurarArray();

function reestrurarArray (){
    salarios.forEach (persona=>persona.trabajos.forEach(trabajo=>{
        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);
    }))
}

Ok yo lo hice así

 

Desarrolle una fución para registrar las empresas(así ya no tenía que hacerlo yo mismo 😅) a partir de la información del array de “salarios” y además esta función registra los salarios por año en la empresa.

.
Resultado mostrado en consola:

.
Código:

function registrarPersona(empresas) {
  salarios.forEach(({ trabajos, name }) => {
    trabajos.forEach(({ year, empresa, salario }) => {
      if (!empresas[empresa]) {
        empresas[empresa] = {};
      }
      if (!empresas[empresa][year]) {
        empresas[empresa][year] = [];
      }
      empresas[empresa][year].push(salario);
    });
  });
}
registrarPersona(empresas);
console.log(empresas);

Me tomo tiempo entender todo, pero pude entenderlo mas fácil con este método:
Haz todo por partes. Es decir cuando escribas el primer for “for(trabajo of salarios){}” solo pon dentro un console.log para que veas que es lo que devuelve la consola:

const empresas = {}; // Aqui guardamos toda la información de todas las empresas que tengamos
for (persona of salarios) { 
	console.log(persona);
}

Cuando entiendas bien que es lo que hace ese for escribe el siguiente y haz un console.log:

const empresas = {}; // Aqui guardamos toda la información de todas las empresas que tengamos
for (persona of salarios) { //
     for (trabajo of persona.trabajos) {
       console.log(trabajo);
    } 
}

De esta forma tendrás una mejor idea de lo que hace cada ciclo for con el array salarios.

Me quemó las neuronas pero acá esta mi solución 🫠

function estructurarEmpresas(arraySalarios){
    const trabajos_globales = [];
    arraySalarios.forEach(salario => {
        trabajos_globales.push(...salario.trabajos);
    });
    const empresas = {};
    for (let i = 0; i < trabajos_globales.length; i++) {
        empresas[trabajos_globales[i].empresa] = {};
    }

    for (const empresa in empresas) {
        for (let i = 0; i < trabajos_globales.length; i++) {
            if(trabajos_globales[i].empresa == empresa){
                empresas[empresa][trabajos_globales[i].year] = [];
            }
        }
        for (let i = 0; i < trabajos_globales.length; i++) {
            if(trabajos_globales[i].empresa == empresa){
                empresas[empresa][trabajos_globales[i].year].push(trabajos_globales[i].salario);
            }
        }
    }
    return empresas;
}

Aqui mi solución al reto, aunque creo que fue un código muy largo pero al menos cuando vea la solución del profesor veré como cambio mi lógica para optimizar mi código, pero por ahora da el resultado esperado:
Código:

Output:

A ver si les ayuda un poco más esta explicación en la función que hizo el profe, a mi me ayudó un poco más.

/* Recorriendo el arreglo de salarios.*/
for (persona of salarios) {
   /* Por cada persona en el arreglo de salarios, se esta recorriendo cada uno de los trabajos que tuvo la persona. */
    for (trabajo of persona.trabajos) {
        /* Se está haciendo un nuevo objeto de "empresas" que tenga una propiedad por cada distinta empresa. */
        if (!empresas[trabajo.empresa]) {
            empresas[trabajo.empresa] = {};
        }
        /*Por cada distinta empresa, se esta creando una propiedad con el año en la que esa empresa tuvo empleados recibiendo un salario.*/
        if (!empresas[trabajo.empresa][trabajo.year]) {
            empresas[trabajo.empresa][trabajo.year] = [];
        }
        /* Por cada año, se esta agregando un array con los distintos salarios.*/
        empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
    }
}

Puedo sacar la mediana con esta función (todo debajo del código que escribimos en la restructuracion).

// Sacar la mediana por empresa y año seleccionados en la funcion

function medianaEmpresa (empresa, year){
    array = empresas[empresa][year];
    let mediana = MathCalculos.calcularMediana(array);
    console.log(mediana);

}
medianaEmpresa("MarketerosCOL",2022);
// 900

Hice el mismo código, pero utilizando map y object.values:

const empresasMap = {};
for (persona of salarios) {
    Object.values(persona.trabajos).map((value) => {
        if (!empresasMap[value.empresa]) {
            empresasMap[value.empresa] = {};
        }
        if (!empresasMap[value.empresa][value.year]) {
            empresasMap[value.empresa][value.year] = []
        }
        empresasMap[value.empresa][value.year].push(value.salario);
    })     
}
console.log(empresasMap)

Mi solución, objetivo más eficiente y menos código:

const analisisEmpresarial = (salarios) => {
  return salarios.reduce((empresas, persona) => {
    persona.trabajos.forEach((trabajo) => {
      empresas[trabajo.empresa] ??= {};
      empresas[trabajo.empresa][trabajo.year] ??= [];
      empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
    });
    return empresas;
  }, {});
};

mediana por año.

function medianaPorEmpresa(empresa) {
    var anho = 2018;
    var medianaPorAnho = [];
    for (anho; anho <= 2023; anho++){
        var mediana = PlatziMath.calcularMediana(empresas[empresa][String(anho)]);
        medianaPorAnho.push({ anho, mediana });
    }   
    return  medianaPorAnho 
}

![](

Cuando estoy en las clase y no entiendo nada me siento mal pero pasa el tiempo y con la practica lo puedo comprender y siento una super satisfaccion mental muy buena

Ya me quedó xD

function OrganizarPorIndustria(salarios){
    const empresas= {};
    salarios.forEach((empleado) => {
        empleado.trabajos.forEach((trabajo)=>{
            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); 
        })
    });
    return empresas
}

Si no entienden, les recomiendo que realicen primero los cálculos en una hoja de papel. Después desarrollan el código y comparan con los resultados del profesor.

pues yo creí que era una análisis por empresa cuando lo intenté en el minuto 5:05 y me arriesgué a hacerlo así, después de dos horas lo logré con el código siguiente

PlatziMath.analisisSalarialEmpresarial1=function(enterprise){
    let trabajos=[]
    salarios.forEach((a)=>{
        let k=Object.values(a.trabajos)
        for(i of k){
            let l=i
            if(l.empresa==enterprise){
            trabajos.push(i)
            }
        }
    })
    console.log(trabajos);

    let empresa={}
    trabajos.forEach((a,b,c)=>{
        
        const anio = trabajos[b].year
        if(empresa[anio]){            
        empresa[anio].push(c[b].salario)
        }
        else{
            empresa[anio]=[c[b].salario]
        }
    })
    console.log(empresa)
}

luego vi el resto del video y en lugar de hacer un copia y pega con el loop for, lo decidí hacer con el método forEach:

PlatziMath.analisisSalarialEmpresarial2=function(){
    let empresas={}
    salarios.forEach((a,b)=>{
        salarios[b].trabajos.forEach((c,d)=>{
            let empresaName= salarios[b].trabajos[d].empresa
            if(!empresas[empresaName]){
                empresas[empresaName]={}
            }
            let yearSalary = salarios[b].trabajos[d].year
            if(!empresas[empresaName][yearSalary]){
                empresas[empresaName][yearSalary]=[]
            }
            let salary= salarios[b].trabajos[d].salario
            empresas[empresaName][yearSalary].push(salary)
        })
    })
    console.log(empresas);
}

me ayudo mentalmente ordenarme con un esquemita como era la estructura del array salarios.
y como debia quedar el objeto empresas:

//////analisis empresarial: reestructuracion de array
/* ---------------------------------------
estructura del array "salarios":
salarios[
    {//objetos "persona":
        .name
        .trabajos[
            {//objetos "trabajo":
                .year
                .empresa
                .salario
            }
        ]
    }
]
----------------------------------------------
estructura deseada para el nuevo objeto "empresas":
empresas{
    {//objeto "empresa":
        {//objeto "year":
            [// array de salarios:]
            [// array de salarios:]
            ....
        }
                {//objeto "year":
            [// array de salarios:]
            [// array de salarios:]
            ....
        }
        ...
    }
        {//objeto "empresa":
        {//objeto "year":
            [// array de salarios:]
            [// array de salarios:]
            ....
        }
                {//objeto "year":
            [// array de salarios:]
            [// array de salarios:]
            ....
        }
        ...
    }
    ....
}
*/

Hola a todos, con el fin de poder comprender mejor los pasos para la reestructuración de los datos en la función enseñada, me fui creando un manual paso a paso. Me sirvió bastante para entender que pasa en cada ciclo y condicional, y las referencia los elementos. Se los dejo por si es útil para alguien, está en pdf, saludos.

https://drive.google.com/file/d/1mLyysRClgbedLwlF-ZwhE3iwkKG2wmG9/view?usp=sharing

hasta ahora entiendo todo, muy conveniente venir del sector financiero y haber aprendido primero backend, se me a hecho facil

Antes de que empiece la clase me gustaría compartir cómo le hice para reestrcuturar la información. La verdad estuvo bien divertido y me emociona ver cómo lo hará el señor profesor y ya veré si mi código no quedó tan horrible xD.

function companiesList(array){
    let companies_list = [];

    salarios.forEach(function(element){

        element.trabajos.forEach(function(trabajo){
            let result =companies_list.findIndex(function(company){
                return trabajo.empresa == company.name;
            })

            if(result === -1 ){
                companies_list.push({name: trabajo.empresa, earns: []});
            }

        });

    });

    return companies_list;
}

function companyWorth(name){
    let company = {};
    company.name = name;
    company.earns = [];
    
    salarios.forEach(function(element){

        let trabajos = element.trabajos.filter(function(trabajo){
            return trabajo.empresa.toLowerCase() === name.toLowerCase();
        });

        trabajos = trabajos.map(function(trabajo){
            return {year: trabajo.year, earn: trabajo.salario};
        });
        
        trabajos.forEach(function(trabajo){

            let result = company.earns.findIndex(function(earn, index){
                return earn.year === trabajo.year;
            });
            //console.log(result);
            if(result > -1){
                company.earns[result].earn += trabajo.earn;
            }
            else{
                company.earns.push(trabajo);
            }

        });
    });
    
    return company;
}

let companies = companiesList(salarios);

companies.forEach(function(element){
    console.group('Estas son las ganacias de la empresa ' + element.name);
    console.table(companyWorth( element.name ).earns)
    console.groupEnd();
});

Cataclismos: Desastre de grandes proporciones que afecta a todo el planeta o a parte de él y es producido por un fenómeno natural. google

xD

Para simplificar todos los esquemas, dejar todo como una sola base, me parece la forma más simple de trabajar.

Si a alguien le interesa, adjunto el nuevo esquema

const salarioEmpresa = [];

salarioEmpresa.push(
  { name: "Juanita", year: 2018, empresa: "Freelance", salario: 250 },
  { name: "Juanita", year: 2019, empresa: "Freelance", salario: 250 },
  { name: "Juanita", year: 2020, empresa: "Industrias Mokepon", salario: 850 },
  { name: "Juanita", year: 2021, empresa: "Industrias Mokepon", salario: 1050 },
  { name: "Juanita", year: 2022, empresa: "Industrias Mokepon", salario: 1250 },
  { name: "Juanita", year: 2023, empresa: "Industrias Mokepon", salario: 1250 },
  { name: "Alex", year: 2018, empresa: "Freelance", salario: 450 },
  { name: "Alex", year: 2019, empresa: "Freelance", salario: 550 },
  { name: "Alex", year: 2020, empresa: "Freelance", salario: 400 },
  { name: "Alex", year: 2021, empresa: "Industrias Mokepon", salario: 1050 },
  { name: "Alex", year: 2022, empresa: "Industrias Mokepon", salario: 1250 },
  { name: "Alex", year: 2023, empresa: "Industrias Mokepon", salario: 1250 },
  { name: "Nath", year: 2018, empresa: "Freelance", salario: 600 },
  { name: "Nath", year: 2019, empresa: "Freelance", salario: 625 },
  { name: "Nath", year: 2020, empresa: "Freelance", salario: 575 },
  { name: "Nath", year: 2021, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Nath", year: 2022, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Nath", year: 2023, empresa: "MarketerosCOL", salario: 1100 },
  { name: "Julia", year: 2018, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Julia", year: 2019, empresa: "MarketerosCOL", salario: 2000 },
  { name: "Julia", year: 2020, empresa: "MarketerosCOL", salario: 2000 },
  { name: "Julia", year: 2021, empresa: "MarketerosCOL", salario: 2000 },
  { name: "Julia", year: 2022, empresa: "MarketerosCOL", salario: 2000 },
  { name: "Julia", year: 2023, empresa: "MarketerosCOL", salario: 2000 },
  { name: "Jonatan", year: 2019, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Jonatan", year: 2020, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Jonatan", year: 2021, empresa: "MarketerosCOL", salario: 800 },
  { name: "Jonatan", year: 2022, empresa: "MarketerosCOL", salario: 900 },
  { name: "Jonatan", year: 2023, empresa: "MarketerosCOL", salario: 1000 },
  { name: "Armando", year: 2018, empresa: "Freelance", salario: 750 },
  { name: "Armando", year: 2019, empresa: "Freelance", salario: 750 },
  { name: "Armando", year: 2020, empresa: "Freelance", salario: 750 },
  { name: "Armando", year: 2021, empresa: "Freelance", salario: 850 },
  { name: "Armando", year: 2022, empresa: "Freelance", salario: 850 },
  { name: "Armando", year: 2023, empresa: "Freelance", salario: 850 },
  { name: "Dilan", year: 2018, empresa: "Freelance", salario: 500 },
  { name: "Dilan", year: 2019, empresa: "Freelance", salario: 500 },
  { name: "Dilan", year: 2020, empresa: "Freelance", salario: 600 },
  { name: "Dilan", year: 2021, empresa: "Mokepon", salario: 1100 },
  { name: "Dilan", year: 2022, empresa: "Mokepon", salario: 1100 },
  { name: "Dilan", year: 2023, empresa: "Mokepon", salario: 1100 },
  { name: "Zamir", year: 2018, empresa: "Freelance", salario: 400 },
  { name: "Zamir", year: 2019, empresa: "Freelance", salario: 500 },
  { name: "Zamir", year: 2020, empresa: "Freelance", salario: 500 },
  { name: "Zamir", year: 2021, empresa: "Mokepon", salario: 1100 },
  { name: "Zamir", year: 2022, empresa: "Mokepon", salario: 1100 },
  { name: "Zamir", year: 2023, empresa: "Mokepon", salario: 1200 },
  { name: "Daniela", year: 2018, empresa: "Freelance", salario: 500 },
  { name: "Daniela", year: 2019, empresa: "Freelance", salario: 500 },
  { name: "Daniela", year: 2020, empresa: "Freelance", salario: 500 },
  { name: "Daniela", year: 2021, empresa: "Freelance", salario: 550 },
  { name: "Daniela", year: 2022, empresa: "Freelance", salario: 550 },
  { name: "Daniela", year: 2023, empresa: "MarketerosCOL", salario: 850 },
  { name: "Daniel", year: 2020, empresa: "Freelance", salario: 150 },
  { name: "Daniel", year: 2021, empresa: "Freelance", salario: 450 },
  { name: "Daniel", year: 2022, empresa: "Freelance", salario: 550 },
  { name: "Daniel", year: 2023, empresa: "Freelance", salario: 650 },
  { name: "Rigoberto", year: 2018, empresa: "MarketerosCOL", salario: 700 },
  { name: "Rigoberto", year: 2019, empresa: "MarketerosCOL", salario: 700 },
  { name: "Rigoberto", year: 2020, empresa: "MarketerosCOL", salario: 700 },
  { name: "Rigoberto", year: 2021, empresa: "MarketerosCOL", salario: 750 },
  { name: "Rigoberto", year: 2022, empresa: "MarketerosCOL", salario: 750 },
  { name: "Rigoberto", year: 2023, empresa: "MarketerosCOL", salario: 750 },
  { name: "Alicia", year: 2018, empresa: "Inversionify", salario: 300 },
  { name: "Alicia", year: 2019, empresa: "Inversionify", salario: 1700 },
  { name: "Alicia", year: 2020, empresa: "Inversionify", salario: 2700 },
  { name: "Alicia", year: 2021, empresa: "Inversionify", salario: 3750 },
  { name: "Alicia", year: 2022, empresa: "Freelance", salario: 1550 },
  { name: "Alicia", year: 2023, empresa: "Freelance", salario: 350 },
  { name: "Teodoro", year: 2018, empresa: "Freelance", salario: 600 },
  { name: "Teodoro", year: 2019, empresa: "Freelance", salario: 700 },
  { name: "Teodoro", year: 2020, empresa: "Inversionify", salario: 1700 },
  { name: "Teodoro", year: 2021, empresa: "Inversionify", salario: 1750 },
  { name: "Teodoro", year: 2022, empresa: "Freelance", salario: 800 },
  { name: "Teodoro", year: 2023, empresa: "Freelance", salario: 850 },
  { name: "Bruce", year: 2018, empresa: "Wayne Enterprises", salario: 4600 },
  { name: "Bruce", year: 2019, empresa: "Wayne Enterprises", salario: 4700 },
  { name: "Bruce", year: 2020, empresa: "Wayne Enterprises", salario: 3700 },
  { name: "Bruce", year: 2021, empresa: "Wayne Enterprises", salario: 4150 },
  { name: "Bruce", year: 2022, empresa: "Wayne Enterprises", salario: 4400 },
  { name: "Bruce", year: 2023, empresa: "Wayne Enterprises", salario: 3850 },
  { name: "Alfred", year: 2018, empresa: "Wayne Enterprises", salario: 2000 },
  { name: "Alfred", year: 2019, empresa: "Wayne Enterprises", salario: 2000 },
  { name: "Alfred", year: 2020, empresa: "Wayne Enterprises", salario: 1500 },
  { name: "Alfred", year: 2021, empresa: "Wayne Enterprises", salario: 1500 },
  { name: "Alfred", year: 2022, empresa: "Wayne Enterprises", salario: 2000 },
  { name: "Alfred", year: 2023, empresa: "Wayne Enterprises", salario: 1500 },
  { name: "Clark Kent", year: 2018, empresa: "Daily Planet", salario: 1000 },
  { name: "Clark Kent", year: 2019, empresa: "Daily Planet", salario: 1500 },
  { name: "Clark Kent", year: 2020, empresa: "Daily Planet", salario: 1000 },
  { name: "Clark Kent", year: 2021, empresa: "Daily Planet", salario: 1500 },
  { name: "Clark Kent", year: 2022, empresa: "Daily Planet", salario: 2000 },
  { name: "Clark Kent", year: 2023, empresa: "Daily Planet", salario: 1500 },
  { name: "Luisa Lane", year: 2018, empresa: "Daily Planet", salario: 2000 },
  { name: "Luisa Lane", year: 2019, empresa: "Daily Planet", salario: 2500 },
  { name: "Luisa Lane", year: 2020, empresa: "Daily Planet", salario: 2000 },
  { name: "Luisa Lane", year: 2021, empresa: "Daily Planet", salario: 2500 },
  { name: "Luisa Lane", year: 2022, empresa: "Daily Planet", salario: 2500 },
  { name: "Luisa Lane", year: 2023, empresa: "Daily Planet", salario: 2500 },
  { name: "Jimmy Olsen", year: 2018, empresa: "Daily Planet", salario: 1500 },
  { name: "Jimmy Olsen", year: 2019, empresa: "Daily Planet", salario: 2000 },
  { name: "Jimmy Olsen", year: 2020, empresa: "Daily Planet", salario: 2000 },
  { name: "Jimmy Olsen", year: 2021, empresa: "Daily Planet", salario: 2500 },
  { name: "Jimmy Olsen", year: 2022, empresa: "Daily Planet", salario: 2500 },
  { name: "Jimmy Olsen", year: 2023, empresa: "Daily Planet", salario: 1500 },
  { name: "Perry White", year: 2018, empresa: "Daily Planet", salario: 3500 },
  { name: "Perry White", year: 2019, empresa: "Daily Planet", salario: 3700 },
  { name: "Perry White", year: 2020, empresa: "Daily Planet", salario: 3800 },
  { name: "Perry White", year: 2021, empresa: "Daily Planet", salario: 4000 },
  { name: "Perry White", year: 2022, empresa: "Daily Planet", salario: 4050 },
  { name: "Perry White", year: 2023, empresa: "Daily Planet", salario: 4050 },
  { name: "Lex Luthor", year: 2018, empresa: "LexCorp", salario: 5000 },
  { name: "Lex Luthor", year: 2019, empresa: "LexCorp", salario: 5300 },
  { name: "Lex Luthor", year: 2020, empresa: "LexCorp", salario: 4000 },
  { name: "Lex Luthor", year: 2021, empresa: "LexCorp", salario: 3000 },
  { name: "Lex Luthor", year: 2022, empresa: "LexCorp", salario: 3500 },
  { name: "Lex Luthor", year: 2023, empresa: "LexCorp", salario: 3050 }
);

Dejo el contenido de la clase mas una breve explicacion del paso a paso.

/*creamos el objeto*/
const empresas = {};

/*lo llenamos */
/*en cada elem del arr de salarios se realizara un for que busque...*/
for (persona of salarios) {
  for (trabajo of persona.trabajos) {
    /*PRIMERO si la empresa no existe..*/
    if (!empresas[trabajo.empresa]) {
      /*si no existe la crea*/
      empresas[trabajo.empresa] = {};
    }
/* si ya existe no hace nada*/
    /*DESPUES verificamos si existe o no dentro de nuestro arr el año trabajado*/
    if (!empresas[trabajo.empresa][trabajo.year]) {
      /*si no existe lo agregamos y especif. que sera un array, este contendra los montos de los salarios.*/
      empresas[trabajo.empresa][trabajo.year] = [];
    }

    /*y por ultimo agregamos el monto del salario.*/
    empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
  }

  /*despues de todo esto pasamos a la proxima persona o elemento del arreglo salarios*/
}

Aplicando for...in loop para recorrer un objeto:

function getMediana(nameCompany, year) {
    let salarios;
    for (const key in company()) {
        if (key === nameCompany) {
            salarios = company()[key][year];
        }
    }
    return PlatziMath.mediana(salarios);

}

Mi respuesta al reto.

function mediaPerYear(empresa , year) {
        let array = empresas[empresa]//Probar en consola empresas[nombre de la empresa]
        let newArray = Object.entries(array);//esta linea da un arreglo
        for (elements of newArray) {
        if(elements[0] == year) {//la posicion [0] del arreglo es el año
                console.log(elements[1])
               let arrayInOrder = AverageJS.sortList(elements[1])//la posicion [1] del arreglo es salarios. organizar el array antes de calcular la media
              let  mediaYears = AverageJS.calculateMedia(arrayInOrder)//calcular media de salarios
          
              console.log(mediaYears)
           }  
        }
    }

function sortByCountries() {
    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].push(trabajo.salario);
        }
    }

    return empresas;
}

Reto compleado, lo resolví transformando los objetos en array y usando método find:
.
.
.

function yearlyMedian (business, year) {
    let onlyJobsArray = Object.entries(onlyJobs(salarios));
    let specificJobArray = onlyJobsArray.find( function (foo) {
        if (foo[0] == business) {
            return foo;
        }
    });
    let yearlySalaryArray = Object.entries(specificJobArray[1]);
   
    let yearForMedian = yearlySalaryArray.find( function (foo) {
        if (foo[0] == year) {
            return foo[1];
        }
    })
   
    let medianInYear = PlatziMath.median(yearForMedian[1]);
    console.log(medianInYear);
}

yearlyMedian('Freelance', 2021);

Les comparto el código que utilice para reestructurar la información.

Resultado obtenido:

una solución diferente

function analisisEmpresarialSalarios(salarios){ 
let empresas_salarios = []
var a = []

for(s of salarios){
    var trabajos = s.trabajos          
    
    for(let i =0; i<trabajos.length; i++ ){
        var elemento = trabajos[i].empresa
        var year = trabajos[i].year.toString()
        var salarioPorObjeto = trabajos[i].salario
        var empresa = {}

        if(a.includes(elemento)){
            // la empresa ya esta incluida en el array auxiliar a

            //indice del objeto en empresas_salarios cuya llave es elemento         
            const condicion = (empresa) => Object.keys(empresa)[0] === elemento;
            const indice = empresas_salarios.findIndex(condicion)
            
            //acceder al arrray con los objetos {año:[salario]}
            const empresa_actual = empresas_salarios[indice]

            const arrayConObjetos = empresa_actual[elemento]
            
            // verificar que el objeto ya tenga el año
            //se busca el indice del objeto que tenga el año
            const indiceEncontrado = arrayConObjetos.findIndex(objeto => Object.keys(objeto)[0] === year);
            if (indiceEncontrado !== -1) {
                // el array con objetos contiene un objeto con el year de la iteracion
                // agregarle el valor de salario al array de dicho año
                arrayConObjetos[indiceEncontrado][year].push(salarioPorObjeto)
                    
              } else {
                // el array no contine un objeto con ese year
                // agregarle un objeto con ese año y un array con el salario
                arrayConObjetos.push({[year]:[salarioPorObjeto]})

              }              

        }else{
            // si el array auxiliar a no contiene al empresa esta se le agrega   
            a.push(elemento)
            empresa[elemento]= [{[year]:[salarioPorObjeto]}]           
            empresas_salarios.push(empresa)
        } 
    }
}
console.log(empresas_salarios)

}

me puse el reto de no usar un for of sino el for convencional, el resultado:

for (let i = 0; i < salarios.length; i++) {
    let persona = salarios[i]
    for (let j = 0; j < persona.trabajos.length; j++) {
        let empresa = persona.trabajos[j].empresa
        let year = persona.trabajos[j].year
        let dinero = persona.trabajos[j].salario

        if (!empresas1[empresa]) {
            empresas1[empresa] = {}
        }

        if (!empresas1[empresa][year]) {
            empresas1[empresa][year] = []

        }

        empresas1[empresa][year].push(dinero)

    }

}

Para no alargar el código, se puede hacer con desestructuración:

const companies = {};

wages.forEach((person) => {
  person.jobs.forEach((record) => {
    let { company, year, salary } = record;

    if (!companies[company]) {
      companies[company] = {};
    }

    if (!companies[company][year]) {
      companies[company][year] = [];
    }

    companies[company][year].push(salary);
  });
});

console.log(companies);

Esto permite un código más legible.

Mi aporte al reto de las medianas por año

function medianaEmpresasPorAño(empresa, year) {
  const empresaBuscada = empresas[empresa];
  const yearFound = empresaBuscada[year];
  const resultadoMediana = PlatziMath.calcularMediana(yearFound);
  return resultadoMediana;
}

La hice antes de ver la clase, me costo unas 4 horas 😦 y seguramente no este optimizado pero creo que retorna lo requerido
( Al final del código coloco el array que retorna)

    // lap: create an array of objects with company name and an object of year empty fo an array of salaries
function arrByCompany(arr) {
    // lap: create an array of all the row works 
    const arrIndustries = []
    for (let i = 0; i < arr.length; i++) {
        const arrObjsWorks = [arr[i].works]

        for (let j = 0; j < arrObjsWorks.length; j++) {
            for (let y = 0; y < arrObjsWorks[j].length; y++) {
                arrIndustries.push(arrObjsWorks[j][y])
            }
        }
    }
    console.log(arrIndustries) //lap: probe <-- this is the array of all the row works

    // lap: create an array of objects with company name and an object of year empty fo an array of salaries
    const arrCompanies = []
    arrIndustries.forEach(element => {
        obj = { company: element.company, year: {} }
        if (!arrCompanies.find(obj => obj.company === element.company)) {
            arrCompanies.push(obj)
        }
    });

    // lap: create an array of all the years for company
    for (let i = 0; i < arrCompanies.length; i++) {
        for (let j = 0; j < arrIndustries.length; j++) {
            if (arrCompanies[i].company === arrIndustries[j].company) {
                if (!arrCompanies[i].year[arrIndustries[j].year]) {
                    arrCompanies[i].year[arrIndustries[j].year] = []
                    let salary = arrIndustries[j].salary
                    arrCompanies[i].year[arrIndustries[j].year].push(salary)
                } else {
                    let salary = arrIndustries[j].salary
                    arrCompanies[i].year[arrIndustries[j].year].push(salary)
                }
            }
        }
    }
    console.log(arrCompanies) // lap: probe
}// lap: <-- finish the function 

let probeArrByCompany = arrByCompany(salaries)
console.log(probeArrByCompany)

[
    {
        "company": "Freelance",
        "year": {
            "2018": [250, 450, 600, 750, 500, 400, 500, 600],
            "2019": [250, 550, 625, 750, 500, 500, 500, 700],
            "2020": [400, 575, 750, 600, 500, 500, 150],
            "2021": [850, 550, 450],
            "2022": [850, 550, 550, 1550, 800],
            "2023": [850, 650, 350, 850]
        }
    },
    {
        "company": "Industrias Mokepon",
        "year": {
            "2020": [850],
            "2021": [1050, 1050],
            "2022": [1250, 1250],
            "2023": [1250, 1250]
        }
    },
    {
        "company": "MarketerosCOL",
        "year": {
            "2018": [1000, 700],
            "2019": [2000, 1000, 700],
            "2020": [2000, 1000, 700],
            "2021": [1000, 2000, 800, 750],
            "2022": [1000, 2000, 900, 750],
            "2023": [1100, 2000, 1000, 850, 750]
        }
    },
    {
        "company": "Mokepon",
        "year": {
            "2021": [1100, 1100],
            "2022": [1100, 1100],
            "2023": [1100, 1200]
        }
    },
    {
        "company": "Inversionify",
        "year": {
            "2018": [300],
            "2019": [1700],
            "2020": [2700, 1700],
            "2021": [3750, 1750]
        }
    },
    {
        "company": "Wayne Enterprises",
        "year": {
            "2018": [4600, 2000],
            "2019": [4700, 2000],
            "2020": [3700, 1500],
            "2021": [4150, 1500],
            "2022": [4400, 2000],
            "2023": [3850, 1500]
        }
    },
    {
        "company": "Daily Planet",
        "year": {
            "2018": [1000, 2000, 1500, 3500],
            "2019": [1500, 2500, 2000, 3700],
            "2020": [1000, 2000, 2000, 3800],
            "2021": [1500, 2500, 2500, 4000],
            "2022": [2000, 2500, 2500, 4050],
            "2023": [1500, 2500, 1500, 4050]
        }
    },
    {
        "company": "LexCorp",
        "year": {
            "2018": [5000],
            "2019": [5300],
            "2020": [4000],
            "2021": [3000],
            "2022": [3500],
            "2023": [3050]
        }
    }
]

Increiblemente me costó menos hacer esto que hacer lo de sacar la moda de las clases anteriores

const salari_year = []

for(nombres of salarios){
    for (nose of nombres.trabajos){
        if(!(salari_year.includes(nose.year))){
            salari_year.push(nose.year)
        }
    }
 }

console.log(salari_year)



function buscarEmpresa(Inputempresa){
    let i = 0
    console.log(Inputempresa)
    while (i < salari_year.length){ //Iteracion sobre los años
        const salariosPorYear = {
            year : salari_year[i],
            salarios: []
        }
        for (nombres of salarios){     //Recorrriendo nombres
            for (rTrabajos of nombres.trabajos){ //Recorriendo trabajos
                
                if (rTrabajos.empresa == Inputempresa && rTrabajos.year == salari_year[i]){
                    // console.log(nombres.name + ' en ' + rTrabajos.year + ': ' + rTrabajos.salario)
                    salariosPorYear.salarios.push({name:nombres.name, salario: rTrabajos.salario})
                }
            }
            
        }

    i++
    console.log(salariosPorYear)
    }


}

buscarEmpresa('Freelance')

realice el siguiente analisis respeto a lo que explico juan

<code> 
// Análisis empresarial
/* {
  Industrias Mokepon: {
    2018: [salario]
  }
  Industrias Mokepon: {
    2018: [salario, salarios, salrios]
    2019: 
    2025: 
    2026: 
  },
  Industrias Mokepon: {},
  Industrias Mokepon: {},
  Industrias Mokepon: {},
} */
const empresas = {};

for (persona of salarios) { //recorre el arreglo salarios {name,trabajos[{}]}=persona

  for (trabajo of persona.trabajos) {// ahora tenemos a persona.trabajos{year,empresa,salario}= trabajo
    if (!empresas[trabajo.empresa]) {// pregunta si la empresa no existe dentro del objeto empresas,
      empresas[trabajo.empresa] = {};// si no exite crea lo siguiente empresas{NOMBRE DE LA EMPRESA{}}

    }

    if (!empresas[trabajo.empresa][trabajo.year]) {//pregunta si no ha trabajado tal año en la empresa 
      empresas[trabajo.empresa][trabajo.year] = [];// si no existe el año crea lo siguiente empresas={"nombre de la empresa:{"year":[]} }
    }

    empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);

    //por ultimo va agregando el salario a cada empresa a cada año
    //empresas={"nombre de la empresa":{"year":[salrios, salario,salario...]}}
  }
}

console.log({empresas});

Aquí mi solución al reto:

• En una sola línea

function medianSalariesPerCompanieAndYear(companie, year) {
    return PlatziMath.mediana(companies[companie][year])
}

• Por partes

function medianSalariesPerCompanieAndYear(companie, year) {
    const salaries = companies[companie];
    const yearSalaries = salaries[year];
    return PlatziMath.mediana(yearSalaries)
}

madreia, todo iba bien hasta llegar a esta clase. Dicen q a la tercera va la vencida pero he tenido que verla 4 veces 😭

Solo le cambié un poco:

const enterprise = {}
salaries.map(person => {
    for (const job of person.jobs) {
        
        const company = job.company;
        const year = job.year;
        const salary = job.salary

        if (!enterprise[company]) enterprise[company] = {};
        if (!enterprise[company][year]) enterprise[company][year] = [];
        enterprise[company][year].push(salary)
    }
})

Encontré otra forma de hacerlo O.o
No sé si esto está dentro de las “buenas practicas”

const companies = {}

salaries.forEach(person => {
  person.jobs.forEach(job => {

    companies[job.company] = companies[job.company] || {}
    let company = companies[job.company]

    company[job.year] = company[job.year] || []
    company[job.year].push(job.salary)
  })
})

Comparto mi codigo comentado

// La función "informacionEmpresas" toma como argumento un objeto (objAFiltrar) que contiene información sobre personas y sus trabajos.
function informacionEmpresas(objAFiltrar) {

  // Declaramos un objeto vacío llamado "empresas" donde almacenaremos la información reestructurada de cada empresa.
  const empresas = {};

  // Utilizamos el ciclo "for...of" para iterar sobre el objeto "objAFiltrar" y obtener cada persona en él. 
  // En cada iteración, la variable "persona" tomará el valor de una de las personas del objeto "objAFiltrar".
  for (let persona of objAFiltrar) {

    // Utilizamos otro ciclo "for...of" para iterar sobre el objeto "trabajos" que está dentro de cada persona.
    // En cada iteración, la variable "trabajo" tomará el valor de uno de los trabajos de la persona actual.
    for (let trabajo of persona.trabajos) {

      // Verificamos si la empresa del trabajo actual ya existe como una propiedad en el objeto "empresas".
      // Si no existe, creamos una propiedad con el nombre de la empresa en el objeto "empresas" y le asignamos un objeto vacío.
      if (!empresas[trabajo.empresa]) {
        empresas[trabajo.empresa] = {};
      }

      // Verificamos si la empresa del trabajo actual tiene un año específico en el objeto "empresas".
      // Si no existe, creamos una propiedad con el nombre del año en el objeto "empresas" y le asignamos un array vacío.
      if (!empresas[trabajo.empresa][trabajo.year]) {
        empresas[trabajo.empresa][trabajo.year] = [];
      }

      // Añadimos el salario del trabajo actual al array correspondiente en el objeto "empresas".
      empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
    }
  }

  // Imprimimos el objeto "empresas" en la consola para que podamos ver los resultados de la reestructuración.
  console.log({ empresas });
}

Para sacar la mediana por año según la empresa lo hice así:

// Empresas - Reestructurando información

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 salarios por año en empresas

function medianaSalariosEmpresas (company, year) {
    const empresa = empresas[company]
    const SalariosYearEmpresa = empresa[year]
    const calculoMediana = NewMath.calcularMediana(SalariosYearEmpresa)
    return calculoMediana
}
<code> 

Tomo como parametro de dificultad de la clase el peinado de JuanDC

Ver estos comentarios donde muchos no entienden esta bien hard xd

Comparto el código de mi función que ordena los datos de los salarios por compañía. Segun el formato del profe:
{
companyName1: {
2018: [salary1, salary2 …]
2019: [salary1, salary2 …]
…
2023: [salary1, salary2 …]
}

companyName2: {
2018: [salary1, salary2 …]
2019: [salary1, salary2 …]
…
2023: [salary1, salary2 …]
}
}

function getSalariesbyCompany(){
    companyNames = {};
    for (let x of salarios){
        for(let y of x.trabajos){
            if (companyNames[y.empresa]){
                
                if(companyNames[y.empresa][y.year]){
                    companyNames[y.empresa][y.year].push(y.salario);
                    companyNames[y.empresa][y.year].sort((a,b)=>a-b);
                }
            }
            else{
                companyNames[y.empresa] = {
                    2018: [], 2019: [], 2020: [], 2021: [], 2022: [], 2023: [] };

                if(companyNames[y.empresa][y.year]){
                    companyNames[y.empresa][y.year].push(y.salario);
                    companyNames[y.empresa][y.year].sort((a,b)=>a-b);
                }
            }       
        }
    }

Mi codigo es un tanto distinto pero me agrado como me quedo asi que dejo mi version XD:
La unica diferencia es que mi estructura final no devuelve solo los sueldo sino un array de objetos donde esta el nombre y el salario de cada persona… es una diferencia minima pero ps me parecio bueno, hacerlo.

function datosEmpresa() {
  const nuevosDatos = salarios.reduce((acc, trabajador) => {
    let nombreEmpleado = trabajador.name;
    for (const valor of trabajador.trabajos) {
      let empresa = valor.empresa;
      let salario = valor.salario;
      let periodo = valor.year;

      let listed = acc.some((item) => item.nombre == empresa);
      if (listed) {
        ingresarDato(acc, empresa, periodo, nombreEmpleado, salario);
      } else {
        const nuevaEmpresa = new Empresa(empresa);
        acc.push(nuevaEmpresa);
        ingresarDato(acc, empresa, periodo, nombreEmpleado, salario);
      }
    }
    return acc;
  }, []);
  return nuevosDatos;
}

Mi solucion es mas larga… aqui la otra parte de codigo:

function ingresarDato(array, empresa, año, trabajador, sueldo) {
  let indiceEmpresa = array.findIndex((item) => item.nombre === empresa);
  let historialEmpresa = array[indiceEmpresa].historial;
  let indiceAño = historialEmpresa.findIndex((item) =>
    item.hasOwnProperty(año)
  );

  historialEmpresa[indiceAño][año].push({
    nombre: trabajador,
    salario: sueldo,
  });
}

Tal vez considere reducir codigo… ya veremos :p

Este es mi código un poco largo pero entendible, esto solo me da el objeto de la empresa con el array de salarios de una empresa por cada año

function empresas(nombreEmpresa){

    const salarios2018Freelance =[]
    const salarios2019Freelance =[]
    const salarios2020Freelance =[]
    const salarios2021Freelance =[]
    const salarios2022Freelance =[]
    const salarios2023Freelance =[]
    for(let j=0; j< salarios.length;j++){
        for(let i=0; i< salarios[j].trabajos.length;i++){
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2018)){
                const salario2018F =salarios[j].trabajos[i].salario ;
                salarios2018Freelance.push(salario2018F);
            }
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2019)){
                const salario2019F =salarios[j].trabajos[i].salario ;
                salarios2019Freelance.push(salario2019F);
            }
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2020)){
                const salario2020F =salarios[j].trabajos[i].salario ;
                salarios2020Freelance.push(salario2020F);
            }
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2021)){
                const salario2021F =salarios[j].trabajos[i].salario ;
                salarios2021Freelance.push(salario2021F);
            }
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2022)){
                const salario2022F =salarios[j].trabajos[i].salario ;
                salarios2022Freelance.push(salario2022F);
            }
            if((salarios[j].trabajos[i].empresa == nombreEmpresa) && (salarios[j].trabajos[i].year == 2023)){
                const salario2023F =salarios[j].trabajos[i].salario ;
                salarios2023Freelance.push(salario2023F);
            }
            }
        }
        console.log('salarios2018Freelance');
        console.log(salarios2018Freelance);
        
        console.log('salarios2019Freelance');
        console.log(salarios2019Freelance);

        console.log('salarios2020Freelance');
        console.log(salarios2020Freelance);

        console.log('salarios2021Freelance');
        console.log(salarios2021Freelance);

        console.log('salarios2022Freelance');
        console.log(salarios2022Freelance);

        console.log('salarios2023Freelance');
        console.log(salarios2023Freelance);

       // const medianaSalarios2018Freelance = PlatziMath.calcularMediana(salarios2019Freelance);
        //console.log(medianaSalarios2018Freelance)
        const salariosEmpresas= {salarios2018Freelance , salarios2019Freelance,salarios2020Freelance,salarios2021Freelance,salarios2022Freelance,salarios2023Freelance};

        return salariosEmpresas
    }

El desafío de crear la estructura de datos que el maestro propone, me tomó HORAS en crearla dinámicamente con funciones.

ok me costo saber bien lo que quería, para hacer este tipo de análisis primero se tiene que saber exactamente que se quiere preguntar, de esa forma sabemos como queremos ordenar la información. Excelente ejercicio para el análisis.

Use algunos ejemplos de codigo y obtuve otra implementacion para analizar y entender el codigo, la explicacion del codigo abajo:

const company = () => {
  const empresas = new Map();

  for (const item of salarios) {
    for (const job of item.trabajos) {
      const { empresa, year, salario } = job;
      empresas.set(empresa, updateCompany(empresas.get(empresa), year, salario));
    }
  }

  return empresas;
}

const updateCompany = (existingCompany, year, salary) => {
  if (!existingCompany) {
    return { [year]: [salary] };
  }
  if (!existingCompany[year]) {
    return { ...existingCompany, [year]: [salary] };
  }
  return { ...existingCompany, [year]: [...existingCompany[year], salary] };
}

console.log(company());

Esta implementación del código hace lo mismo que la versión anterior, pero con algunos cambios significativos.

Utiliza un Map en lugar de un objeto para empresas: Un Map te permite usar cualquier tipo de valor como clave, mientras que un objeto solo puede usar cadenas o símbolos. Esto puede hacer que el código sea más legible y mantenible, especialmente si esperas que las claves de empresas sean algo diferente a cadenas.

Utiliza un bucle for-of anidado en lugar de forEach: los bucles for-of son más legibles y te dan acceso al índice del elemento actual, si es necesario.

Extrae la lógica para crear una nueva empresa, año y agregar el salario en funciones separadas: esto hará que el código sea más modular, lo que lo hará más fácil de entender y probar.

Utiliza un enfoque funcional. En lugar de mutar el objeto empresas, es más programación funcional devolver un nuevo objeto con las actualizaciones.

En esta implementación, primero se define una función llamada “company” que no toma argumentos. Dentro de la función, se crea un nuevo objeto Map llamado “empresas”. Luego, utilizando un ciclo for-of anidado, se recorre el arreglo “salarios”, y por cada item del arreglo, se recorre el arreglo “trabajos” (que es una propiedad del item actual del for-of exterior).

Por cada item en el arreglo “trabajos”, se destruye el objeto “job” y se obtienen las propiedades “empresa”, “year” y “salario”. Luego, se verifica si existe una empresa con el mismo nombre en el mapa “empresas”. Si no existe, se utiliza la función “updateCompany” para crear una nueva empresa, con un objeto que tiene como clave el “year” y como valor un arreglo con el salario. Si existe, se utiliza la función “updateCompany” para agregar el año y salario a la empresa existente en el mapa.

Finalmente, la función “company” devuelve el mapa “empresas”. La última línea de código es un console.log de la función company() que imprimirá el mapa empresas.

mi solución:

function calcularMedianaPorAño(nombreEmpresa,año){
  let empresa=analisisPorEmpresa();
    let años= empresa[nombreEmpresa][año];
    return MyselfMath.calcularMediana(años);  
}

Mi solucion al ultimo reto de la clase 😀
No se si entendi mal o que, pero la solucion es sencilla teniendo en cuenta que la informacion ya esta en el objeto empresas, solo hay que extraerla

function medianaDeSalarioPorAñoPorEmpresa(empresa,year){
    if(empresas[empresa]===undefined){
        return console.log('la empresa no existe');
    }
    if(empresas[empresa][year]===undefined){
        return console.log('no hay registros en ese año especifico')
    }
    return Platzimath.calcularMediana(empresas[empresa][year])
}

function medianByCompany(companyName, year) {
    const companies = sortByCountries();

    if(!companies[companyName]) {
        console.warn('La empresa no existe');
    }
    else if(!companies[companyName][year]) {
        console.warn('No tenemos datos sobre este año');
    }
    else {
        console.info(companies[companyName][year]);
    }
}

Como ya tenemos definida la función para calcular la mediana, simplemente mandé el arreglo correspondiente dependiendo de los argumentos recibidos por la función:

const calculateMedianPerYear = (companyName, year) => {

/* Se comprueba que el nombre de la empresa exista, si sí, ahora valida que el año ingresado esté registrado, si no, manda mensajes de error para ambos casos. En este caso se usa el operador "in", el cual checa si una propiedad en específico existe dentro del objeto especificado*/

	return companyName in companies
		? year in companies[companyName]
			? Stadistics.calculateMedian(companies[companyName][year])
			: "El año ingresado no tiene registro en la empresa."
		: "El nombre de la empresa no se encuentra registrado.";
};