UNIVERSIDAD DEL VALLE

ALGORITMIA Y PROGRAMACIÓN

INFORME DE LABORATORIO #4

JAVIER SANTIAGO GÓMEZ GALINDO-2023396

JULIAN FELIPE ESPINOSA HERNANDEZ-2029638

DANIELA ARBOLEDA RODRÍGUEZ - 2025314

BREYNER LEDESMA SACHICA- 2024586

ERIT GARCIA BARRERO - 2023640

SANTIAGO DE CALI (VALLE DEL CAUCA)

2021
EJERCICIO 1
La Universidad te contratará para desarrollar un programa que solicite en pantalla las notas
finales que tres alumnos obtuvieron en tres materias distintas y las almacene en un arreglo
bidimensional de tamaño 3x3, en el que las filas corresponden a las materias y las
columnas representan a los alumnos. El programa deberá imprimir el arreglo bidimensional
generado (una tabla) y reportar tanto el promedio de notas de cada estudiante como el
promedio de notas por materia. Para lograr lo anterior, el programa deberá basarse en las
siguientes indicaciones (siempre que sea posible, usar estructuras iterativas):
1. Implementar una función que se encargue de la captura de datos que el usuario ingresa y
retorna el arreglo bidimensional de tamaño 3x3.
2. Implementar un procedimiento que tome la matriz 3x3 generada por la función del
numeral 1 e imprima su contenido en un formato similar al de la Figura 1 (ejecución del
código). Sugerencia: para el pseudocódigo use simplemente la función “imprimir”, para el
código utilice los tabuladores “\t.
3. Implementar un procedimiento que tome el arreglo bidimensional 3x3 que resulta de la
función del numeral 1, calcule el promedio de notas de cada estudiante e imprima en
pantalla dichos valores.
4. Implementar un procedimiento que tome el arreglo bidimensional 3x3 que resulta de la
función del numeral 1, calcule el promedio de notas por materia e imprima en pantalla
dichos valores.

1.1 Entradas y salidas:

Entradas: Notas de los estudiantes 1, 2 y 3 con respecto a las materias 1, 2 y 3.

Salidas: Promedio de notas por cada estudiante y Promedio de notas por cada materia.

1.2 proceso

print ("Bienvenidos al sistema de ingreso de notas." "\n")

materia1estudiante1= float(input("ingrese nota de la materia 1 del estudiante 1:"))

materia1estudiante2= float(input("ingrese nota de la materia 1 del estudiante 2:"))

materia1estudiante3= float(input("ingrese nota de la materia 1 del estudiante 3:"))

materia2estudiante1= float(input("ingrese nota de la materia 2 del estudiante 1:"))

materia2estudiante2= float(input("ingrese nota de la materia 2 del estudiante 2:"))

materia2estudiante3= float(input("ingrese nota de la materia 2 del estudiante 3:"))

materia3estudiante1= float(input("ingrese nota de la materia 3 del estudiante 1:"))

materia3estudiante2= float(input("ingrese nota de la materia 3 del estudiante 2:"))

materia3estudiante3= float(input("ingrese nota de la materia 3 del estudiante 3:"))

matriz= [["---","Est. 1","Est. 2","Est,3"],

["Mat. 1",materia1estudiante1,materia1estudiante2,materia1estudiante3],

["Mat. 2",materia2estudiante1,materia2estudiante2,materia2estudiante3],

["Mat. 3",materia3estudiante1,materia3estudiante2,materia3estudiante3]]

b=""

print ("\n")

for i in range(4):

for j in range (4):

#print(matriz[i][j])

b += str(matriz[i][j]) + '\t'

print (b)

b= " "

print ("\n")

su=[0,0,0]

prom=[0,0,0]

su2=[0,0,0]

prom2=[0,0,0]

for j in range(3):

for n in range(3):
 su[j]=su[j] + matriz[n+1][j+1]

su2[j]=su2[j]+ matriz[j+1][n+1]

prom[j]=su[j]/3

prom2[j]=su2[j]/3

promedioEstudiante=[0,0,0]

promedioMateria=[0,0,0]

for k in range(3):

promedioEstudiante[k]=round(prom[k],1)

resultadoEstudiante1 =print("Promedio de estudiante",k+1,"=",promedioEstudiante[k])

print("\n")

for k in range(3):

promedioMateria[k]=round(prom2[k],1)

resultadoMateria1 =print("Promedio de Materia",k+1,"=",promedioMateria[k])

2. Algoritmo en python
3. prueba de escritorio
EJERCICIO 2

El producto de una matriz A de n filas y n columnas por un vector x de tamaño n,

denotado como Ax, siendo n un entero positivo, resulta en un vector b también de
tamaño

n cuya i-ésima componente resulta del producto punto entre la i-ésima fila de la
matriz A y el vector x, esto es,

bi=Ai1 x1+Ai2 x2+...+A❑ xn

siendo Ai1,Ai2,...,A❑ las componentes de la i-ésima fila de la matriz A y x1,x2,...,xn las

componentes del vector x.

Se requiere desarrollar un algoritmo que solicite al usuario el valor de n y calcule el producto

antes

descrito entre la matriz A y el vector x, para esto considere lo siguiente:

1. Implemente una función que tome como entrada un número entero n y retorne una
matriz (arreglo bidimensional) aleatoria, de tamaño n por n, cuyas componentes
sean números enteros entre 0 y 10.
2. Implemente una función que tome como entrada un número entero n y retorne un
vector (arreglo) aleatorio, de tamaño n, cuyas componentes sean números enteros
entre 0 y 10.
3. Implemente una función que tome como entradas una matriz de de tamaño n por n y
un vector de tamaño n y retorne el producto entre dicha matriz y dicho vector.
4. Imprima en pantalla la matriz aleatoria generada, el vector aleatorio generado y el
vector resultante de la multiplicación.

1.1 Entradas y salidas:

Entradas: El número de filas y columnas, dado que es una matriz cuadrada, se pide al
usuario ingresar el valor de n; también n se utiliza para determinar cuántos componentes
contiene el vector x

Salidas: Matriz A, Vector x, resultado de Ax=b

1.2 proceso

import numpy as np

from random import randint

n=int(input('digite el valor de n :'))

random_matrix=np.random.randint(10, size=(n,n))

vector_x=np.random.randint(10, size=(n))

resultado= np.dot(random_matrix, vector_x)

print('*****************************')

print('Calculando Ax=b')

print('*****************************')

print('Matriz A :')

print(random_matrix)

print('*****************************')

print('Vector x :')

print(vector_x)

print('*****************************')

print('resultado b :')

print(resultado)

2. Algoritmo en python
3. prueba de escritorio

n=7
Matriz A

0 6 5 2 5 0 8

8 9 1 2 3 4 7

6 3 7 0 8 1 6

3 0 7 4 1 4 8

7 8 7 5 1 3 0

5 0 1 5 3 8 1

3 1 5 7 1 5 1

n=7
Vector x

9 4 4 6 5 7 6

Resultado Ax=b

b=
 129 209 177 160 179 156 139

EJERCICIO 3

a. Escribir un programa que calcule la frecuencia de aparición de las vocales de un texto

proporcionado por el usuario. Esta solución se debe presentar en forma de histograma.

Ejemplo: Texto introducido por el usuario:

"El control de la información en la pantalla suele ser uno de los caballos de batalla de todos
los programadores."

Salida en pantalla:

Letra Frecuencia Histograma

a 11 ***********

e 9 *********

i 2 **

o 12 ************

u 0

Debe leer tanto mayúsculas como minúsculas.

b. En este otro punto se debe escoger todo el texto introducido por el usuario y organizar
todas las letras en orden alfabético. Desde a hasta la x.

En el ejemplo anterior se muestra en pantalla:

aaaaaaaaaaabcccddddeeeeeeeeef......

y así sucesivamente hasta acabar en descomponer todo el texto en sus letras y cantidad de
letras en orden alfabético.

1.1 Entradas y salidas

Entradas: Algún texto o frase.

Salidas: Fila correspondiente al título de cada dato a imprimir seguidamente de las letras
que se encuentran en el texto ingresado, la cantidades de veces y representación en forma
de histograma con el caracter “*”

1.2 Proceso

1. Solicitamos ingresar algún texto o frase que desee.

2. Utilizando la función print imprimimos en pantalla la fila del nombre de cada
columna.
3. Declaramos una función contar_vocales, luego de ingresado el texto, convertimos
toda esa cadena en una cadenas de letra minúsculas que nos permita leer en caso
tal letras mayúsculas que puedan ingresar esto con la instrucción .lower().
4. Utilizando la instrucción for declaramos i para que tome distintos valores, luego con
la instrucción .count() sabemos el número de veces que un elemento(letra) está en
una lista.
5. Imprimimos la columna de las vocales cantidad de veces en el texto y seguido del
histograma que simplemente multiplicamos el carácter “*” por la cantidad de veces.
6. Con .join() y .sorted() logramos reunir los datos ingresados, guardarlos, separarlos
y ordenarlos de tal manera que quede como se requiere.

2. Algoritmo en pseudocodigo

Inicio
 Preguntar - Frase o texto

Mostrar - columna de letra, frecuencia e histogramaç

Tomar valores i como a,e,i,o,u

Contar valores i ingresados

Mostrar - valores i, frecuencia de aparición y formato de histograma

Agrupar y ordenar (frase) alfabéticamente todas las letras ingresadas

Mostrar letra ordenadas alfabéticamente

Fin

3. Prueba de escritorio y prueba de ejecución

Ingrese un texto: Una vecina mia que tenia un gato

Letra Frecuencia Histograma
a 5 *****
e 3 ***
i 3 ***
o 1 *
u 3 ***

aaaaaceeegiiimnnnnoqttuuuv

EJERCICIO 4
La división de promoción y prevención de desastres del Suroccidente Colombiano desea
llevar un control sobre la cantidad de lluvias que se han producido en los 6 primeros meses
del año en 5 de sus departamentos (Valle, Cauca, Nariño, Putumayo y Chocó). Los
nombres de los departamentos se encuentran almacenados en un arreglo de String de
tamaño 5, y la información sobre las precipitaciones se encuentra almacenada en una
matriz de tipo double de tamaño 5x6 donde cada fila representa un departamento, y cada
columna un mes del año.

Tabla 1. Lluvia por departamento

Se requiere un programa en Python para simular la cantidad de lluvias, el programa

debe cumplir los siguientes requerimientos. Realizar una función que
automáticamente llene la matriz de lluvias con números aleatorios decimales entre
0.0 y 100. Cada posición de la matriz representa la cantidad de lluvias en
centímetros cúbicos en un departamento en determinado mes. Para redondear
números en Python se debe importar la librería random. El siguiente código genera
números aleatorios.

1. Realizar una función que imprima los datos de las lluvias como se muestra en la
tabla 1. Realizar una función que pida un mes y luego muestre el promedio de
lluvias en los 5 departamentos en ese mes.

2. Realizar una función que pida un departamento y muestre el promedio de lluvias

de ese departamento en ese semestre.
El programa debe presentar al usuario un menú como el que se muestra a
continuación:

1.1 Entradas y salidas:

Entradas: Mes y semestre que el usuario desea conocer el promedio

Salidas: Promedio de lluvias en mes y semestre

1.2 proceso

import random

Caucaenero=5.2

Caucafebrero=10.4

Caucamarzo=2.4

Caucaabril=99.0

Caucamayo=5.0

Caucajunio=2.5

Chocóenero=4.2

Chocófebrero=10.1

Chocómarzo=3.4

Chocóabril=9.0

Chocómayo=45.0

Chocójunio=12.5

Nariñoenero=3.2

Nariñofebrero=7.4
Nariñomarzo=5.4

Nariñoabril=9.0

Nariñomayo=4.0

Nariñojunio=1.5

Putumayoenero=5.5

Putumayofebrero=9.4

Putumayomarzo=23.1

Putumayoabril=12.0

Putumayomayo=45.3

Putumayojunio=2.5

Valleenero=5.9

Vallefebrero=5.4

Vallemarzo=3.2

Valleabril=5.0

Vallemayo=45.5

Vallejunio=2.5

Promedioenero=((Caucaenero+Chocóenero+Nariñoenero+Putumayoenero+Valleenero)/5)

Promediofebrero=((Caucafebrero+Chocófebrero+Nariñofebrero+Putumayofebrero+Vallefebr
ero)/5)

Promediomarzo=((Caucamarzo+Chocómarzo+Nariñomarzo+Putumayomarzo+Vallemarzo)/
5)

Promedioabril=((Caucaabril+Chocóabril+Nariñoabril+Putumayoabril+Valleabril)/5)

Promediomayo=((Caucamayo+Chocómayo+Nariñomayo+Putumayomayo+Vallemayo)/5)

Promediojunio=((Caucajunio+Chocójunio+Nariñojunio+Putumayojunio+Vallejunio)/5)

PromedioCauca=((Caucaenero+Caucafebrero+Caucamarzo+Caucaabril+Caucamayo+Cauc
ajunio)/6)
PromedioChocó=((Chocóenero+Chocófebrero+Chocómarzo+Chocóabril+Chocómayo+Choc
ójunio)/6)

PromedioNariño=((Nariñoenero+Nariñofebrero+Nariñomarzo+Nariñoabril+Nariñomayo+Nari
ñojunio)/6)

PromedioPutumayo=((Putumayoenero+Putumayofebrero+Putumayomarzo+Putumayoabril+
Putumayomayo+Putumayojunio)/6)

PromedioValle=((Valleenero+Vallefebrero+Vallemarzo+Valleabril+Vallemayo+Vallejunio)/6)

#Matriz Tabla 1

Matriz=[[" "," ","Enero","Febrero","Marzo","Abril","Mayo","Junio"],

["Cauca"," ",5.2,10.4,2.4,99.0,5.0,2.5],

["Chocó"," ",4.2,10.1,3.4,9.0,45.0,12.5],

["Nariño"," ",3.2,7.4,5.4,9.0,4.0,1.5],

["Putumayo",5.5,9.4,23.1,12.0,45.3,2.5," "],

["Valle"," ",5.9,5.4,3.2,5.0,45.5,2.5]]

b= " "

print("\n")

for i in range (6):

for j in range (8):

b+=str(Matriz[i][j]) + '\t'

print(b)

b=" "

print("\n")

#Solicitud del mes del usuario

Mes = input("Digite el mes:")

if Mes == "Enero" :

print("El promedio de lluvias en el mes de Enero es: ",Promedioenero, "centimetros

cubicos")

if Mes == "Febrero" :

print("El promedio de lluvias en el mes de Febrero es: ",Promediofebrero, "centimetros

cubicos")

if Mes == "Marzo" :

print("El promedio de lluvias en el mes de Marzo es: ",Promediomarzo, "centimetros

cubicos")

if Mes == "Abril" :

print("El promedio de lluvias en el mes de Abril es: ",Promedioabril, "centimetros cubicos")

if Mes == "Mayo" :

print("El promedio de lluvias en el mes de Mayo es: ",Promediomayo, "centimetros

cubicos")

if Mes == "Junio" :

print("El promedio de lluvias en el mes de Junio es: ",Promediojunio, "centimetros

cubicos")

#Solicitud del departamento del usuario

Semestre=input("Digite el nombre del Departamento:")

if Semestre == "Cauca":

print("El promedio de lluvias en el semestre del departamento del Cauca es:

",PromedioCauca, "centimetros cubicos")

elif Semestre == "Chocó" :

print("El promedio de lluvias en el semestre del departamento del Chocó es:

",PromedioChocó, "centimetros cubicos")

elif Semestre == "Nariño" :

print("El promedio de lluvias en el semestre del departamento del Nariño es:

",PromedioNariño, "centimetros cubicos")
elif Semestre == "Putumayo" :

print("El promedio de lluvias en el semestre del departamento del Putumayo es:

",PromedioPutumayo, "centimetros cubicos")

elif Semestre == "Valle" :

print("El promedio de lluvias en el semestre del departamento del Valle es:

",PromedioValle, "centimetros cubicos")

#Solicitud del Usuario

print("\n")

print("Seleccione una opción:\n1: Llenar Matriz de lluvias\n2: Imprimir Matriz\n3: Promedio

de Lluvias por departamento\n4: Promedio de lluvias por mes\n5: Salir")

2. Algoritmo en python
3. Prueba de escritorio

Enero Febrero Marzo Abril Mayo Junio

Cauca 5.2 10.4 2.4 99.0 5.0 2.5

Chocó 4.2 10.1 3.4 9.0 45.0 12.5

Nariño 3.2 7.4 5.4 9.0 4.0 1.5

Putumayo 5.5 9.4 23.1 12.0 45.3 2.5

Valle 5.9 5.4 3.2 5.0 45.5 2.5

Mes Promedio de lluvias Departamento Promedio de lluvia en el

semestre del departamento

Febrero 8.54 Valle 11.25

EJERCICIO 5
El dueño de un negocio lo contrata a usted para publicar anuncios programados en python
en un tablero electrónico con dimensiones de 5 cuadros de alto por 24 o 30 cuadros de
ancho. La idea del algoritmo es que le solicite al cliente uno o varios mensajes para publicar
en el tablero y que estos mensajes se repitan cuantas veces quiera el usuario. Cada letra
debe tener una dimensión de 5 cuadros de alto por 4 de ancho (la altura se conserva, el que
puede variar es el ancho de la letra para hacer una letra bonita y uniforme) y un espacio
entre letras de un cuadro, y entre palabras de dos, y al separar mensajes se usará un signo
( /) o un (-) como se muestra en la figura da letra R.

1.1 entradas y salidas

Entradas: Primero se le solicita al usuario que digite la cantidad de veces que quiere que se
repita el mensaje en el tablero electrónico, después simplemente se le pide al usuario que
presione la tecla enter cuando este listo para desplegar el mensaje.

Salidas: Texto en matriz

1.2 proceso

import os
os.system('cls')
msj=str(input("Escriba texto: "))
Rep=int(input("Escriba la cantidad de veces que desea repetir el mensaje: "))
Y=[]

⬛⬛⬛ ⬛⬜⬛ ⬛⬛⬛ ⬛⬜⬛ ⬛⬜⬛

#Generador de letras del abecedario en arreglo matricial.

⬛⬜⬜ ⬛⬜⬛ ⬛⬛⬜ ⬛⬜⬛ ⬛⬛⬜

A=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬜ ⬛⬜⬜ ⬛⬜⬜ ⬛⬛⬛

B=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬜ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬛⬜

C=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬜ ⬛⬛⬜ ⬛⬜⬜ ⬛⬛⬛

D=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬜ ⬛⬛⬜ ⬛⬜⬜ ⬛⬜⬜

E=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬜ ⬛⬛⬛ ⬛⬜⬛ ⬛⬛⬛

F=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬛ ⬛⬜⬛ ⬛⬛⬛ ⬛⬜⬛ ⬛⬜⬛

G=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬜⬛⬜ ⬜⬛⬜ ⬜⬛⬜ ⬛⬛⬛

H=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬜⬜⬛ ⬜⬜⬛ ⬛⬜⬛ ⬛⬛⬛

I=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬛ ⬛⬜⬛ ⬛⬛⬜ ⬛⬜⬛ ⬛⬜⬛

J=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬜ ⬛⬜⬜ ⬛⬜⬜ ⬛⬜⬜ ⬛⬛⬛

K=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬛ ⬛⬛⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛

L=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛

M=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬜⬜⬜ ⬛⬛⬛ ⬛⬜⬛ ⬛⬜⬛

N=[[" "],[" "],[" "],[" "],[" "]]

⬜⬛⬜ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬜⬛⬜

Ñ=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬛ ⬛⬛⬜ ⬛⬜⬜ ⬛⬜⬜

O=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬛ ⬜⬛⬛ ⬜⬜⬛ ⬜⬜⬛

P=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬜ ⬛⬜⬛ ⬛⬛⬜ ⬛⬜⬛ ⬛⬜⬛

Q=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬛⬜⬜ ⬛⬛⬛ ⬜⬜⬛ ⬛⬛⬛

R=[[" "],[" "],[" "],[" "],[" "]]

⬛⬛⬛ ⬜⬛⬜ ⬜⬛⬜ ⬜⬛⬜ ⬜⬛⬜

S=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬛⬛

T=[[" "],[" "],[" "],[" "],[" "]]

⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬛⬜⬛ ⬜⬛⬜

U=[[" "],[" "],[" "],[" "],[" "]]
V=[[" "],[" "],[" "],[" "],[" "]]
 ⬛⬜⬜"],["⬛⬜⬜"],["⬛⬜⬛"],["⬛⬜⬛"],["⬜⬛⬜"],["⬜⬜⬛"],["⬜⬜⬛"],["⬛
⬜⬛"],["⬛⬜⬛"],["⬜⬛⬜"]]
W=[["

X=[["⬛⬜⬛"],["⬛⬜⬛"],["⬜⬛⬜"],["⬛⬜⬛"],["⬛⬜⬛"]]
YL=[["⬛⬜⬛"],["⬛⬜⬛"],["⬜⬛⬜"],["⬜⬛⬜"],["⬜⬛⬜"]]
Z=[["⬛⬛⬛"],["⬜⬜⬛"],["⬜⬛⬜"],["⬛⬜⬜"],["⬛⬛⬛"]]
CB=[["⬜⬜⬜"],["⬜⬜⬜"],["⬛⬛⬛"],["⬜⬜⬜"],["⬜⬜⬜"]]
ES=[["⬜⬜⬜"],["⬜⬜⬜"],["⬜⬜⬜"],["⬜⬜⬜"],["⬜⬜⬜"]]
for i in range(0,len(msj)):
if msj[i] in ["a","A"]:
Y=Y+A
if msj[i] in ["b","B"]:
Y=Y+B
if msj[i] in ["c","C"]:
Y=Y+C
if msj[i] in ["d","D"]:
Y=Y+D
if msj[i] in ["e","E"]:
Y=Y+E
if msj[i] in ["f","F"]:
Y=Y+F
if msj[i] in ["g","G"]:
Y=Y+G
if msj[i] in ["h","H"]:
Y=Y+H
if msj[i] in ["i","I"]:
Y=Y+I
if msj[i] in ["j","J"]:
Y=Y+J
if msj[i] in ["k","K"]:
Y=Y+K
if msj[i] in ["l","L"] :
Y=Y+L
if msj[i] in ["n","N"]:
Y=Y+N
if msj[i] in ["m","M"]:
Y=Y+M
if msj[i] in ["ñ","Ñ"]:
Y=Y+Ñ
if msj[i] in ["o","O"]:
Y=Y+O
if msj[i] in ["p","P"]:
Y=Y+P
if msj[i] in ["q","Q"]:
Y=Y+Q
if msj[i] in ["r","R"]:
Y=Y+R
if msj[i] in ["s","S"]:
Y=Y+S
 if msj[i] in ["t","T"]:
Y=Y+T
if msj[i] in ["u","U"]:
Y=Y+U
if msj[i] in ["v","V"]:
Y=Y+V
if msj[i] in ["w","W"]:
Y=Y+W
if msj[i] in ["x","X"]:
Y=Y+X
if msj[i] in ["y","Y"]:
Y=Y+YL
if msj[i] in ["z","Z"]:
Y=Y+Z
if msj[i] in [" "]:
Y=Y+ES
Y1=Y
os.system('cls')
time=10000000
if Rep != 1:
for i in range(1,Rep):
Y=Y+ES+CB+ES+Y1

for i in range(5):
print(Y[i],Y[i+5],Y[i+10],Y[i+15],Y[i+20],Y[i+25],Y[i+30])
print()
for i in range(time+1):
if time==i:
os.system('cls')
cl=35
n=5
while (cl)<len(Y):
for i in range(5):
i=i+n
print(Y[i],Y[i+5],Y[i+10],Y[i+15],Y[i+20],Y[i+25],Y[i+30])
print()
for i in range(time+1):
if time==i:
os.system('cls')
n=n+5
cl=cl+5

2. Algoritmo en python