3

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

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 49 / 257

#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())

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 50 / 257

3.2 Asignar
Esta instrucción asigna un valor a una variable, mediante un
, esta flecha reemplaza al símbolo igual
, a diferencia de
la instrucción leer esta no se ingresa por teclado sino mediante
una instrucción en el mismo Pseudocódigo. Permite:
Operar sobre el dato obteniendo nuevo valor
Procesar los datos, obteniendo nuevo valor
Su empleo dentro de un Pseudocódigo (Algoritmo en
instrucciones) es:
Variable <Valor>
#OPERADOR ASIGNACIÓN EN PYTHON
#En Python como en muchos otros lenguajes se usa el operador:
# '='

numero = 5 #Asigna 5 a la variable

3.3 Escribir
La instrucción Escribir se emplea para poder visualizar
resultados o valores que contiene una variable, también para
mostrar mensajes, por lo general el resultad o se aprecia en la
pantalla de la computadora o impreso en papel. Permite:
Mostrar el resultado
Visualizar el resultado
Imprimir el valor resultante
Su empleo dentro de un Pseudocódigo (Algoritmo en
instrucciones) es:
Escribir <Valor Resultante>
#ESCRIBIR O MOSTRAR EN PYTHON

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 51 / 257

# 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.

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 52 / 257

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

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 53 / 257

 Leer (T) // se lee y almacena en la variable T el tiempo que
tarda el vehículo
D V * T // Se procede a calcular la distancia y asignar el
valor a la variable D
Escribir (D) //Se imprime el valor que contiene la variable D
FIN
Este segmento de Pseudocódigo se puede llevar a cualquier
lenguaje de programación para su implementación, solamente
requiere reemplazar las instrucciones por los comandos que use
el lenguaje.
Nota:
esa línea es un comentario, no interviene en ninguna de las
instrucciones.
El código en Python para resolver el Ejercicio1 es el siguiente:

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio1: CALCULAR DISTANCIA.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese la velocidad y el tiempo de la unidad móvil")
#convirtiendo entrada a Entero
V = float( input("Velocidad: ") )
T = int( input("Tiempo: ") )

#Proceso
D = V*T

#Salida
print(D)

-------------------------------------------------------
Ejercicio1: CALCULAR DISTANCIA.
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 54 / 257
-------------------------------------------------------
Ingrese la velocidad y el tiempo de la unidad móvil
Velocidad: 10
Tiempo: 20
200.0

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 N1
Segunda Nota Parcial N2
Tercera Nota Parcial N3

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:

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 55 / 257

 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 )
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 56 / 257
#Salida
print("\nSalida: ")
print(P)

-------------------------------------------------------
Ejercicio2: PROMEDIO DE 3 NOTAS.
-------------------------------------------------------
Ingrese las 3 notas del alumno N1, N2, N3
N1: 15
N2: 10
N3: 14

Salida:
13

Ejercicio 3.
Se necesita elaborar un algoritmo que solicite el
número de respuestas correctas, incorrectas y en blanco,
correspondientes a postulantes, y muestre su puntaje final
considerando que por cada respuesta correcta tendrá
3 puntos, respuestas incorrectas tendrá -1 y respuestas en
blanco tendrá 0.
Solución:
Procederemos a determinar los datos de entrada y la salida a
obtener, obsérvese.

Entrada Identificador
Puntaje Final PF
Salida
Número de Respuestas Correctas RC
Número de Respuestas Incorrectas RI
Número de Respuestas en Blanco RB

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 57 / 257

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 -1
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
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 58 / 257
 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 * -1
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

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 59 / 257

PF = PCR + PRI + PRB
#Salida
print("El puntaje total es:", PF)

-------------------------------------------------------
Ejercicio3: PUNTAJE FINAL.
-------------------------------------------------------
Ingrese número de respuestas correctas:
8
Ingrese número de respuestas incorrectas:
6
Ingrese número de respuestas en blanco:
4
El puntaje total es: 18

Ejercicio 4.
Elaborar un algoritmo que permita ingresar el número de
partidos ganados, perdidos y empatados, por ABC club en el
torneo apertura, se debe de mostrar su puntaje total,
teniendo en cuenta que por cada partido ganado obtendrá 3
puntos, empatado 1 punto y perdido 0 puntos.
Solución:
Procederemos a determinar los datos de entrada, la salida y
variables intermedias, obsérvese.

DATOS Identificador
Salida
Puntaje Total PT
Entrada
Número de Partidos Ganados PG
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 60 / 257
 Número de Partidos Empatados PE
Número de Partidos Perdidos PP
Intermedio
Puntaje de Partido s Ganado s P PG
Puntaje de Partido s Emp atado s PPE
Puntaje de Partido s E mp atado s P PP

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 -*-
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 61 / 257
#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.

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 62 / 257

 Elaborar un algoritmo que permita calcular el número de micro
discos 3 .5 necesarios para hacer una copia de seguridad, de la
información almacenada en un disco cuya capacidad se conoce.
Hay que considerar que el disco duro está lleno de información,
además expresado en gigabyte. Un micro disco tiene 1.44
megabyte y un gigabyte es igual a 1,024 megabyte.(Vinuesa,
1966)
Solución:
Procederemos a determinar los datos de entrada, la salida y
variables intermedias, obsérvese.

Entrada Identificador
Número de Gigabyte del Disco Duro GB
Número de Megabyte del Disco Duro MG

Salida
Número de Micro Disco 3.5 MD

El proceso de cálculo para determinar el número de Megabytes

(MG) dado la cantidad de Gigabytes (GB) es MG = 1024 x GB,
esto se puede determinar también si se aplica la regla de tres
simple. Para calcular el número de Micro discos de 3.5 se
procede a dividir el número de Megabytes (MD) calculados entre
1.44 que es la capacidad de un solo Micro disco, así:
MD = MG / 1.44
Determinado el proceso de conversión entonces construimos el
pseudocódigo.
INICIO
Leer (GB)
MG GB * 1,024
MD MG / 1.44
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 63 / 257
 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.44

#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.5
print("Numero de Discos necesarios: ", math.ceil(MD))

-------------------------------------------------------
Ejercicio5: NÚMERO DE MICRO DISCOS 3.5 NECESARIOS
-------------------------------------------------------
Ingrese GB:
2

SALIDA:
-------------------------------------------------------
1422.2222222222222
Número de Discos necesarios: 1423

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 64 / 257

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.

E
J
E

EJE X

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

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 65 / 257
 fórmula matemática siguiente:

Esta fórmula la podemos encontrar en los textos de matemática

básica o geometría plana. Determinado el proceso de cálculo
construimos el pseudocódigo.
INICIO
Leer (AX)
Leer (AY ) // se lee las coordenadas del punto A
Leer ( BX)
Leer ( BY ) // se lee las coordenadas del punto B
// Procedemos a realizar el cálculo matemático, el símbolo ^ es
usado para la potencia
D ((AX-BX) ^2 + (AY-BY) ^2) ^0.5
Escribir ( D )
FIN
Nota: El cálculo de la raíz cuadrada se da usando el símbolo de
potencia elevado a la 0.5.
El código del Ejercicio 6 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio6: DISTANCIA ENTRE 2 PUNTOS A y B, en 2D.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese coordenadas del Punto A: ")
AX = float(input("Ax: "))
AY = float(input("Ay: "))

print("Ingrese coordenadas del Punto B: ")

BX = float(input("Bx: "))
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 66 / 257
BY = float(input("By: "))

#Proceso
D = ( (AX-BX)**2 + (AY-BY)**2 )**0.5

#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.4142135623730951

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
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 67 / 257
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.

Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 68 / 257