¡Descarga Diagramas de flujo, algoritmos y códigos en Python y más Esquemas y mapas conceptuales en PDF de Programación Informática solo en Docsity!
3. Instrucciones Básicas en un Algoritmo
En este capítulo se busca afianzar el criterio de análisis y diseño de
algoritmos, para ello nos valemos de herramientas como los
Pseudocódigos, describimos sus partes y usos.
Así mismo emplearemos diagramas de flujo, como una representación
equivalente a un Pseudocódigo, esta práctica nos llevara a desarrollar
mejor el aspecto de análisis y diseño de un algoritmo.
A continuación, se describe las instrucciones básicas que se utilizaran
para construir algoritmos. (Cairó et al., 1993)
3.1 Leer
La instrucción de Lectura viene a ser aquella mediante la cual
se ingresa uno o más datos por medio del teclado que luego
internamente será guarda en una variable, este valor se
requerirá para realizar cálculos y hallar la solución a un
algoritmo. Permite:
Solicitar un dato inicial
Requerir un dato de entrada
Su declaración dentro de un Pseudocódigo (Algoritmo en
instrucciones) es:
Leer < Dat
#LEER DATOS EN PYTHON
#Leer datos de teclado es facil gracias a la función: input() de python #El cual nos devolverá una cadena de texto #El cual debemos capturar en alguna variable texto = input() #Además input puede tener un parámetro indicando al usuario #que debe ingresar mes = input("Ingrese mes: ")
CASTING (Conversiones de tipo de dato)
como la función input() retorna un texto
si nos otro queremos que nos devuelva un entero
debemos hacer una covnersión usando la función int()
numero = input() #numero es string entero = int(numero) #O la simplificada entero = int( input())
Si en otro caso queremos trabajar con decimales
Se debe usar la función float()
numero = input() #numero es string decimal = int(numero) #O de la forma directa decimal = float( input())
Para mostrar resultados por la pantalla tenemos la función
print()
numero = 5 print(numero) #Muestra el valor de 'numero' por pantalla dia = 10 mes = "Septiembre" anio = " 1990 " #Es recomendable usar solo caracteres Ingleses para evitar error print(dia, mes, anio) #Salida: 10 Septiembre 1990 #Note que los espacios fueron agregados por la función print #format() #Otra manera interesante de imprimir es utilizando la función format()
"cadena de texto".formta()
print("dia: {} mes: {} anio: {}".format(dia, mes, anio)) #Salida: dia: 10 mes: Septiembre anio: 1990 #Se sugiere al estudiante profundizar más.
Nota:
Para no tener problemas con los caracteres especiales
del lenguaje Español como pueden ser las tildes y la eñe
es recomendable poner la siguiente sentencia al inicio de
cada programa como comentario.
-- coding: utf-8 --
A continuación, desarrollaremos nuestros primeros algoritmos,
para ello emplearemos las tres instrucciones descritas: Leer,
asignar y escribir.
3.4 Ejercicios del tema
Ejercicio 1.
Se desea calcular la distancia recorrida (m) por un móvil que
tiene velocidad constante (m/s) durante un tiempo t (s),
considerar que es un MRU (Movimiento Rectilíneo
Uniforme).
Solución:
Primero se procede a determinar los datos de entrada y la salida
a obtener, obsérvese.
Entrada Identificador
Velocidad Constante (m/s) V
Tiempo (s) T
Salida
Distancia Recorrida (m) D
Ahora se establece el proceso requerido para obtener el
resultado pedido:
Se sabe que el cálculo de la velocidad en MRU es por
formula:
Despejando la distancia se tiene:
Una vez determinado los tres elementos de un algoritmo
(entrada, proceso, salida) procedemos a construir la parte
medular del Pseudocódigo. (Quetglás, 2003)
INICIO
Escribir
//muestra el mensaje en pantalla
Leer (V) // se lee y almacena en la variable V la velocidad del
vehículo
Ingrese la velocidad y el tiempo de la unidad móvil Velocidad: 10 Tiempo: 20
Ejercicio 2.
Se necesita obtener el promedio simple de un estudiante a partir
de sus tres notas parciales N1, N2 y N3.
Solución:
Procederemos a determinar los datos de entrada y la salida a
obtener, obsérvese.
Entrada Identificador
Promedio P
Salida
Primera Nota Parcial N
Segunda Nota Parcial N
Tercera Nota Parcial N
obtener el resultado pedido, como ustedes saben el promedio
simple de cualquier dato, se halla, sumando todos los datos y
dividiendo entre el número de datos sumados, por ejemplo, les
vamos a asignar valores a los identificadores.
N1 = 14
N2 = 13
N3 = 15
P = (14 + 13 + 15) / 3
Entonces P (Promedio) tomaría el valor de 14
Por lo tanto, el cálculo del promedio es:
Una vez determinado los tres elementos de un algoritmo
(entrada, proceso, salida) procedemos a construir la parte
medular del Pseudocódigo. Siempre colocar la palabra INICIO
para comenzar y FIN al terminar.
INICIO
Escribir 1,
//muestra el mensaje en pantalla
Leer (N1) // se lee y almacena en la variable N1 la nota
número uno del alumno
Leer (N2) // se lee y almacena en la variable N2 la nota
número dos del alumno
Leer (N3) // se lee y almacena en la variable N3 la nota
número tres del alumno
P (N1 + N2 + N3) / 3 // Se procede a calcular el promedio
y asignar el valor a la variable P
Escribir (P) //Se imprime el valor que contiene la variable P:
promedio obtenido
FIN
El código del Ejercicio 2 en Python es el siguiente:
-- coding: utf-8 --
#Decoración: Nombre del Algoritmo print("-------------------------------------------------------") print("Ejercicio2: PROMEDIO DE 3 NOTAS.") print("-------------------------------------------------------") #Entradas print("Ingrese las 3 notas del alumno N1 , N2, N3") N1 = int( input("N1: ")) N2 = int( input("N2: ")) N3 = int( input("N3: ")) #Proceso P = int( (N1+N2+N3)/ 3 )
Otras variables intermedias para usar:
Puntaje de Respuestas Correctas PRC
Puntaje de Respuestas Incorrectas PRI
Puntaje de Respuestas en blanco PRB
Se ha considerado variables intermedias al momento de
determinar las entradas y salidas, debido a que durante la
ejecución del pseudocódigo habrá necesidad de almacenar
información adicional para los cálculos, esta es una situación
perfectamente normal, uno puede usar variables adicionales si
así lo cree conveniente. (Introducción a la Programación en
Java., 2007)
Ahora se establece el proceso de cálculo para obtener el
resultado pedido.
Para calcular el puntaje de respuestas correctas (PRC)
debemos multiplicar el número de respuestas correctas (RC)
por el valor de cada respuesta correcta (3), entonces:
PRC = RC x 3
Para el puntaje de respuestas incorrectas (PRI):
PRI = RI x -
El puntaje de respuestas en blanco es:
PRB = RB x 0
Finalmente, la suma de estos tres será el puntaje final (PF).
PF = PRC + PRI + PRB
Determinado los tres elementos de un algoritmo (entrada,
proceso, salida) procedemos a construir la parte medular del
Pseudocódigo.
INICIO
Escribir
Leer (RC)
Escribir
Leer (RI)
Escribir
Leer (RB)
// Procedemos a realizar el cálculo de cada grupo de respuestas
PRC RC * 3 //No olvidar que el asterisco es el símbolo
de multiplicación
PRI RI * -
PRB RB * 0
PF PRC + PRI + PRB
Escribir (PF) //Se imprime el puntaje final
FIN
El código del Ejercicio 3 en Python es el siguiente:
-- coding: utf-8 --
#Decoración: Nombre del Algoritmo print("-------------------------------------------------------") print("Ejercicio3: PUNTAJE FINAL.") print("-------------------------------------------------------") #Entradas print("Ingrese número de respuestas correctas: ") RC = int( input()) print("Ingrese número de respuestas incorrectas: ") RI = int( input()) print("Ingrese número de respuestas en blanco: ") RB = int( input()) #Proceso PCR = RC* 3 PRI = RI- 1 PRB = RB 0
Número de Partidos Empatados PE
Número de Partidos Perdidos PP
Intermedio
Puntaje de Partidos Ganados PPG
Puntaje de Partidos Empatados PPE
Puntaje de Partidos Empatados PPP
El proceso de cálculo para obtener el resultado pedido es
similar al anterior (Ejercicio 3), procedemos a construir el
pseudocódigo.
INICIO
Escribir
Leer (PG)
Escribir
Leer (PE)
Escribir
Leer (PP)
// Procedemos a realizar el cálculo de cada grupo de partidos
PPG PG * 3
PPE PE * 1
PPP PP * 0
// Calculamos el puntaje total del equipo ABC club
PT PPG + PPE + PPP
Escribir (PT) //Se imprime el puntaje final
FIN
El código del Ejercicio 4 en Python es el siguiente:
-- coding: utf-8 --
#Decoración: Nombre del Algoritmo print("-------------------------------------------------------") print("Ejercicio4: PUNTAJE TOTAL DE PARTIDOS.") print("-------------------------------------------------------") #Entradas print("Ingrese número de partidos ganados") PG = int( input()) print("Ingrese número de partidos empatados") PE = int( input()) print("Ingrese número de partidos perdidos") PP = int( input()) #Proceso PPG = PG* 3 PPE = PE* 1 PPP = PP* 0 PF = PPG + PPE + PPP #Salida print("\nSALIDA: ") print("-------------------------------------------------------") print("Puntaje Final: ", PF)
Ejercicio4: PUNTAJE TOTAL DE PARTIDOS.
Ingrese número de partidos ganados 5 Ingrese número de partidos empatados 3 Ingrese número de partidos perdidos 4 SALIDA:
Puntaje Final: 18
Ejercicio 5.
Escribir (MD)
FIN
El código del Ejercicio 5 en Python es el siguiente:
-- coding: utf-8 --
import math #librería necesaria para usar funciones Matemáticas #en este caso math.ceil(), que redondea un numero al Entero superior #Decoración: Nombre del Algoritmo print("-------------------------------------------------------") print("Ejercicio5: NÚMERO DE MICRO DISCOS 3.5 NECESARIOS") print("-------------------------------------------------------") #Entradas print("Ingrese GB: ") GB = float( input()) #Proceso MG = GB* 1024 MD = MG/1. #Salida print("\nSALIDA: ") print("-------------------------------------------------------") print(MD) #En caso de Decimal Aproximar al siguiente entero #Ya que la parte decimal debe ser almacenada en otro DISCO 3. print("Numero de Discos necesarios: ", math.ceil(MD))
Ejercicio5: NÚMERO DE MICRO DISCOS 3.5 NECESARIOS
Ingrese GB: 2 SALIDA:
Número de Discos necesarios: 1423
Ejercicio 6.
Se tiene los puntos A y B en el cuadrante positivo
del plano cartesiano, elabore el algoritmo que permita obtener
la distancia entre A y B.
Solución:
Un punto en el plano tiene dos coordenadas (X ,Y), entonces el
punto A tendrá sus coordenadas (AX, AY) y el punto B de
manera similar (BX, BY), luego se tiene los siguientes datos:
Entrada Identificador
Coordenada X de A AX
Coordenada Y de A AY
Coordenada X de B BX
Coordenada Y de B BY
Salida
Distancia entre el punto A y B D
Para determinar la distancia entre dos puntos, empleamos la
E
J
E
Y
EJE X
BY = float(input("By: ")) #Proceso D = ( (AX-BX)** 2 + (AY-BY)** 2 )**0. #Salida print("\nSALIDA: ") print("-------------------------------------------------------") print("Resultado:", D) Ingrese coordenadas del Punto A: Ax: 0 Ay: 0 Ingrese coordenadas del Punto B: Bx: 1 By: 1 SALIDA:
Resultado: 1.
3.5 Pseudocódigo y sus partes
El pseudocódigo
utiliza una serie de
palabras clave o
palabras especiales
que va indicando lo
que significa en el
algoritmo según el
dato ingresado.
Algoritmo: Esta parte
es donde se coloca el
nombre del algoritmo,
se escribe la palabra
a
continuación del
nombre del algoritmo. El nombre debe hacer alusión a lo que el
algoritmo realiza.
Inicio y Fin: En este segmento es donde se colocan las
instrucciones que va a ejecutar el algoritmo. Similar a lo que
hicimos en los ejercicios anteriores.
Var: Aquí se declaran las variables que se usaran en el algoritmo,
odas las variables
que se usaran.
Const: Sección de declaración de constantes, se escribe la palabra
de la flecha.
