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 < Dato, dato2, dato3,…>

#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
símbolo flecha “”, esta flecha reemplaza al símbolo igual
para no confundir con el operador lógico “=”, 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 resultado 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 (“ingrese la velocidad y el tiempo de la unidad
móvil”) //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: Las dos barras inclinadas “//” indica que lo que sigue en
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

Ahora se establece el proceso “Calcular Promedio” para

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 (“Ingrese las 3 notas del alumno N1, N2, N3”)
//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 (“Ingrese número de respuestas correctas”)
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 58 / 257
 Leer (RC)
Escribir (“Ingrese número de respuestas incorrectas”)
Leer (RI)
Escribir (“Ingrese número de respuestas en blanco”)
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 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 (“Ingrese número de partidos ganados”)
Leer (PG)
Escribir (“Ingrese número de partidos empatados”)
Leer (PE)
Escribir (“Ingrese número de partidos perdidos”)
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
“Algoritmo” seguida 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,
se escribe la palabra “Var” y debajo se lista todas las variables
que se usaran.
Const: Sección de declaración de constantes, se escribe la palabra
“Const” y debajo se lista todas las constantes a utilizar con su
valor correspondiente, aquí se utiliza el símbolo igual “=” en vez
de la flecha.

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

3.6 Diagramas de flujo símbolos usados
Se dijo que los diagramas de flujo son representaciones graficas
de un algoritmo, en ese sentido utiliza simbologías propias (Tabla
2.1), mismas que son necesarias conocer para poder desarrollar
las soluciones algorítmicas. Si bien es cierto en la tabla no se
indican todos los símbolos que emplea un diagrama de flujo si
están los más usados, algunos otros especiales se indicaran en los
siguientes temas.
Tabla 11
Símbolos usados frecuentemente en diagramas de flujo

Ejercicio 7.
Elaborar un algoritmo que solicite 2 números y muestre
el promedio de ambos.
Solución.
Determinamos los datos de entrada, salida y procesos.

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

 Entrada Identificador
Número 1 N1
Número 2 N2
Salida
Promedio P
Otras variables
Suma parcial S

Construimos el Pseudocódigo según la estructura que se indicó,

obsérvese que el nombre del algoritmo se ubica al principio, las
variables se declaran separadas por comas para después indicar el
tipo de dato al que pertenece ese grupo mediante los dos puntos
(:), finalmente se escribe todo el proceso que se llevara a cabo
dentro del segmento Inicio. fin. (Jordi et al., 2006)

PSEUDOCÓDIGO

ALGORITMO Promedio
Var
N1, N2, S: Entero
P: Real
Inicio
Leer (N1)
Leer (N2)
S  N1 + N2
PS/2
Escribir (P)
Fin

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

El diagrama de flujo se construye reemplazando cada comando
con su correspondiente símbolo gráfico, la construcción inicia
desde la instrucción INICIO y termina, en FIN. En el diagrama
de flujo no se declaran las variables ni constantes.(Regino, 2003)

Inicio
Leer (N1)
Leer (N2)
S  N1 + N2
PS/2
Escribir (P)
Fin

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

 Una forma reducida del
diagrama de flujo se muestra a
continuación, obsérvese que la
lectura de datos de N1 y N2 se
agrupa en un solo símbolo de
lectura, por ser operaciones
continuas y que ejecutan la
misma instrucción “leer”.
De forma similar para el caso de
asignar valores a la variable S y
P.

El código del Ejercicio 7 en Python es el siguiente:

# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio7: PROMEDIO DE DOS NÚMEROS.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese notas: ")
N1 = int( input("N1: "))
N2 = int( input("N2: "))

#Proceso
S = N1 + N2
P = S/2

#Salida
print("\nSALIDA: ")
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 72 / 257
print("-------------------------------------------------------")
print("Promedio:", P)

#Salida
-------------------------------------------------------
Ejercicio7: PROMEDIO DE DOS NÚMEROS.
-------------------------------------------------------
Ingrese notas:
N1: 12
N2: 9

SALIDA:
-------------------------------------------------------
Promedio: 10.5

Ejercicio 8.
Construya un diagrama de flujo tal que, dado como datos la base
y la altura de un rectángulo, calcule el perímetro y la superficie
de este.
Solución.
Determinamos los datos de entrada, salida y procesos.

Entrada Identificador
Base del rectángulo BASE
Altura del rectángulo ALTO

Salida
Superficie SUP
Perímetro PER

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

 La superficie (SUP) se calcula multiplicando la base (BASE) por
la altura (ALTO), en el caso del perímetro (PER) es 2 veces la
suma de la base y la altura 2 x (BASE+ALTO)

PSEUDOCODIGO

ALGORITMO Rectángulo
Var
BASE, ALTO: Real
SUP, PER: Real
Inicio
Leer (BASE, ALTO)
SUP  BASE * ALTO
PER  2*(BASE+ALTO)
Escribir (SUP, PER)
Fin

El código del Ejercicio 8 en Python es el siguiente:

# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio8: CALCULAR PERÍMETRO Y SUPERFICIE DEL RECTÁNGU
LO")
print("-------------------------------------------------------")

#Entradas
print("Ingrese Base y Alto: ")
BASE = float( input("Base: "))
ALTO = float( input("Alto: "))

#Proceso

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

SUP = BASE*ALTO
PER = 2*(BASE + ALTO)

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Superficie:", SUP)
print("Perímetro:", PER)

-------------------------------------------------------
Ejercicio8: CALCULAR PERÍMETRO Y SUPERFICIE DEL RECTÁNGULO
-------------------------------------------------------
Ingrese Base y Alto:
Base: 6
Alto: 8

SALIDA:
-------------------------------------------------------
Superficie: 48.0
Perímetro: 28.0

Ejercicio 9.
Construya un diagrama de flujo (DF) que resuelva un problema
que tiene una gasolinera. Los dispensadores de esta registran lo
que “surten” en galones, pero el precio de la gasolina está fijado
en litros. El DF debe calcular e imprimir lo que hay que cobrarle
al cliente.
Solución.

Entrada Identificador
Litros por galón (constante) LITXG
Precio por litro (constante) PRECIOXL
Cantidad surtida CONSU

Salida

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

 Total a pagar por lo surtido TOTAL

Para calcular el total a pagar por lo surtido se debe multiplicar lo

surtido (CONSU), cuyo valor está en galones, por la equivalencia
de cuantos litros hay en un galón (LITXG), así obtendremos el
total de litros que se surtió, a este resultado se le multiplica por el
precio de cada litro (PRECIOXL).
TOTAL = COSU * LITXG* PRECIOXL

PSEUDOCODIGO

ALGORITMO Gasolinera
Const
LITXG = 3.785
PRECIOXL = 4.50
Var
CONSU, TOTAL: Real
Inicio
Leer (CONSU)
TOTAL  COSU * LITXG* PRECIOXL
Escribir (TOTAL)
Fin

El código del Ejercicio 9 en Python es el siguiente:

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

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

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio9: GASOLINERA.")
print("-------------------------------------------------------")

#Constantes
LITXG = 3.785
PRECIOXL = 4.50

#Entradas
consu = float( input("Ingresar consumo: "))

#Proceso
total = consu*LITXG*PRECIOXL

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Total:", total)

-------------------------------------------------------
Ejercicio9: GASOLINERA.
-------------------------------------------------------
Ingresar consumo: 4

SALIDA:
-------------------------------------------------------
Total: 68.13

Ejercicio 10.
Construya un DF tal que, dado como datos el radio y la altura de
un cilindro, calcule e imprima el área y su volumen.
Solución.
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 77 / 257
 Entrada Identificador
Valor de PI (constante) PI
Radio RADIO
Altura del cilindro ALTO
Salida
Volumen del cilindro VOL
Área del cilindro ARE

PSEUDOCODIGO

ALGORITMO Cilindro
Const
PI = 3.1416
Var
RADIO, ALTO, VOL, AREA: Real
Inicio
Leer (RADIO, ALTO)
VOL  PI * RADIO^2 * ALTO
ARE  2*PI * RADIO (ALTO+RADIO)
Escribir (VOL, ARE)
Fin

El código del Ejercicio 10 en Python es el siguiente:

# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio10: CALCULAR ÁREA Y VOLUMEN DEL CILINDRO.")

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

print("-------------------------------------------------------")

#Constantes
PI = 3.1416

#Entradas
print("Ingrese Radio y Alto: ")
radio = float( input("Radio: "))
alto = float ( input("Alto: "))

#Proceso
vol = PI * radio**2 * alto
are = 2*PI*radio*(radio + alto)

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Volumen:", vol)
print("área:", are)

-------------------------------------------------------
Ejercicio10: CALCULAR ÁREA Y VOLUMEN DEL CILINDRO.
-------------------------------------------------------
Ingrese Radio y Alto:
Radio: 3
Alto: 4

SALIDA:
-------------------------------------------------------
Volumen: 113.0976
área: 131.9468

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

3.7 Ejercicios complementarios
1. Dado el radio de un círculo, calcule el volumen de la esfera
correspondiente.
Pseudocódigo.

Algoritmo esfera
Var
v,r: real //volumen=v y radio=r
Const
Pi=3.1416
Inicio
Escribir Ingrese el radio:
Leer (r)
v 4/3*Pi*r^3
Escribir ("El volumen de la esfera es: ",v)
Fin

Diagrama de Flujo.

Inicio

“Ingrese el radio:”

v← 4/3*Pi*r^3

"El volumen de la esfera será: ",v

Fin

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

 Nota: Si se desea imprimir un texto este se coloca entre
comillas “”, caso contrario se tomará como variable y se
imprimirá lo que contiene. Para imprimir varias cosas se separan
por comas.
El código del Complementario 1 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento1: CALCULAR VOLUMEN DE LA ESFERA.")
print("-------------------------------------------------------")

#Constantes
PI = 3.1416

#Entradas
r = float( input("Ingrese Radio: "))

#Proceso
v = 4/3 * PI * r**3

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El volumen de la esfera es:", v)

-------------------------------------------------------
Complemento1: CALCULAR VOLUMEN DE LA ESFERA.
-------------------------------------------------------
Ingrese Radio: 1

SALIDA:
-------------------------------------------------------
El volumen de la esfera es: 4.1888

2. Calcular el perímetro de un triángulo equilátero, teniendo

como dato de entrada la altura de este triángulo.

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

Pseudocódigo.

Algoritmo perimetro
Var
p,h: real //h=altura y p=perímetro
Inicio
Escribir ("Ingrese altura del triángulo:")
Leer (h)
p h/3^0.5)
Escribir ("El perímetro del triangulo será:",p)
Fin

Diagrama de Flujo.

Inicio

"Ingrese altura
del triángulo:"

p←3*(2*h/3^0.5)

"El perímetro del

triangulo será:",p

Fin

El código del Complementario 2 en Python es el siguiente:

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

# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento2: PERÍMETRO TRIANGULO EQUILÁTERO.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese altura del triángulo: ")
h = float( input())

#Proceso
p = 3*(2*h)/3**0.5

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El perímetro del triángulo será:", p)

-------------------------------------------------------
Complemento2: PERÍMETRO TRIANGULO EQUILÁTERO.
-------------------------------------------------------
Ingrese altura del triángulo:
4

SALIDA:
-------------------------------------------------------
El perímetro del triángulo será: 13.85640646055102

3. Si tengo una cantidad de soles, dar su equivalente en dólares

y después en euros. Se sabe que 1 dólar =3.25 soles y 1
euro=3.83 soles.

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

 Pseudocódigo.
Algoritmo cambio
Var
d,e,s: real //d=dólares, e=euros y s=soles
Const
eu=3.84
do=2.82
Inicio
Escribir ("Ingrese la cantidad de soles:")
Leer (s)
d s /do
e s /eu
Escribir ("En ",s," soles hay ",e " euros")
Escribir ("En ",s," soles hay ",d " dólares")
Fin

Diagrama de Flujo.

Inicio

"Ingrese la cantidad de soles:"

d s /do
e s /eu

"En ",s," soles hay ",e " euros

"En ",s," soles hay ",d " dólares"

Fin

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

 El código del Complementario 3 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento3: CAMBIOS DE SOLES a EUROS y DÓLARES")
print("-------------------------------------------------------")

#Constantes
EU = 3.84
DO = 2.28

#Entradas
print("Ingrese la cantidad de soles:")
s = float( input())

#Proceso
d = s/DO
e = s/EU

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("En", s, "soles hay ", e, "euros")
print("En", s, "soles hay ", d, "dólares")

-------------------------------------------------------
Complemento3: CAMBIOS DE SOLES a EUROS y DÓLARES
-------------------------------------------------------
Ingrese la cantidad de soles:
50

SALIDA:
-------------------------------------------------------
En 50.0 soles hay 13.020833333333334 euros
En 50.0 soles hay 21.92982456140351 dólares

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

4. Dado el tiempo en segundos y la distancia en metros de un
móvil, ingresados por teclado, calcule la velocidad
correspondiente.
Pseudocódigo.

Algoritmo velocidad
Var
v,t,d: real //v=velocidad, t=tiempo y d=distancia
Inicio
Escribir ("Ingrese el tiempo en segundos:")
Leer (t)
Escribir ("Ingrese la distancia en metros:")
Leer (d)
v d/t
Escribir ("La velocidad es: ",v, m/s
Fin
Diagrama de Flujo.
Inicio

"Ingrese el tiempo en
segundos:"

"Ingrese la distancia en
metros:"

v d/t

"La velocidad es: ",v, m/s

Fin

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

 El código del Complementario 4 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento4: CALCULAR LA VELOCIDAD DE UN MÓVIL.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese el tiempo en segundos:")
t = float( input())
print("Ingrese la distancia en metros:")
d = float( input())

#Proceso
v = d/t

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("La velocidad es:", v, "m/s")

-------------------------------------------------------
Complemento4: CALCULAR LA VELOCIDAD DE UN MÓVIL.
-------------------------------------------------------
Ingrese el tiempo en segundos:
10
Ingrese la distancia en metros:
200

SALIDA:
-------------------------------------------------------
La velocidad es: 20.0 m/s

5. Calcular el monto a pagar por un artículo si se tiene como

datos de entrada la cantidad de docenas que compra y el costo
por unidad de este artículo.

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

Pseudocódigo.

Algoritmo precio_artículo
Var
p,c: real
d:entero
Inicio
Escribir ("Ingrese costo unitario del artículo:")
Leer (c)
Escribir ("Ingrese el número de docenas:")
Leer (d)
p d*12*c
Escribir ("El precio del artículo es: ",p)
Fin

Nota: Al número de docenas “d” se multiplica por 12 para obtener

el número de unidades del artículo y poder multiplicar por el
precio unitario del artículo “c”.
Diagrama de Flujo.
Inicio

"Ingrese costo
unitario del
artículo:"

"Ingrese el
número de
docenas:"

p d*12*c

Fin

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

 El código del Complementario 5 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento5: CALCULAR MONTO A PAGAR.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese costo unitario del artículo:")
c = float( input())
print("Ingrese el número de docenas:")
d = int( input())

#Proceso
p = d*12 * c

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El precio del artículo es:", p)

-------------------------------------------------------
Complemento5: CALCULAR MONTO A PAGAR.
-------------------------------------------------------
Ingrese costo unitario del artículo:
1.5
Ingrese el número de docenas:
5

SALIDA:
-------------------------------------------------------
El precio del artículo es: 90.0

6. Realice un diagrama de flujo que convierta millas a

kilómetros. Se sabe que una milla equivale a 1.609344
kilómetros.

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

Pseudocódigo.
Algoritmo millas_kilom
Var
m,k: real //m=millas y k=kilómetros
Const
mi=1.609344
Inicio
Escribir ("Ingrese número de millas:")
Leer (m)
k m*mi
Escribir (m," millas tiene ",k," kilómetros")
Fin

Diagrama de Flujo.

Inicio

"Ingrese número
de millas:"

k←m*mi

m," millas tiene ",k,"

kilómetros"

Fin

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

 El código del Complementario 6 en Python es el siguiente:
# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento6: Millas a Kilómetros.")
print("-------------------------------------------------------")
#Constantes
MI = 1.609344

#Entradas
print("Ingrese número de millas:")
m = float( input())

#Proceso
k = m*MI

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print(m, "millas tiene", k, "kilómetros")

-------------------------------------------------------
Complemento6: Millas a Kilómetros.
-------------------------------------------------------
Ingrese número de millas:
30

SALIDA:
-------------------------------------------------------
30.0 millas tiene 48.28032 kilómetros

7. Si se conoce la longitud de dos de los lados de un triángulo (b

y c) y el ángulo entre ellos (alfa), expresado en grados
sexagesimales, la longitud del tercer lado (a) se calcula por la
fórmula:
a2 = b2 + c2 – 2bc*cos(alfa)

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

Pseudocódigo.
El ángulo “alfa” esta dado en grados sexagesimales, para el
cálculo del lado “a” hay que pasar “alfa” a radianes,
transformando se tiene “alfa*Pi/180”
Algoritmo tercer_lado
Var
b,c,alfa: real
Const
Pi=3.1416
Inicio
Escribir ("Ingrese lados del triángulo:")
Leer (b,c)
Escribir ("Ingrese el ángulo en grados sexagesimales:")
Leer (alfa)
//formula para calcular lado a con alfa transformado
a (b^2+c^2-2*b*c*cos(alfa*Pi/180))^0.5
Escribir ("El lado a es: ", a)
Fin

Diagrama de Flujo.
Inicio

"Ingrese lados del triángulo:"

b,c

"Ingrese el ángulo en grados

sexagesimales:"

alfa

a (b^2+c^2-2*b*c*cos(alfa*Pi/180))^0.5

"El lado a vale: ", a

Fin

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

 El código del Complementario 7 en Python es el siguiente:
# -*- coding: utf-8 -*-

#Librerias
import math #Necearia para fórmulas matemáticas

#Decoración: Nombre del Algoritmo

print("-------------------------------------------------------")
print("Complemento7: CALCULAR EL TERCER LADO DEL TRIANGULO")
print("-------------------------------------------------------")

#Constantes
PI = 3.1416

#Entradas
print("Ingrese lados del triángulo:")
b = float( input("Lado b: "))
c = float( input("Lado c: "))
print("Ingrese el ángulo en grados sexagesimales:")
alfa = float( input())

#Proceso
#fórmula para calcular lado 'a' con alfa transformado
a = ( b**2 + c**2 - 2*b*c * math.cos( alfa*PI/180 ) )**0.50

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El lado a es:", a)

-------------------------------------------------------
Complemento7: CALCULAR EL TERCER LADO DEL TRIANGULO
-------------------------------------------------------
Ingrese lados del triángulo:
Lado b: 4
Lado c: 3
Ingrese el ángulo en grados sexagesimales:
90

SALIDA:

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

-------------------------------------------------------
El lado a es: 5.000008815684476

8. Dado la velocidad de 2 cuerpos que se dirigen uno al

encuentro de otro determinar el tiempo de encuentro si la
distancia que los separa inicialmente es “D”.

Pseudocódigo.
va = velocidad del cuerpo “a”
vb = velocidad del cuerpo “b”
te = tiempo de encuentro
D = distancia que separa “a” de “b”
Algoritmo edad
Var
D,va,vb,te: real
Inicio
Escribir ("Ingrese las velocidades:")
Leer (va,vb)
Escribir ("Ingrese la distancia que los separa:")
Leer (D)
te← D/(va+vb)
Escribir ("Los cuerpos se encontraran en:",te," segundos")
Fin

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

 Diagrama de Flujo.

Inicio

"Ingrese las velocidades:"

va,vb

"Ingrese la distancia que los

separa:"

te← D/(va+vb)

"Los cuerpos se encontraran

en:",te," segundos"

Fin

El código del Complementario 8 en Python es el siguiente:

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

#Decoración: Nombre del Algoritmo

print("-------------------------------------------------------")
print("Complemento8: TIEMPO DE ENCUENTRO.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese las velocidades:")
va = float( input("Va: "))
vb = float( input("Vb: "))
print("Ingrese la distancia que los separa:")
Algoritmos resueltos con Python ISBN: 978-958-53018-2-5 95 / 257
D = float( input())

#Proceso
te = D/(va+vb)

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Los cuerpos se encontraran en:", te, "segundos")

-------------------------------------------------------
Complemento8: TIEMPO DE ENCUENTRO.
-------------------------------------------------------
Ingrese las velocidades:
Va: 5
Vb: 4
Ingrese la distancia que los separa:
50

SALIDA:
-------------------------------------------------------
Los cuerpos se encontrarán en: 5.555555555555555 segundos

9. Dado un ángulo en Radianes conviértalo a grados

Sexagesimales y luego a Centesimales.

Pseudocódigo.
x = ángulo en radianes
sex = ángulo en grados sexagesimales
cen = ángulo en grados centesimales

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

 Algoritmo grados
Var
x,sex,cen: real
Const
Pi=3.1416
Inicio
Escribir ("Ingrese ángulo en radianes:")
Leer (x)
sex x*180/Pi
cen x*200/Pi
Escribir ("En sexagesimales es: ",sex)
Escribir ("en centesimales es: ",cen)
Fin

Diagrama de Flujo.
Inicio

"Ingrese ángulo en
radianes:"

sex x*180/Pi
cen x*200/Pi

Escribir "En sexagesimales es: ",sex

Escribir "En centesimales es: ",cen

Fin

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

 El código del Complementario 9 en Python es el siguiente:
# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo

print("-------------------------------------------------------")
print("Complemento9: RADIANES a SEXAGESIMALES y CENTESIMALES")
print("-------------------------------------------------------")

#Constantes
PI = 3.1416

#Entradas
print("Ingrese ángulo en radianes:")
x = float( input())

sex = x*180/PI
cen = x*200/PI

#Proceso

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("En sexagesimales es:", sex)
print("En centesimales es:", cen)

-------------------------------------------------------
Complemento9: RADIANES a SEXAGESIMALES y CENTESIMALES
-------------------------------------------------------
Ingrese ángulo en radianes:
1

SALIDA:
-------------------------------------------------------
En sexagesimales es: 57.29564553093965
En centesimales es: 63.66182836771072

10. Determine la distancia entre dos puntos en el espacio.

(x1,y1, z1) y (x2, y2, z2)

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

Pseudocódigo.

La fórmula para hallar la distancia entre 2 puntos en el

espacio es

Punto 1: (x1, y1, z1) Punto 2: (x2, y2, z2)

dis = distancia entre puntos

Algoritmo distancia
Var
dis,x1,y1,z1,x2,y2,z2: real
Inicio
Escribir ("Ingrese valores de los puntos x1 ,y1 y z1")
Leer (x1,y1,z1)
Escribir ("Ingrese valores de los puntos x2,y2 y z2")
Leer (x2, y2, z2)
dis ((z2-z1)^2+(y2-y1)^2+(x2-x1)^2)^0.5
Escribir ("La distancia es: ",dis)
Fin

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

 Diagrama de Flujo:

Inicio

"Ingrese valores de
los puntos x1 y x2:"

x1,x2

"Ingrese valores de
los puntos y1 y y2:"

y1,y2

dis← ((y2-y1)+(x2-x1))^0.5

La distancia será: ",di

Fin

El código del Complementario 10 en Python es el siguiente:

# -*- coding: utf-8 -*-
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Complemento10: DISTANCIA DE DOS PUNTOS en 3D.")
print("-------------------------------------------------------")

#Entradas
print("Ingrese valores del punto A(x1, y1 y z1): ")
x1 = float( input("x1: "))
y1 = float( input("y1: "))
z1 = float( input("z1: "))

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

print("Ingrese valores del punto B(x2, y2 y z2): ")
x2 = float( input("x2: "))
y2 = float( input("y2: "))
z2 = float( input("z2: "))

#Proceso
dis = ( (z2-z1)**2 + (y2-y1)**2 + (x2-x1)**2 )**0.5

#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("La distancia es:", dis)

-------------------------------------------------------
Complemento10: DISTANCIA DE DOS PUNTOS en 3D.
-------------------------------------------------------
Ingrese valores del punto A(x1, y1 y z1):
x1: 0
y1: 0
z1: 0
Ingrese valores del punto B(x2, y2 y z2):
x2: 1
y2: 1
z2: 0
SALIDA:
-------------------------------------------------------
La distancia es: 1.4142135623730951

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