Proyección salarial personal

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

Proyección salarial personal

Comentarios

marco antonio

student

OK listo lo del calculo de la proyección, tuve que modificar muchas cosas para que funcionara ;D

código
page

Jhon Ramirez

student

Increible!

marco antonio

student

@jhon98-ra184 gracias +w+

Felipe Molano Corredor

student

Para calcular directamente el nuevo salario podemos en una sola linea de codigo (en vez de 3) simplemente multiplicar el ultimo Salario * (1 + mediana). esta es una forma rapida de obtener un numero con el aumento de cierto valor. Es decir:

Si tenemos que incrementarle un 20% a 500 en vez de hacer: aumento=500*20%; nuevoSalario = ultimoSalario + aumento;

se puede hacer nuevoSalario = ultimoSalario*(1+20%); y esto da lo mismo

Orlando Rodriguez

student

Estuvo genial la clase, me di cuenta que me complique mas haciendo una media geométrica (había dejado mi código en la clase pasada), pero lo pude lograr.

// Haremos la proyeccion salarial usando una media geometrica
// Necesitamos el porcentaje de aumento de cada año, para calcular la media geometrica
// %aumento = (salarioNuevo - salarioViejo) / salarioViejo + 1

const aumentos = [];

function calcularMediaGeometrica (person) {
    const array = listaSalarios(person);

    for (let i=1; i<array.length; i++){
    
        let aumentoPorAnnio = (array[i] - array[i-1]) / array[i-1];
// condicional para cumplir reglas de la Media Geometrica (Si hay un aumento de 0% no sumarle el +1)
        if (aumentoPorAnnio === 0){
            aumentoPorAnnio = 0;
        } else {
            aumentoPorAnnio++;
        }
        aumentos.push(aumentoPorAnnio.toFixed(2));    
    }

    let multiplicarAumentos = aumentos.reduce((valorAcumulado, valorNuevo) => 
    valorAcumulado * valorNuevo);
    let indiceRaiz = 1 / aumentos.length;

// Aca estamos sacando una raiz con un indice que es igual a la cantidad de aumentos que tuvo la persona

    let mediaGeometrica = multiplicarAumentos ** indiceRaiz;
    let proyeccion = mediaGeometrica * array[array.length-1];
    console.log(mediaGeometrica.toFixed(2));
    if (mediaGeometrica === 0) {
            console.log(`${person} para el año que viene proyectamos que no tendras un aumento salarial.`);
    } else {
        console.log(`${person} para el año que viene proyectamos que tendras un salario de $${proyeccion.toFixed(0)}.`);
    }
    return mediaGeometrica.toFixed(2); 
}

calcularMediaGeometrica("Daniel");

Génesis Jarlenis Patiño Ynfante

student

Aquí seguimos o// Me han ayudo mucho los comentarios, muchas gracias o//

function proyeccionProxSalario(id){
    const trabajosPersona = encontrarPersona(id).trabajos
    const salarios = trabajosPersona.map((elemento)=> elemento.salario)

    const listaInvertida = salarios.sort((a, b)=> b - a)
    

    const salarioActual = listaInvertida[0]
    const salarioAnterior = listaInvertida.find((valor)=> valor !== salarioActual)

    const porcentajeSalarial = Number((((salarioActual - salarioAnterior)/salarioAnterior) * 100).toFixed(2))

    const nuevoSalario = Number((salarioActual * ((1 + (porcentajeSalarial / 100)))).toFixed(2))
    return nuevoSalario
}

Johangly Sucre

student

Que buen codigo!, lo subiste a github?

David Silgado

student

Next version :)

Eric López

student

Buenisimo...

Beder Danilo Casa Condori

student

excelente bro

Brandon Cortes Rivera

student

Pequeño recordatorio para todos:

2.4 = 240% 0.23 = 23% 0.19 = 19%

En los porcentajes para obtener un fracción hay que dividir la unidad en 100 pedacitos por eso 1 = 100% y .01 = 1%

Steeven Rocha

student

Para la proyección salarial utilice una regresión lineal (Porqué me pareció la más sencilla), para lo cual implemente la siguiente formula obtenida de un video en Youtube: Video

código js para la proyección del año 2024 es de 1636.66$

console.log(salarios[0]);
// Mediana una persona 

function findPerson(array,nameSearch){
    return (array.filter(function(articulo){
        return articulo.name == nameSearch;
    }));
}
function mediaPerson(array, nameSearch){
    const mediaP =findPerson(array,nameSearch)[0].trabajos.map(function (articulo){ return articulo.salario;}) ;
    return MathOperation.calcMediana(mediaP);
    
}
function proyectSalary(array, nameSearch, yearproyect){
    const yearAndSalary =findPerson(array,nameSearch)[0].trabajos.map(function(articulo){return [articulo.year,articulo.salario];});
    const yearandSalarySum = yearAndSalary.reduce(function(a,b){return [a[0]+b[0],a[1]+b[1]]});
    const yearCuad = yearAndSalary.reduce(function(a,b){
        return [a[0]+(b[0]**2)];
    }, [0,0]);
    const yearporsalary = yearAndSalary.reduce(function(a,b){return [a[0]+b[0]*b[1]]},[0,0]);
    yearandSalarySum.push(yearCuad[0],yearporsalary[0])
    const valueLinealA = Number(((yearAndSalary.length*yearandSalarySum[3]-yearandSalarySum[0]*yearandSalarySum[1])/(yearAndSalary.length*yearandSalarySum[2]-yearandSalarySum[0]**2)).toFixed(3));
    const valueLinealB = Number(((yearandSalarySum[1]-valueLinealA*yearandSalarySum[0])/(yearAndSalary.length)).toFixed(3));
    const resultlenalproyect = valueLinealA*(yearproyect)+(valueLinealB);
    return [yearAndSalary, yearandSalarySum, valueLinealA, valueLinealB, resultlenalproyect]
}
console.log([findPerson(salarios,"Juanita"),mediaPerson(salarios,"Juanita")]);
console.log(proyectSalary(salarios,"Juanita",2023));```

Fabio Escobar

student

Yo simplemente calcule una pendiente promedio, con respecto al ultimo y al primer salario. Despues use esa pendiente en la formula Y = mX + b.

Y = salario proyectado
m = pendiente promedio
X = año para la proyección
b = sueldo del primer año (2018)

// Analisis para persona

function calcularMedianaPorPersona(nombrePersona) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = filtrarSalarios(arrayTrabajos);
	const medianaSalarios = PlatziMath.calcMediana(arraySalarios);
	// console.log(salarios);
	// console.log(objPersona);
	// console.log(arrayTrabajos);
	// console.log(arraySalarios);
	// console.log(medianaSalarios);

	function filtrarSalarios(arr) {
		const arraySal = [];
		for (element of arr) {
			arraySal.push(element.salario);
		}
		return arraySal;
	}
}

//console.log(calcularMedianaPorPersona("Alex"));

// Analisis de proyeccion

function proyectarSalario(nombrePersona, añoProyectado) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = arrayTrabajos.map((element) => element.salario);

	console.log(arraySalarios);

	const pendiente =
		(arraySalarios[arraySalarios.length - 1] - arraySalarios[0]) /
		(arraySalarios.length - 1);
	const proyeccion = pendiente * (añoProyectado - 2018) + arraySalarios[0];
	console.log(proyeccion);
}
proyectarSalario("Alex", 2023);

Nestor Rios Garcia

student

Ahora es posible acceder al último elemento de un array sin tener que hacer la típica maniobra:

let lastSalary = array[array.length - 1] ;

Ahora podemos usar :

let lastSalary = array.at(-1);

Eliane Rivera Castillo

student

Buen dato, gracias!!

Jhon Eduard Bocanegra Ortiz

student

Ricardo Alfonso Chavez Vilcapoma

student

Nunca me ha gustado el tema financiero xd...pero en sí al ver las clases, es increíble que se pueda desarrollar esto usando JavaScript.

Miguel Angel Hernandez Colombo

student

yo durante el curso! Dioses del internet ayudenme!

Luis Rodríguez

student

En mi opinión está errado el resultado, porque en el array de porcentajes de crecimiento incluye dos veces cero... y se está considerando, por lo que el porcentaje es menor.. y OBVIAMENTE "cero" no es crecimiento... por lo que yo lo hice así:

PlatziMath.SiguienteSalarioConMediana=function(persona){
    let salarios=PlatziMath.encontrarSalariosDePersona(persona)
    console.log(salarios);
    let porcentajes=[];
    salarios.forEach((element,index,array) => {
        console.log(element);
        if(index !== salarios.lenght-2)
        if( (salarios[index+1]-salarios[index])/salarios[index] > 0)
         porcentajes.push( (salarios[index+1]-salarios[index])/salarios[index]  )    
        });
    let MedianaDeSalarios=PlatziMath.mediana(porcentajes)
    return (salarios[(salarios.length)-1]*(MedianaDeSalarios+1))

Gualberto Montiel

student

Aqui una pequeña funcion que me ayudo a entender la logica del ejercicio:

function incrementSalary(currentSalary, incrementPercentage) {
  let incrementAmount = currentSalary * (incrementPercentage / 100);
  let newSalary = currentSalary + incrementAmount;
  return newSalary;
}

Elizabeth Villarruel

student

Holaaa, una observación es que vas demasiado rápido, he visto el vídeo varias veces para comprender pero de igual forma siento que falta explicarlo ded una forma más tranquila, tqm profe juan <3

CRISTIAN DARIO AGUDELO PORRAS

student

DRY -- Don't Repeat Yourself.

Por si no lo notaron tanto en la funcion de medianaPorPersona como en proyeccionPorPersona para generar el array de los salarios, se repite codigo escribiendo practicamente las mismas lineas

const trabajos = EncontrarPersona(nombrePersona).trabajos;
const salarios = trabajos.map(item => item.salario);

Desde mi punto de vista, conviene mas crear una funcion que directamente nos devuelva el array de los salarios de cualqueir persona, sin tener que escribir las mismas lineas cada vez que se requiera.

Silvia Corrales

student

Analisis de la proyecccion del salario de una persona:

function proyeccionPorPersona(nombrePersona) {
    // Filtrar por persona:
    const trabajos = personaBuscada(nombrePersona).trabajos;

    // Hacer un arreglo para guardar los incrementos que ha tenido la persona en sus salarios:
    let porcentajesCrecimiento = [];
    for (let i = 1; i < trabajos.length; i++){
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i - 1].salario;
        const crecimiento = salarioActual - salarioPasado;
        const porcentajeCrecimiento = crecimiento / salarioPasado;

        porcentajesCrecimiento.push(porcentajeCrecimiento);
    } 
    console.log(porcentajesCrecimiento);

    // Obtener la mediana de los porcentajes de  crecimiento:
    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcentajesCrecimiento);
    console.log(medianaPorcentajesCrecimiento);

    // Proyectar su nuevo aumento de salario encontrando su ultimo salario y multiplicarlo por el porcentaje de crecimiento:
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const aumento = ultimoSalario * medianaPorcentajesCrecimiento;

    // El resultado de la proyeccion de su salario sera la suma de su salario mas reciente y el aumento calculado:
    const nuevoSalario = ultimoSalario + aumento;
    return nuevoSalario;
};

Felipe Moreno

student

Me enrede un poco para sacar los porcentajes pero al final llegue al mismo resultado 😆

function getSalarios(nombre, arraySalarios){
    const persona = arraySalarios.find(salario => salario.name == nombre);
    const salarios_persona = persona.trabajos.map(trabajo => trabajo.salario);
    return salarios_persona;
};

function proyectarSalarios(nombre, arraySalarios){
    const salarios_persona = getSalarios(nombre, arraySalarios);
    const porcentajes_aumentos = [];
    for (const index in salarios_persona) {
       if(index < (salarios_persona.length-1)){
            const salarioActual = salarios_persona[parseInt(index) + 1];
            const salarioAnterior = salarios_persona[index];
            const aumento = ((salarioActual * 100) / salarioAnterior) - 100;
            porcentajes_aumentos.push(aumento);
       }
    }
    const proyeccion_porcentaje = PlatziMath.calcular_mediana(porcentajes_aumentos);
    const ultimo_salario = salarios_persona[salarios_persona.length -1];
    const aumento = (ultimo_salario*proyeccion_porcentaje)/100;
    const nuevo_salario = ultimo_salario + aumento;
    return nuevo_salario;
}

Matias Ezequiel Rivero

student

Hola, dejo aporte por si alguien le sirve!! Se que vienen áspera las mate. Agregué que retorne un objeto con la proyección de sueldos, por la misma cantidad de años de la información de origen de la persona.

function proyeccionSalarial(personaProyeccion) {
    const trabajos = encontrarPersonas(personaProyeccion).trabajos;    
    const proyeccionCrecimiento = []
    
    for( i=1; i<trabajos.length; i++) {
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i-1].salario;
        const porcentajeCrecimiento = (salarioActual - salarioPasado) / salarioPasado;
        proyeccionCrecimiento.push(porcentajeCrecimiento);       
    };

    const medianaPorcentajeCrecimiento = MhMath.calcularMediana(proyeccionCrecimiento);    
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const nuevoSalario = (ultimoSalario * medianaPorcentajeCrecimiento) + ultimoSalario;
    console.log(`Tu próximo nuevo salario 2024 estimado es u$ ${nuevoSalario}`);
    
    let proyeccion = [];
    let years = 2023;
    let sueldo = ultimoSalario;
    for( i=0; i<trabajos.length; i++) {
        years++;
        sueldo += sueldo * medianaPorcentajeCrecimiento;
        proyeccion.push({
            year: years,
            sueldo: sueldo,
        });
    };
    return proyeccion;
};

Angelo Mateo Bessolo Rueda

student

excelente clase! JS tiene un mundo de cosas por explorar cada día más emocionado de continuar con este gran reto, en el tema de los porcentajes faltó multiplicar por 100 ya que el primer aumento fue del 240% respecto al primer sueldo.👌

// Haremos la proyeccion salarial usando una media geometrica
// Necesitamos el porcentaje de aumento de cada año, para calcular la media geometrica
// %aumento = (salarioNuevo - salarioViejo) / salarioViejo + 1

const aumentos = [];

function calcularMediaGeometrica (person) {
    const array = listaSalarios(person);

    for (let i=1; i<array.length; i++){
    
        let aumentoPorAnnio = (array[i] - array[i-1]) / array[i-1];
// condicional para cumplir reglas de la Media Geometrica (Si hay un aumento de 0% no sumarle el +1)
        if (aumentoPorAnnio === 0){
            aumentoPorAnnio = 0;
        } else {
            aumentoPorAnnio++;
        }
        aumentos.push(aumentoPorAnnio.toFixed(2));    
    }

    let multiplicarAumentos = aumentos.reduce((valorAcumulado, valorNuevo) => 
    valorAcumulado * valorNuevo);
    let indiceRaiz = 1 / aumentos.length;

// Aca estamos sacando una raiz con un indice que es igual a la cantidad de aumentos que tuvo la persona

    let mediaGeometrica = multiplicarAumentos ** indiceRaiz;
    let proyeccion = mediaGeometrica * array[array.length-1];
    console.log(mediaGeometrica.toFixed(2));
    if (mediaGeometrica === 0) {
            console.log(`${person} para el año que viene proyectamos que no tendras un aumento salarial.`);
    } else {
        console.log(`${person} para el año que viene proyectamos que tendras un salario de $${proyeccion.toFixed(0)}.`);
    }
    return mediaGeometrica.toFixed(2); 
}

calcularMediaGeometrica("Daniel");

function proyeccionProxSalario(id){
    const trabajosPersona = encontrarPersona(id).trabajos
    const salarios = trabajosPersona.map((elemento)=> elemento.salario)

    const listaInvertida = salarios.sort((a, b)=> b - a)
    

    const salarioActual = listaInvertida[0]
    const salarioAnterior = listaInvertida.find((valor)=> valor !== salarioActual)

    const porcentajeSalarial = Number((((salarioActual - salarioAnterior)/salarioAnterior) * 100).toFixed(2))

    const nuevoSalario = Number((salarioActual * ((1 + (porcentajeSalarial / 100)))).toFixed(2))
    return nuevoSalario
}

console.log(salarios[0]);
// Mediana una persona 

function findPerson(array,nameSearch){
    return (array.filter(function(articulo){
        return articulo.name == nameSearch;
    }));
}
function mediaPerson(array, nameSearch){
    const mediaP =findPerson(array,nameSearch)[0].trabajos.map(function (articulo){ return articulo.salario;}) ;
    return MathOperation.calcMediana(mediaP);
    
}
function proyectSalary(array, nameSearch, yearproyect){
    const yearAndSalary =findPerson(array,nameSearch)[0].trabajos.map(function(articulo){return [articulo.year,articulo.salario];});
    const yearandSalarySum = yearAndSalary.reduce(function(a,b){return [a[0]+b[0],a[1]+b[1]]});
    const yearCuad = yearAndSalary.reduce(function(a,b){
        return [a[0]+(b[0]**2)];
    }, [0,0]);
    const yearporsalary = yearAndSalary.reduce(function(a,b){return [a[0]+b[0]*b[1]]},[0,0]);
    yearandSalarySum.push(yearCuad[0],yearporsalary[0])
    const valueLinealA = Number(((yearAndSalary.length*yearandSalarySum[3]-yearandSalarySum[0]*yearandSalarySum[1])/(yearAndSalary.length*yearandSalarySum[2]-yearandSalarySum[0]**2)).toFixed(3));
    const valueLinealB = Number(((yearandSalarySum[1]-valueLinealA*yearandSalarySum[0])/(yearAndSalary.length)).toFixed(3));
    const resultlenalproyect = valueLinealA*(yearproyect)+(valueLinealB);
    return [yearAndSalary, yearandSalarySum, valueLinealA, valueLinealB, resultlenalproyect]
}
console.log([findPerson(salarios,"Juanita"),mediaPerson(salarios,"Juanita")]);
console.log(proyectSalary(salarios,"Juanita",2023));```

// Analisis para persona

function calcularMedianaPorPersona(nombrePersona) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = filtrarSalarios(arrayTrabajos);
	const medianaSalarios = PlatziMath.calcMediana(arraySalarios);
	// console.log(salarios);
	// console.log(objPersona);
	// console.log(arrayTrabajos);
	// console.log(arraySalarios);
	// console.log(medianaSalarios);

	function filtrarSalarios(arr) {
		const arraySal = [];
		for (element of arr) {
			arraySal.push(element.salario);
		}
		return arraySal;
	}
}

//console.log(calcularMedianaPorPersona("Alex"));

// Analisis de proyeccion

function proyectarSalario(nombrePersona, añoProyectado) {
	const objPersona = salarios.find((arr) => arr.name == nombrePersona);
	const arrayTrabajos = objPersona.trabajos;
	const arraySalarios = arrayTrabajos.map((element) => element.salario);

	console.log(arraySalarios);

	const pendiente =
		(arraySalarios[arraySalarios.length - 1] - arraySalarios[0]) /
		(arraySalarios.length - 1);
	const proyeccion = pendiente * (añoProyectado - 2018) + arraySalarios[0];
	console.log(proyeccion);
}
proyectarSalario("Alex", 2023);

PlatziMath.SiguienteSalarioConMediana=function(persona){
    let salarios=PlatziMath.encontrarSalariosDePersona(persona)
    console.log(salarios);
    let porcentajes=[];
    salarios.forEach((element,index,array) => {
        console.log(element);
        if(index !== salarios.lenght-2)
        if( (salarios[index+1]-salarios[index])/salarios[index] > 0)
         porcentajes.push( (salarios[index+1]-salarios[index])/salarios[index]  )    
        });
    let MedianaDeSalarios=PlatziMath.mediana(porcentajes)
    return (salarios[(salarios.length)-1]*(MedianaDeSalarios+1))

function incrementSalary(currentSalary, incrementPercentage) {
  let incrementAmount = currentSalary * (incrementPercentage / 100);
  let newSalary = currentSalary + incrementAmount;
  return newSalary;
}

function proyeccionPorPersona(nombrePersona) {
    // Filtrar por persona:
    const trabajos = personaBuscada(nombrePersona).trabajos;

    // Hacer un arreglo para guardar los incrementos que ha tenido la persona en sus salarios:
    let porcentajesCrecimiento = [];
    for (let i = 1; i < trabajos.length; i++){
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i - 1].salario;
        const crecimiento = salarioActual - salarioPasado;
        const porcentajeCrecimiento = crecimiento / salarioPasado;

        porcentajesCrecimiento.push(porcentajeCrecimiento);
    } 
    console.log(porcentajesCrecimiento);

    // Obtener la mediana de los porcentajes de  crecimiento:
    const medianaPorcentajesCrecimiento = PlatziMath.calcularMediana(porcentajesCrecimiento);
    console.log(medianaPorcentajesCrecimiento);

    // Proyectar su nuevo aumento de salario encontrando su ultimo salario y multiplicarlo por el porcentaje de crecimiento:
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const aumento = ultimoSalario * medianaPorcentajesCrecimiento;

    // El resultado de la proyeccion de su salario sera la suma de su salario mas reciente y el aumento calculado:
    const nuevoSalario = ultimoSalario + aumento;
    return nuevoSalario;
};

function getSalarios(nombre, arraySalarios){
    const persona = arraySalarios.find(salario => salario.name == nombre);
    const salarios_persona = persona.trabajos.map(trabajo => trabajo.salario);
    return salarios_persona;
};

function proyectarSalarios(nombre, arraySalarios){
    const salarios_persona = getSalarios(nombre, arraySalarios);
    const porcentajes_aumentos = [];
    for (const index in salarios_persona) {
       if(index < (salarios_persona.length-1)){
            const salarioActual = salarios_persona[parseInt(index) + 1];
            const salarioAnterior = salarios_persona[index];
            const aumento = ((salarioActual * 100) / salarioAnterior) - 100;
            porcentajes_aumentos.push(aumento);
       }
    }
    const proyeccion_porcentaje = PlatziMath.calcular_mediana(porcentajes_aumentos);
    const ultimo_salario = salarios_persona[salarios_persona.length -1];
    const aumento = (ultimo_salario*proyeccion_porcentaje)/100;
    const nuevo_salario = ultimo_salario + aumento;
    return nuevo_salario;
}

function proyeccionSalarial(personaProyeccion) {
    const trabajos = encontrarPersonas(personaProyeccion).trabajos;    
    const proyeccionCrecimiento = []
    
    for( i=1; i<trabajos.length; i++) {
        const salarioActual = trabajos[i].salario;
        const salarioPasado = trabajos[i-1].salario;
        const porcentajeCrecimiento = (salarioActual - salarioPasado) / salarioPasado;
        proyeccionCrecimiento.push(porcentajeCrecimiento);       
    };

    const medianaPorcentajeCrecimiento = MhMath.calcularMediana(proyeccionCrecimiento);    
    const ultimoSalario = trabajos[trabajos.length - 1].salario;
    const nuevoSalario = (ultimoSalario * medianaPorcentajeCrecimiento) + ultimoSalario;
    console.log(`Tu próximo nuevo salario 2024 estimado es u$ ${nuevoSalario}`);
    
    let proyeccion = [];
    let years = 2023;
    let sueldo = ultimoSalario;
    for( i=0; i<trabajos.length; i++) {
        years++;
        sueldo += sueldo * medianaPorcentajeCrecimiento;
        proyeccion.push({
            year: years,
            sueldo: sueldo,
        });
    };
    return proyeccion;
};

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