Ejercicios de

Aplicación –
Primera parte

Programación
Lógica

1
1. Ejercicios de aplicación
1) Implementar un algoritmo que permita representar información sobre la
compra de un artículo. Cada artículo tiene un código, nombre y precio. El
algoritmo debe calcular y mostrar por pantalla el valor final de la compra.
Se debe ingresar la información del artículo y la cantidad. Considerar la
aplicación de impuestos por un valor de 21 % del subtotal.

algoritmo registros_compra_articulo
tipo
registro: registroArticulo
inicio
entero: codigo
cadena: nombre
real: precio
fin-registro
registro: registroCompra
inicio
registroArticulo: articulo
entero: cantidad
real: impuestos, subtotal, total
fin-registro
var
registroCompra: compra
const
real: porcentajeImpuestos  0.21
inicio
mostrar("Cálculo de la compra de un artículo")

mostrar("Ingrese el nombre del artículo")

leer(compra.articulo.nombre)

mostrar("Ingrese el código del artículo")

leer(compra.articulo.codigo)

mostrar("Ingrese el precio del artículo")

leer(compra.articulo.precio)

mostrar("Ingrese la cantidad de artículos a comprar")

leer(compra.cantidad)

compra.subtotal  compra.articulo.precio * compra.cantidad

compra.impuestos  compra.subtotal * porcentajeImpuestos

compra.total  compra.subtotal + compra.impuestos

mostrar("El valor final de la compra es: ", compra.total)

fin

2) Implementar un algoritmo que permita representar la información de

cinco alumnos. Para cada alumno, se debe ingresar la siguiente
información: apellido, nota1, nota2, nota3, promedio. El algoritmo debe

2
mostrar el alumno con mayor promedio y la cantidad de alumnos que
superan el promedio de 4.

(Nota: esta versión del algoritmo considera que los promedios más altos de
los alumnos no se repiten, ya que siempre se muestra un único alumno
como promedio más alto).

algoritmo registros_alumnos
tipo
registro: registroAlumno
inicio
cadena: apellido
vectorNotas: notas
real: promedio
fin-registro
array[1…10] de registroAlumno: vectorAlumnos
array[1…3] de real: vectorNotas
var
entero: cantidadMayorPromedio4
vectorAlumnos: listadoAlumnos
registroAlumno: alumnoMayorPromedio
const
entero: cantidadAlumnos  5
inicio
cargarAlumnos(listadoAlumnos)

alumnoMayorPromedio  buscarMayorPromedio(listadoAlumnos)
mostrar(“El alumno con mayor promedio es ”, alumnoMayorPromedio.apellido, “ y su promedio
es ”, alumnoMayorPromedio.promedio)

cantidadMayorPromedio4  buscarPromedioMayor4(listadoAlumnos)
mostrar(“La cantidad de alumnos que superan el promedio de 4 es ”,
cantidadMayorPromedio4)
fin

procedimiento cargarAlumnos(vectorAlumnos: listadoAlumnos por referencia)

var
entero: i, j
inicio
mostrar(“Carga de datos de alumnos”)
desde i  1 hasta cantidadAlumnos hacer
mostrar(“Ingrese apellido del alumno ”, i)
leer(listadoAlumnos[i].apellido)
desde j  1 hasta 3 hacer
mostrar(“Ingrese la nota ”, i, “ del alumno ”, listadoAlumnos[i].apellido)
leer(listadoAlumnos[i].notas[j])
fin-desde
asignarPromedioAlumno(listadoAlumnos[i])
fin-desde
fin-procedimiento

registroAlumno funcion buscarMayorPromedio(vectorAlumnos: listadoAlumnos)

var
entero: i
registroAlumno: alumnoMayorPromedio
inicio

3
 alumnoMayorPromedio  listadoAlumnos[1]
desde i  2 hasta cantidadAlumnos hacer
si listadoAlumnos[i].promedio > alumnoMayorPromedio.promedio entonces
alumnoMayorPromedio  listadoAlumnos[i]
fin-si
fin-desde
devolver(alumnoMayorPromedio)
fin-funcion

entero funcion buscarPromedioMayor4(vectorAlumnos: listadoAlumnos)

var
entero: i, cantidad
inicio
cantidad  0
desde i  1 hasta cantidadAlumnos hacer
si listadoAlumnos[i].promedio > 4 entonces
cantidad  cantidad + 1
fin-si
fin-desde
devolver(cantidad)
fin-funcion

procedimiento asignarPromedioAlumno(registroAlumno: alumno por referencia)

var
entero: i
real: suma, promedio
inicio
suma  0
desde i  1 hasta 3 hacer
suma  suma + alumno.notas[i]
fin-desde
promedio  suma / 3
alumno.promedio  promedio
fin-procedimiento

3) Implementar un algoritmo que permita manipular la siguiente

información de trabajadores:
- apellido;
- número de horas trabajadas;
- precio por hora trabajada;
- sexo (codificado por masculino: ‘M’ y femenino: ‘F’).
Cada trabajador debe ser representado mediante un registro. La
información debe ser ingresada por el usuario del programa y se debe
mostrar por pantalla:
- la remuneración promedio;
- la mayor remuneración;
- la remuneración promedio de los trabajadores de sexo femenino;
- cantidad de trabajadores que perciben una remuneración por
encima del promedio.

algoritmo registros_trabajadores

4
tipo
registro: registroTrabajador
inicio
cadena: apellido
entero: horasTrabajadas
real: precioHora
caracter: sexo
fin-registro
array[1…100] de registroTrabajador: vectorTrabajadores
var
entero: cantidadTrabajadores
vectorTrabajadores: listado
real: promedioRemuneracionFemenino
registroTrabajador: trabajadorMayorRem
inicio
mostrar(“Ingrese la cantidad de trabajadores que va cargar”)
leer(cantidadTrabajadores)

cargarTrabajadores(listado, cantidadTrabajadores)

promedioRemuneracion  calcularRemuneracionPromedio(listado, cantidadTrabajadores)

mostrar(“La remuneración promedio es ”, promedioRemuneracion)

trabajadorMayorRem  calcularMayorRemuneracion(listado, cantidadTrabajadores)

mostrar(“El trabajador con mayor remuneración es ”, trabajadorMayorRem.apellido, “ “ y su
remuneración es ”, calcularRemuneracionTrabajador(trabajadorMayorRem))

promedioRemuneracionFemenino  calcularRemPromedioFemenino(listado,
cantidadTrabajadores)
mostrar(“La remuneración promedio de las trabajadoras es ”,
promedioRemuneracionFemenino)

mostrarTrabajadoresMayorPromedio(listado, cantidadTrabajadores)
fin

procedimiento cargarTrabajadores(vectorTrabajadores: listado por referencia, entero: N)

var
entero: i
inicio
mostrar(“Carga de datos de trabajadores”)
desde i  1 hasta N hacer
mostrar(“Ingrese el apellido del trabajador ”, i)
leer(listado[i].apellido)
mostrar(“Ingrese el número de horas trabajadas del trabajador ”, listado[i].apellido)
leer(listado[i].horasTrabajadas)
mostrar(“Ingrese el precio por hora del trabajador ”, listado[i].apellido)
leer(listado[i].precioHora)
mostrar(“Ingrese el sexo (masculino=‘M’ - femenino=‘F’) del trabajador ”,
listado[i].apellido)
leer(listado[i].sexo)
fin-desde
fin-procedimiento

real funcion calcularRemuneracionPromedio(vectorTrabajadores: listado, entero: N)

var
entero: i
real: suma, promedio
inicio
suma  0

5
 desde i  1 hasta N hacer
suma  suma + calcularRemuneracionTrabajador(listado[i])
fin-desde
promedio  suma / N
devolver(promedio)
fin-funcion

registroTrabajador funcion calcularMayorRemuneracion(vectorTrabajadores: listado, entero: N)

var
entero: i
registroTrabajador: trabajadorMayorRemuneracion
inicio
trabajadorMayorRemuneracion  listado[1]
desde i  2 hasta N hacer
si calcularRemuneracionTrabajador(listado[i]) >
calcularRemuneracionTrabajador(trabajadorMayorRemuneración) entonces
trabajadorMayorRemuneracion  listado[i]
fin-si
fin-desde
devolver(trabajadorMayorRemuneracion)
fin-funcion

real funcion calcularRemuneracionPromedio(vectorTrabajadores: listado, entero: N)

var
entero: i
real: sumaRemuneracion, promedioRemuneracion
inicio
sumaRemuneracion  0
desde i  1 hasta N hacer
sumaRemuneracion  sumaRemuneracion + calcularRemuneracionTrabajador(listado[i])
fin-desde
promedioRemuneracion  sumaRemuneracion / N
devolver promedioRemuneracion
fin-funcion

real funcion calcularRemPromedioFemenino(vectorTrabajadores: listado, entero: N)

var
entero: i, cantidad
real: suma, promedio
inicio
suma  0
cantidad  0
desde i  1 hasta N hacer
si listado[i].sexo == ‘F’ entonces
suma  suma + calcularRemuneracionTrabajador(listado[i])
cantidad  cantidad + 1
fin-si
fin-desde
promedio  suma / cantidad
devolver(promedio)
fin-funcion

procedimiento mostrarTrabajadoresMayorPromedio(vectorTrabajadores: listado, entero: N)

var
entero: i
real: remuneracionPromedio
inicio

6
 remuneracionPromedio  calcularRemuneracionPromedio(listado, N)
desde i  1 hasta N hacer
si calcularRemuneracionTrabajador(listado[i]) > remuneracionPromedio entonces
mostrar(“El trabajador ”, listado[i].apellido, “ tiene una remuneración mayor al
promedio. Su remuneración es: ”, calcularRemuneracionTrabajador(listado[i]))
fin-si
fin-desde
fin-procedimiento

real funcion calcularRemuneracionTrabajador(registroTrabajador: trabajador)

var
real: remuneracion
inicio
remuneracion  trabajador.horasTrabajadas * trabajador.precioHora
devolver(remuneracion)
fin-funcion