UNIVERSIDAD EAN

FACULTAD DE INGENIERÍA
FUNDAMENTOS DE PROGRAMACIÓN

GUÍA 3. APLICACIÓN DE CONCEPTOS EN EL PROYECTO INTEGRADOR DE AULA

AUTORES
ANDREY TRINIDAD BERNAL
ANDRES FELIPE HERRERA MOLINA
FREDY ALEJANDRO TELLEZ PEÑARANDA

TUTOR
ALIX ERICA ROJAS HERNANDEZ

BOGOTÁ, D.C, 02 DE ABRIL DE 2022

 TABLA DE CONTENIDO

1. INTRODUCCIÓN ............................................................................................... 4

2. OBJETIVOS ........................................................................................................ 5

3. JUEGO DE LA VIDA ......................................................................................... 6

3.1. Análisis ............................................................................................................. 6

3.2. Diseño............................................................................................................... 7

3.3. Implementación ................................................................................................ 8

3.4. Pruebas. ............................................................................................................ 9

3.4.1. Regla 1. ...................................................................................................... 9

3.4.2. Regla 2 ..................................................................................................... 10

3.4.3. Regla 3 ..................................................................................................... 11

3.4.4. Regla 4 ..................................................................................................... 12

4. CONCLUSIONES ............................................................................................. 15

5. BIBLIOGRAFÍA ............................................................................................... 16

2
 TABLA DE ILUSTRACIONES

Ilustración 1:regla 1...................................................................................................... 10

Ilustración 2: regla 2..................................................................................................... 11
Ilustración 3: regla 3..................................................................................................... 12
Ilustración 4:regla 4...................................................................................................... 13
Ilustración 5:continuidad regla 4 .................................................................................. 13

3
 1. INTRODUCCIÓN

El juego de la vida es un tipo particular de autómata celular bidimensional. Hay

autómatas celulares unidimensionales. En ellos, una lista de valores (en su versión más
simple, ceros y unos) evoluciona a lo largo del tiempo a partir del estado de sus celdas
vecinas (solo las celdas izquierda y derecha en su versión más simple) y de ella misma en el
instante anterior.

4
 2. OBJETIVOS

• Analizar problemas identificando el contexto, el estado inicial, el estado final y los

casos de prueba.

• Diseñar soluciones algorítmicas y las representa con diagramas de flujo.

• Codificar soluciones y ejecuta casos de pruebas en un lenguaje de programación.

• Desarrollar su pensamiento algorítmico para proponer soluciones modulares.

5
 3. JUEGO DE LA VIDA

3.1. Análisis

Hay que crear un programa para leer la evolución de un autómata celular 1D,
comprobar si la célula está viva, si ha muerto en la iteración anterior, también si tiene células
muertas a la izquierda y células vivas a la derecha, todo lo anterior El contenido se basa en
reglas y pulsos establecidos.

En cada una de las reglas vamos a encontrar unas subreglas que nos indicaran si la
célula esta viva la marcaremos como “1” y si está muerta será un “0” , de acuerdo con esta
condición en la siguiente interacción se validara el pulso anterior y dará vida a nuevas células
o si morirán.

6
3.2. Diseño

7
3.3. Implementación

"""
Descripción: Guía # 3 - Juego de la vida .
Autores: ANDRES FELIPE HERRERA MOLINA, FREDY ALEJANDRO TELLEZ PEÑARANDA,
EDGAR ANDREY TRINIDAD BERNAL
Versión: 4.0
Fecha:02/04/2022
"""

"""
En esta primera parte se pide al usuario que ingrese los datos de pulsos y
la regla que se va a ejecutar, adicional también definimos la cantidad de
posición en el eje Y
"""
cantidad_de_pulsos=int(input('¿Cuántos pulsos quieres ver durante la
evolución de un autómata celular 1D?: '))
regla=int(input('Seleccione el numero de la regla que desea aplicar
(ingrese la regla en numero: 1, 2, 3, 4): '))
cantidad_posiciones=51

"""
En esta parte utilizamos listas para identificar los patrones y posiciones
"""

listado_general=[[0]*cantidad_posiciones]*cantidad_de_pulsos

inicio=[0]*(cantidad_posiciones//2)
intermedio=[1]
final=[0]*(cantidad_posiciones//2)
l0=inicio+intermedio+final
listado_general[0]=l0

"""
En esta parte tenemos el código que identifica las reglas e identifica la
vida o muerte de la célula.
"""

if regla==1:
muerte=[[0,0,0],[1,0,1],[1,1,0],[1,1,1]]
vida=[[0,0,1],[0,1,0],[0,1,1],[1,0,0]]

elif regla==2:
muerte=[[0,0,0],[0,0,1],[1,1,0],[1,0,1],[1,1,1]]
vida=[[0,1,0],[0,1,1],[1,0,0]]

elif regla==3:
muerte=[[0,0,0],[1,0,0],[1,1,1]]
vida=[[0,0,1],[0,1,0],[0,1,1],[1,0,1],[1,1,0]]

elif regla==4:
muerte=[[0,0,0],[0,1,1],[1,1,0]]
vida=[[0,0,1],[0,1,0],[1,0,1],[1,0,0],[1,1,1]]

8
for k in range(0,len(listado_general)-1):
l3=[0]*cantidad_posiciones
for i in range(0,len(listado_general[k])-2):
if listado_general[k][i:i+3] in muerte:
l3[i+1]=0
elif listado_general[k][i:i+3] in vida:
l3[i+1]=1
listado_general[k+1]=l3

"""
Es esta parte encontramos el for que verifica la posición de la lista
general para que desde otro bucle for, se identifique si la célula saldrá,
viva o muerta.
"""

for i in range(0,len(listado_general)):
for j in range(0,len(listado_general[i])):
if listado_general[i][j]==0:
listado_general[i][j]='-'
else:
listado_general[i][j]='*'

"""
En este for se cambia los resultados para que salgan impresos en “-” y “*”.
"""

for i in range(0,len(listado_general)):
s=''
s=s.join(listado_general[i])
print('Pulso', i, ':', s)

3.4. Pruebas.

3.4.1. Regla 1.

Seleccionando la regla numero 1 vamos a tener la siguiente imagen.

9
 Ilustración 1:regla 1

En la imagen podemos ver que se ingreso el numero 24 para indicar la cantidad de

pulsos y después el numero de la regla que deseamos aplicar que en este caso fue la 1.

3.4.2. Regla 2

Seleccionando la regla numero 2 vamos a tener la siguiente imagen.

10
 Ilustración 2: regla 2

En la imagen podemos ver que se ingresó el número 24 para indicar la cantidad de

pulsos y después el numero de la regla que deseamos aplicar que en este caso fue la 2.

3.4.3. Regla 3

11
 Seleccionando la regla numero 3 vamos a tener la siguiente imagen.

Ilustración 3: regla 3

En la imagen podemos ver que se ingresó el número 20 para indicar la cantidad de

pulsos y después el numero de la regla que deseamos aplicar que en este caso fue la 3.

3.4.4. Regla 4

12
 Seleccionando la regla numero 4 vamos a tener la siguiente imagen.

Ilustración 4:regla 4

Ilustración 5:continuidad regla 4

En la imagen podemos ver que se ingresó el número 52 para indicar la cantidad de

pulsos y después el numero de la regla que deseamos aplicar que en este caso fue la 4.

13
 Se escoge un numero grande de pulsos para que se vea la diferencia con la regla 1 y
como cambia el patrón.

14
 4. CONCLUSIONES

De acuerdo con la aplicación de las reglas observamos que cada entorno nos muestra
diferentes condiciones en las que las células pueden convivir.

Al ser este solo un juego vemos que la única interacción que podemos tener es de
indicar cuantos pulsos podemos decirle que nos muestre y que regla deseamos aplicar,
aunque algunas de estas condiciones las podemos alterar en el código fuente, como dejar que
se vean más columnas o que el usuario ingrese el valor que desea de columnas, también
cambiar los “*” y “-” por otro símbolo o letra.

15
 5. BIBLIOGRAFÍA

Varó, A. M., Sevilla, P. G., & Luengo, I. G. (2014). Introducción a la programación con

Python 3. Universitat Jaume I. Servei de Comunicació i Publicacions. https://elibro-

net.bdbiblioteca.universidadean.edu.co/es/lc/bibliotecaean/titulos/51760?as_all=Intro

ducci%C3%B3n__a__la__programaci%C3%B3n__con__Python__3&as_all_op=una

ccent__icontains&prev=as

Álvarez, A. C. (2017). Python 3: curso práctico. Ediciones de la U. https://www-ebooks7-24-

com.bdbiblioteca.universidadean.edu.co/stage.aspx?il=&pg=&ed=

16