Principios de algoritmos UTP – resolución de examen final Nº 4

Resolución de un examen final de Principios de algoritmos de la UTP. Cada ejercicio se resuelve mediante un algoritmo bajo el paradigma de la programación estructurada aplicando las estructuras de control: secuenciales, selectivas y repetitivas. La representación de los algoritmos es a través de pseudocódigo y diagramas de flujo utilizando Pseint.

PREGUNTA 1

Desarrollar un algoritmo que permita realizar para N empleados:

  • Leer los salarios, validando que sean entre 1000 y 6000.
  • Mostrar un reporte con el porcentaje de empleados que ganan menos de 1800, entre 1800 y 3500, y más de 3500.
  • Mostrar el promedio de salarios.

Pseint

Pseudocódigo

				
					Proceso Pregunta1
	Definir N, contador1, contador2, contador3 Como Entero
	Definir salario, sumaSalario, promedioSalario, porcentaje1, porcentaje2, porcentaje3 como Real
	
	Repetir
		Escribir "Ingrese el numero de empleados: "
		Leer N
	Hasta Que N > 0
	
	sumaSalario <- 0
	contador1 <- 0
	contador2 <- 0
	contador3 <- 0
	Para i <- 1 hasta N Con Paso  1 Hacer
		Repetir
			Escribir "Salario persona ", i, ": "
			Leer salario
		Hasta Que salario >= 1000 y salario <= 6000
		
		sumaSalario <- sumaSalario + salario
		
		Si salario < 1800 Entonces
			contador1 <- contador1 + 1
		SiNo
			Si salario <= 3500 Entonces
				contador2 <- contador2 + 1
			SiNo
				contador3 <- contador3 + 1
			FinSi
			
		FinSi
	FinPara
	
	promedioSalario <- sumaSalario / N
	porcentaje1 <- contador1 * 100 / N
	porcentaje2 <- contador2 * 100 / N
	porcentaje3 <- contador3 * 100 / N
	
	Escribir "Porcentaje de personas que ganan menos de 1800: ", porcentaje1, "%"
	Escribir "Porcentaje de personas que ganan entre 1800 y 3500: ", porcentaje2, "%"
	Escribir "Porcentaje de personas que ganan de 3500: ", porcentaje3, "%"
	Escribir "Promedio de salarios: S/", promedioSalario
	
FinProceso
view raw
				
			

Diagrama de flujo

PREGUNTA 2

Crear un programa en pseudocódigo para un estacionamiento que cumpla con las siguientes condiciones:

  1. Se debe ingresar la placa del vehículo.
  2. Se ingresa el tiempo que el vehículo permaneció parqueado en minutos.
  3. Si el vehículo es una motocicleta se cobra S/ 0.02 el minuto, S/ 0.25 el minuto si es un auto y S/ 0.30 si es una camioneta.
  4. Si el vehículo permanece más de 1 hora se hace un descuento del 10%; si permanece más de 2 horas, un 20%; si son más de 3 horas, un 30%.
  5. Se debe mostrar un cuadro resumen que indique: la placa, el tiempo en horas y minutos, el precio base, el descuento y el importe final.
  6. El algoritmo solo debe permitir ingresar los tipos de vehículos mencionados y una cantidad de minutos mayor a cero, en caso no se ingresen valores correctos debe volver a pedirlos sin finalizar la ejecución.

Se evaluará:

  •  Validar el tipo de vehículo.
  • Validar la cantidad de minutos.
  • Calcular el precio base.
  • Calcular el descuento.
  • Calcular el precio final.
  • Calcular el tiempo en horas y minutos. Por ejemplo, si se ingresa 200 minutos, se debe mostrar 3 horas y 20 minutos.
  • Mostrar el cuadro resumen.

Pseint

Pseducódigo

				
					Proceso Pregunta2
	Definir N, tiempo Como Entero
	Definir placa, tipo Como Caracter
	Definir importeBase, descuento, importeFinal como Real
	Definir horas, minutos como Entero
	
	Repetir
		Escribir "Ingrese el numero de vehiculos: "
		Leer N
	Hasta Que N > 0
	
	Para i <- 1 hasta N Con Paso  1 Hacer
		Escribir "Ingrese Placa del vehiculo #", i
		Leer placa
		
		Repetir
			Escribir "Tiempo de parqueado (minutos): "
			Leer tiempo
		Hasta Que tiempo > 0
		
		Repetir
			Escribir "Ingrese Tipo del vehiculo: (M:motocicleta, A:auto, C:Camioneta): "
			Leer tipo
		Hasta Que tipo = 'M' o tipo = 'A' o tipo = 'C'
		
		Segun tipo Hacer
			'M':
				importeBase <- tiempo * 0.20
			'A':
				importeBase <- tiempo * 0.25
			'C':
				importeBase <- tiempo * 0.30
		Fin Segun
		
		Si tiempo <= 60
			descuento <- 0
		Sino
			Si tiempo <= 120
				descuento <- importeBase * 0.10
			SiNo
				Si tiempo <= 180
					descuento <- importeBase * 0.20
				SiNo
					descuento <- importeBase * 0.30
				FinSi
			FinSi
		FinSi
		
		importeFinal <- importeBase - descuento
		
		horas <- trunc(tiempo / 60)
		minutos <- tiempo - horas * 60
		
		Escribir "REPORTE: "
		Escribir "Placa: ", placa
		Si (tiempo > 60) entonces
			Escribir "Tiempo: ", horas, " horas y ", minutos, " minutos"
		Sino
			Escribir "Tiempo: ", tiempo, " minutos"
		FinSi
		
		Escribir "Precio base: S/ ", importeBase
		Escribir "Descuento: S/ ", descuento
		Escribir "Importe final: S/ ", importeFinal
		
	FinPara
FinProceso
				
			

Diagrama de flujo

PREGUNTA 3

Realizar prueba de escritorio al siguiente algoritmo.

Prueba de escritorio

Pseint

Pseudocódigo

				
					Proceso Pregunta3
	Definir m, n, p Como Entero    
	m<-30
	n<-6
	p<-1
	Mientras n > 2 Hacer
		Escribir "true"
		Escribir "m=", m
		Escribir "n=", n
		Escribir "p=", p
		Escribir "-----------"
		m <- n mod 2
		n <- n - 1
		p <- m - n
	FinMientras
	Escribir "false"
	Escribir "m=", m
	Escribir "n=", n
	Escribir "p=", p
	Escribir "-----------"
FinProceso
				
			

Ejercicios con estructura repetitiva Mientras – parte 2

Esta publicación es la continuación de la parte 1: https://algoritmosyalgomas.com/algoritmos-estructura-repetitiva-mientras/

Ejercicio 11

Elabora un algoritmo que imprima el mayor y el menor de una serie de cinco números que vamos introduciendo por teclado.

Pseudocódigo

				
					Proceso Ejercicio11
	Definir i, numero, minimo, maximo como Entero
	
	i <- 1
	Mientras i <= 5 Hacer
		Escribir "Ingrese número Nº: ", i
		Leer numero
		Si i = 1 Entonces
			minimo <- numero
			maximo <- numero
		Sino
			Si numero > maximo Entonces
				maximo = numero
			FinSi
				
			Si numero < minimo Entonces
				minimo <- numero
			FinSi
		FinSi
		i <- i + 1
	FinMientras
	Escribir "Mínimo: ", minimo
	Escribir "Máximo: ", maximo
FinProceso
				
			

Ejercicio 12

Introducir dos números por teclado. Imprimir los numeros naturales que hay entre ambos números empezando por el más pequeño, contar cuantos hay y cuantos de ellos son pares. Calcular la suma de los impares.

Pseudocódigo

				
					Proceso Ejercicio12
	Definir i, numeroInicial, numeroFinal, contador, contadorPares, sumaImpares como Entero
	numeroInicial <- 0
	numeroFinal <- 0
	
	Mientras numeroInicial <= 0 Hacer
		Escribir "Ingrese el número inicial: "
		Leer numeroInicial
	FinMientras
	
	Mientras numeroFinal <= 0 Hacer
		Escribir "Ingrese el número final: "
		Leer numeroFinal
	FinMientras	
	
	i <- numeroInicial
	contador <- 0
	contadorPares <- 0
	sumaImpares <- 0
	Mientras i <= numeroFinal Hacer
		Escribir i
		contador <- contador + 1
		
		Si i mod 2 = 0 Entonces
			contadorPares <- contadorPares  + 1
		SiNo
			sumaImpares <- sumaImpares + i
		FinSi
		
		i <- i + 1
	FinMientras
	
	Escribir "Cantidad de números entre ", numeroInicial, " y ", numeroFinal, " es: ", contador
	Escribir "Cantidad de números pares entre ", numeroInicial, " y ", numeroFinal, " es: ", contadorPares
	Escribir "Suma de impares entre ", numeroInicial, " y ", numeroFinal, " es: ", sumaImpares
FinProceso
				
			

Ejercicio 13

Elabora un algoritmo que permita leer dos números positivos. Debe validar que el segundo número debe ser mayor que el primero. Luego se deben imprimir todos los números pares que se encuentran entre ambos números (en caso que sean pares). Además debe imprimir la cantidad de números múltiplos de 5 entre ambos números.

Pseudocódigo

				
					Proceso Ejercicio13
	Definir numero1, numero2 como Entero
	Definir contador, contMultiplos5 como Entero
	Repetir
		Escribir "Ingresa el primer número: "
		Leer numero1 
	Hasta Que numero1 > 0
	
	Repetir
			Escribir "Ingresa el segundo número: "
			Leer numero2		
	Hasta Que (numero2 > numero1)
	
	contador <- numero1
	Mientras contador <= numero2 Hacer
		Si (contador % 2) = 0 Entonces
			Escribir contador
		FinSi
		contador <- contador + 1
		
		Si contador % 5 = 0 Entonces
			contMultiplos5 <- contMultiplos5 + 1
		FinSi
	Fin Mientras
	
	Escribir "La cantidad de números múltiplos de 5 son: ", contMultiplos5
FinProceso
				
			

Diagrama de flujo

Explicación del pseudocódigo

Las líneas 2-3 declaran las variables que se van a usar en el proceso: “numero1“, “numero2“, “contador” y “contMultiplos5“. Los primeros dos son los números que el usuario ingresará, el “contador” se utiliza para iterar a través de los números entre “numero1” y “numero2“, y “contMultiplos5” se utiliza para contar la cantidad de números múltiplos de 5 entre los dos números.

Las líneas 4-7 utilizan una estructura de repetición “Hasta Que” para asegurarse de que “numero1” sea un número positivo. En otras palabras, el programa seguirá pidiendo al usuario que ingrese “numero1” hasta que este valor sea mayor que cero.

Las líneas 9-12 utilizan una estructura de repetición similar para asegurarse de que “numero2” sea mayor que “numero1”. En otras palabras, el programa seguirá pidiendo al usuario que ingrese “numero2” hasta que este valor sea mayor que “numero1”.

La línea 14 inicializa “contador” con el valor de “numero1”.

Las líneas 15-24 utilizan una estructura de repetición “Mientras” para iterar a través de todos los números entre “numero1” y “numero2”. Si el “contador” actual es un número par, entonces se imprime ese número en la línea 17. Además, si el “contador” actual es un múltiplo de 5, se incrementa el valor de “contMultiplos5” en la línea 22.

La línea 26 imprime la cantidad total de números múltiplos de 5 encontrados entre “numero1” y “numero2”.

Ejercicio 14

Elabora un algoritmo que permita leer dos números positivos. Debe validar que el segundo número debe ser mayor que el primero. Luego se deben imprimir todos los números primos que se encuentren entre ambos números.

Pseudocódigo

				
					Proceso Ejercicio14
	Definir numero1, numero2 como Entero
	Definir contador, contadorDivisores como Entero
	Repetir
		Escribir "Ingresa el primer número: "
		Leer numero1 
	Hasta Que numero1 > 0
	
	Repetir
		Escribir "Ingresa el segundo número: "
		Leer numero2		
	Hasta Que (numero2 > numero1)
	
	contador <- numero1
	Mientras contador <= numero2 Hacer
		contadorDivisores <- 0
		Para i <- 1 Hasta contador Con Paso 1
			Si contador % i = 0 Entonces
				contadorDivisores <- contadorDivisores + 1
			FinSi
		FinPara
		
		Si contadorDivisores = 2 Entonces
			Escribir contador
		FinSi
		
		contador <- contador + 1
	Fin Mientras
FinProceso
				
			

Diagrama de flujo

Explicación del pseudocódigo

Las líneas del 2 al 3 definen dos variables de tipo entero llamadas numero1 y numero2, así como también dos contadores de tipo entero llamados contador y contadorDivisores.

Las líneas del 4 al 7 son un ciclo repetir-hasta-que que le pide al usuario ingresar un número entero positivo para el valor de numero1, y se repite hasta que se cumple la condición numero1 > 0.

Las líneas del 9 al 12 son un ciclo repetir-hasta-que similar al anterior, pero esta vez le pide al usuario ingresar un valor para numero2, que debe ser mayor que numero1.

La línea 14 inicializa la variable contador con el valor de numero1.

Las líneas del 15 al 28 describen una estructura repetitiva mientras que se ejecutará mientras contador sea menor o igual a numero2. En cada iteración, se inicializa el contadorDivisores con cero. Luego, se utiliza un ciclo para con variable i que va desde 1 hasta el valor de contador, verificando si el valor de contador es divisible por i (si el resto de la división es cero). Si es así, se incrementa el contadorDivisores. Después de finalizar el ciclo, si contadorDivisores es igual a 2, significa que el contador es primo, y se imprime su valor. Por último, se incrementa el contador en 1.

Ejercicio 15

Diseñe un algoritmo que permita ingresar un número entero positivo. Luego, indicar la cantidad de cifras que tiene dicho número.

Pseudocódigo

				
					
Proceso Ejercicio15
	Definir numero, contador como Entero
	Repetir
		Escribir "Ingresa el número: "
		Leer numero
	Hasta Que numero > 0
	
	contador <- 0
	Mientras numero <> 0 Hacer
		numero <- trunc(numero / 10)
		contador <- contador + 1
	FinMientras
	
	Escribir "La cantidad de dígitos que tiene el número es: ", contador
FinProceso
				
			

Diagrama de flujo

Explicación del pseudocódigo

Este pseudocódigo corresponde al algoritmo para contar la cantidad de dígitos que tiene un número entero positivo.

Se inicia definiendo las variables “numero” y “contador” como enteros en la línea 2.

Se utiliza un bucle repetir-hasta-que en las líneas 3 a 6 para que el usuario ingrese un número positivo. Si el número ingresado es menor o igual a cero, el bucle se seguirá repitiendo hasta que se ingrese un número positivo.

Luego, se inicializa la variable “contador” en cero en la línea 8.

Se utiliza una estructura repetitiva mientras en las líneas 9 a 12 para contar la cantidad de dígitos del número ingresado. El bucle se repetirá mientras “numero” sea diferente de cero. Dentro del bucle, se divide el número entre 10 y se trunca su valor en la línea 10 para obtener el cociente sin el último dígito del número original. Luego, se incrementa el valor de “contador” en 1 en la línea 11.

Una vez que el bucle ha finalizado, en la línea 14 se muestra el resultado de la cantidad de dígitos que tiene el número ingresado.

Ejercicio 16

Diseñe un algoritmo que permita ingresar un número entero positivo. Luego mostrar el número invertido y la cantidad de dígitos del número ingresado.

Pseudocódigo

				
					Proceso Ejercicio16
	Definir numero, contador, digito, invertido como Entero
	Repetir
		Escribir "Ingresa el número: "
		Leer numero
	Hasta Que numero > 0
	
	contador <- 0
	invertido <- 0
	Mientras numero <> 0 Hacer
		digito <- numero % 10
		invertido <- invertido * 10 + digito
		numero <- trunc(numero / 10)
		contador <- contador + 1
	FinMientras
	
	Escribir "La cantidad de dígitos que tiene el número es: ", contador
	Escribir "El número invertido es: ", invertido
FinProceso
				
			

Diagrama de flujo

Explicación del pseudocódigo

Línea 2: Se declaran las variables que se utilizarán. Las variables numero y contador se utilizan para almacenar el número ingresado y la cantidad de dígitos de dicho número, respectivamente. Las variables digito e invertido se utilizan para invertir el número ingresado.

Líneas 3-6: Se solicita al usuario ingresar un número y se valida que el número ingresado sea positivo.

Líneas 10-15: Se utiliza una estructura repetitiva Mientras para obtener la cantidad de dígitos del número ingresado y su inverso. La variable contador se inicializa en 0 y se utiliza para contar la cantidad de dígitos del número ingresado. La variable invertido se inicializa en 0 y se utiliza para almacenar el número invertido. En cada iteración del bucle, se obtiene el último dígito del número ingresado (utilizando la operación módulo %), se lo agrega al número invertido (multiplicando por 10 y sumando el dígito obtenido) y se elimina el último dígito del número ingresado (dividiendo por 10). Además, se incrementa en 1 la variable contador en cada iteración.

Líneas 17-18: Se muestra por pantalla la cantidad de dígitos del número ingresado y su inverso.

Ejercicio 17

Diseñe un algoritmo que permita ingresar una cantidad incierta de números enteros positivo. Para cada número ingresado mostrar su número invertido y su número de cifras.

Pseudocódigo

				
					Proceso Ejercicio17
	Definir numero, contador, digito, invertido como Entero
	Definir respuesta como Caracter
	
	Repetir
		Repetir
			Escribir "Ingresa el número: "
			Leer numero
		Hasta Que numero > 0
		
		contador <- 0
		invertido <- 0
		Mientras numero <> 0 Hacer
			digito <- numero % 10
			invertido <- invertido * 10 + digito
			numero <- trunc(numero / 10)
			contador <- contador + 1
		FinMientras
		
		Escribir "La cantidad de dígitos que tiene el número es: ", contador
		Escribir "El número invertido es: ", invertido
		
		Repetir
			Escribir "Desea seguir ingresando números? (S/N)"
			Leer respuesta
		Hasta Que respuesta = 'S' o respuesta = 'N'
	Hasta Que respuesta = 'N'
FinProceso
				
			

Diagrama de flujo

Explicación del pseudocódigo

Líneas 2-3: Definición de variables. En esta sección se definen las variables “numero”, “contador”, “digito” e “invertido” como enteros y “respuesta” como carácter.

Líneas 5-27: Bucle principal. Este bucle se repetirá hasta que el usuario decida no ingresar más números (respuesta = ‘N’). Dentro de este bucle, se solicita al usuario que ingrese un número hasta que este sea mayor que cero. Luego, se inicializan las variables “contador” e “invertido” en cero. A continuación, se utiliza un bucle mientras para determinar la cantidad de dígitos del número ingresado y su inverso. 

El bucle mientras se repetirá mientras el número sea diferente de cero. Dentro de este bucle, se utiliza el operador módulo (%) para obtener el último dígito del número ingresado, se multiplica el número invertido por 10 y se le suma el último dígito obtenido y finalmente se divide el número ingresado por 10 y se trunca su valor (eliminando los decimales) para continuar obteniendo los dígitos restantes del número. También se incrementa en 1 el contador en cada iteración del bucle mientras.

Líneas 20-21: Se muestra al usuario la cantidad de dígitos que tiene el número ingresado y su inverso.

Líneas 23-26: En este bucle se solicita al usuario si desea ingresar otro número (respuesta = ‘S’ o respuesta = ‘N’). Si el usuario ingresa una respuesta diferente, se vuelve a solicitar que ingrese su respuesta hasta que sea una respuesta válida.

Línea 27: El bucle principal se repetirá mientras el usuario ingrese la respuesta ‘S’.