UNIVERSIDAD PERUANA DE CIENCIAS APLICADAS

ESTRUCTURA DE DATOS Y ALGORITMOS

TRABAJO FINAL

PRESENTADO POR:
JOSE MENDOZA SANCHEZ
JEAN CUADROS VASQUEZ
EDSON ARTURO QUISPE ORNAY
EFRAIN DUWAL PARRA QUISPE

DOCENTE:

DANIEL ALEJANDRO SUBAUSTE OLIDEN

LIMA PER
2017
 DESARROLLO DE UN SIMULADOR DE PROPAGACION DE UN VIRUS

Para el desarrollo de esta primera versin se realizaron los siguientes:

- Se crearon dos clases llamado Ciclo y ProcesoInfeccion, a continuacin,
detallaremos:
A) Ciclo

Este objeto tendr como funcin almacenar informacin de cada ciclo y tendr
informacin detallada como:

IdCiclo
Esta propiedad permitir almacenar el nmero del ciclo.
HabitacionesInfectadas
Esta propiedad almacenara la cantidad actual de habitaciones infectadas en
un determinado ciclo.
CantidadMuertosPorCiclo
Este indicador permitir almacenar la cantidad de muertos que existan en
un determinado ciclo.
PorcentajeInfeccion
Esta propiedad permitir almacenar la informacin la cual es el clculo de la
cantidad total de habitaciones infectadas entre el total de salas o habitaciones
que hay en el hospital.
MuertosTotalesEnElMomento
Esta propiedad permitir almacenar la cantidad de muertos totales que
existen hasta el ciclo actual.
CuadroInfeccioso
Esta propiedad permitir almacenar un arreglo con los puntos de infeccin
de un determinado ciclo.

B) ProcesoInfeccion

Este Objeto ser el encargado de realizar los diferentes procesos que harn
que la posible infeccin de cada ciclo.
A continuacin, detallo la funcin que realiza cada mtodo o propiedad:
CONST_PERSONA_X_HABITACION
Esta constante almacenara un nmero nico y fijo de personas que se
hospedaran en una habitacin. En caso que sea modificado en cualquier lado
lanzara una excepcin.
 definirHabitaciones
Este mtodo retornara un array con las posiciones iniciales de las
habitaciones (antes del proceso de infeccin). Este mtodo ser utilizado en
diferentes mtodos a modo de apoyo.
El constructor de la clase ProcesoInfeccion
En el constructor se incluirn variables de modo de apoyo.
cantidadHabitaciones
Este mtodo devuelve un entero que har referencia a la cantidad de
habitaciones que tiene el hospital.
pintar
o Recibir como parmetro un arreglo(habitaciones).
o Este mtodo es el encargado de hacer el pintado del detallado de las
habitaciones, en caso haya una infeccin mostrara los puntos de
infeccin de cada habitacin.

procesoInfeccionPorCiclo
o Recibir como parmetro la cantidad de ciclo y los puntos iniciales de
infeccin
o Este mtodo es el encargado de realizar todo el proceso de hallar y
determinar una infeccin en cada habitacin y ciclo.

convertStringToArray

o Recibir como parmetro un Sting o cadena

o Este mtodo se encargar de convertir una cadena a un array

inicioFocoInfeccioso
o Recibir como parmetro las habitaciones inicialmente intactas sin la
infeccin y el otro ser son los puntos iniciales de infeccin que habr en
cada habitacin.
o Este mtodo ser el encargado de realizar el proceso inicial de infeccin
que habr en una determinada posicin de una habitacin.

procesoInicioInfeccion
o Recibir como parmetro el arreglo de habitaciones
o Este mtodo se encargar de recorrer cada habitacin y con un apoyo
de un submetodo es quien determinar si una habitacin estar
infectada o no.
validarInfeccionPorHabitacion
 o Recibir como parmetro la fila y la columna la cual sern las posiciones
de una habitacin y un segundo parmetro que ser el arreglo de
habitaciones.
o Este mtodo se encargar de ubicar la cantidad de habitaciones
infectadas que hay alrededor de la posicin actual de una habitacin, al
final retornar y validar si la habitacin actual ser propensa a una
infeccin.
validarInfeccion
o Recibir como parmetro la cantidad de habitaciones infectadas que hay
alrededor una habitacin, la fila y la columna donde se encuentra una
habitacin, el arreglo de habitaciones.
o Este mtodo validara de acuerdo a la cantidad de habitaciones infectadas
alrededor de una habitacin central y segn a las condiciones
establecidas se cumplirn los siguientes:

Si una habitacin infectada tiene contacto con dos

habitaciones infectadas la bacteria de esa habitacin queda
intacta.
Si una habitacin infectada no tiene contacto con otra
habitacin infectada la bacteria muere en esa habitacin.
Si una habitacin infectada solamente tiene contacto con otra
habitacin infectada entonces la bacteria de dicha habitacin
muere.
Si una habitacin limpia, est en contacto con tres
habitaciones infectadas entonces la bacteria se reproducir en
dicha habitacin.
Si una habitacin infectada est en contacto con ms de tres
habitaciones infectadas las bacterias de esa habitacin
morirn.

o Retornara el estado en el que se encuentra dicha habitacin.

main
o Este mtodo ser el mtodo principal donde iniciaremos todos los
procesos anteriormente mencionadas.

EJECUCION DEL PROGRAMA

El inicio de este programa comienza creando un objeto de tipo ProcesoInfeccion el
cual al hacer una instanciacin se dara a la iniciacin de las variables que estarn en
el constructor de dicho objeto creado.
 - Dentro de este constructor se utiliz variables de tipo Hashes, la cual de acuerdo
a las investigaciones que se realiz , con respecto a sus propiedades tiene la
caracterstica de almacenar una clave de cualquier tipo de dato y
referencindole cualquier tipo de dato hasta inclusive un
objeto(www.tutorialspoint.com/ruby/ruby_hashes.htm) .Es por ello que se utiliz
este tipo de variable(@VECTOR_TMP) con la funcin de almacenar como clave
el cdigo o nmero del ciclo y como referencia un tipo objeto Ciclo.
- La @TOTAL_HABITACION_INFECTADAS, tendr como funcin contabilizar la
cantidad de habitacin infectadas que habr en cada ciclo.
- La variable hashes @MAP_MUERTOS_X_CICLO tendr como clave la
concatenacin de la columna y la fila de una habitacin (2-3). En cada recorrido
de una posicin habitacional, si la clave formada por la fila y columna de una
posicin actual no existe y esta habitacin o posicin se encuentra infectada
(valor = 1) entonces usaremos un contador denominado
@TOTAL_MUERTOS_X_CICLO que se encargara de aumentar la cantidad de
muertos que hay en cada ciclo. Este contador se resetear a 0 en un ciclo nuevo.
- @TOTAL_SALAS invoca al metodo cantidadHabitaciones() como
anteriormente se mencion retornara la cantidad de habitaciones que hay en ese
hospital.
- @MUERTOS_TOTALES esta variable almacenara y contabilizara la cantidad de
muertos totales que hay hasta el momento, en un determinado ciclo.

Luego de describir las variables que, si inician al realizar la instanciacin de un objeto

ProcesoInfeccion, invocaremos al mtodo main que dara el inicio a todos los
procesos, a continuacin, detallaremos los proceso que se realiza en este mtodo:
En primer lugar, habr una variable la cual tomar el valor que introduciremos por
consola, la cual har referencia a la cantidad de ciclo que vamos iterar y procesar.
- El arreglo infeccion ser inicialmente los puntos de infeccion de una habitacin.
- Invocaremos al metodo procesoInfeccionPorCiclo que recibir como
parmetros la variable ciclo y infeccion. La cual lo detallaremos ms adelante.

Luego de procesar el mtodo procesoInfeccionPorCiclo la variable @VECTOR_TMP

tendr informacin completa de cada ciclo.
- En las siguientes lneas de cdigo declaramos una variable entera denominada
respuesta que es inicializada con 1. A continuacin realizamos un bucle con la
cual se detendr cuando la variable respuesta sea diferente a 1.
- Dentro del bucle while, lo que realizamos es declarar un variable
ciclo_averiguar la cual ser seteada cuando introduzcamos un valor por la
pantalla, luego validara si lo introducido es menor a la variable ciclo, que
anteriormente hemos definido, si no cumple la condicin entonces nos saldr un
mensaje debe ser menor al [variable ciclo]. Caso contrario definimos o
 creamos un objeto de tipo Ciclo llamado cicloBean lo seteamos y tomamos
como referencia la variable @VECTOR_TMP , la cual introduciremos a esta
variable la llave que le corresponde, en este caso sera la variable
ciclo_averiguar y finalmente nos retornara una objeto de tipo Ciclo ,donde
lneas despus detallamos la informacin correspondiente a ese ciclo.
- Luego de ello nos saldr un mensaje si deseamos continuar buscando, donde
de acuerdo a la eleccin se seteara la variable respuesta

INICIO DEL PROCESO PRINCIPAL

En el mtodo procesoInfeccionPorCiclo como anteriormente mencionado recibe

como parmetros la cantidad de ciclos y los puntos iniciales de infeccin que habr en
una habitacin, es en este mtodo donde se hace el proceso de infeccin en tales
puntos, a continuacin, describiremos y detallaremos cada secuencia de lnea de
cdigo:
- Invocaremos al metodo definirHabitaciones() que retorna un arreglo, en este
caso el arreglo de habitaciones, que ser almacenada en una variable
habitaciones.
- Inicializamos la variable @MUERTOS_TOTALES y lo seteamos a 0, la cual se
detall la funcin de esta variable.
- Validamos que el numero de ciclo sea mayor a 0.
- En caso que se mayor a 0 entonces recorremos en un bucle for la cantidad de
ciclos que hemos introducido por la pantalla.
- Inicializamos la variable @TOTAL_HABITACION_INFECTADAS y
@TOTAL_MUERTOS_X_CICLO a 0.
A) Por cada ciclo que recorramos crearemos un objeto de tipo Ciclo. Una vez
creado el objeto seteareamos y almacenamos la informacin que tendr un
determinado ciclo. En este caso setearemos el numero de ciclo en la
propiedad setIdCiclo.
Realizamos una validacin, en este caso si es el primer ciclo invocaremos
el metodo inicioFocoInfeccioso, anteriormente ya descrito, pero igual
pasaremos a repetir otra vez. Este metodo se pasa los parmetros el arreglo
de habitaciones que inicialmente estn libres de infeccion y un arreglo que
hace referencia a los puntos de infeccion. Dentro de este metodo recorremos
todas las posiciones ya sea filas y columnas, ms adelante explicaremos por
que se utiliza en algunas posiciones con valor a -1, realizamos una validacin
que cumpla que la posicin fila y columna sea mayor a -1 y considere solo
las posiciones que contenga valores 0 y 1. Una vez cumplido esta condicin
recorremos todo el arreglo infeccion, la cual cada valor contenido en este
 arreglo ser la posicin fila y columna del arreglo de habitaciones. En la
siguiente, realizamos una validacin donde la posicin y la columna sean
mayores a 0 y menores a 9, ya que ubicar las posiciones del arreglo
habitaciones y establecer los puntos iniciales con los estados de infeccion
de cada habitacin. Esta validacin se debe a que inicialmente el arreglo de
habitaciones esta conformado por un arreglo de 10 x 10(imagen 1). En el
siguiente grfico, solo estamos tomando en cuenta desde la fila 1 hasta 8,
columna 1 hasta 8(con respecto a sus ndices). Tomaremos como ejemplo
un punto de infeccion inicial infeccion = [[1,7], [2,6]] entonces el resultado
ser como se refleja en la imagen 2
o Imagen 1

o Imagen 2

Luego habr una validacin como muestra en la siguiente imagen:

En este fragmento de cdigo lo que se hace es primero validar si la habitacin

est infectada, si esto es correcto entonces pasaremos a aumentar la cantidad de
habitaciones infectadas en un ciclo en la variable
@TOTAL_HABITACION_INFECTADAS, luego de ello hay otra validacin que
pregunta si la llave (conformada por la concatenacin de la fila y columna) no
existe y la habitacin est infectada entonces almacenaremos dicha llave en la
variable
hashes @MAP_MUERTOS_X_CICLO y lo referenciamos con un valor auxiliar, y
tambin pasaremos a contabilizar y setear en la variable
@TOTAL_MUERTOS_X_CICLO, con estas validaciones nos mostrara la cantidad
total de muertos que hay en cada ciclo debido a la proliferacin. En el caso que no
se cumpla esta condicin, si ya existe una llave no har la contabilizacin. Por
ejemplo, en la siguiente imagen se detalla como seria estas validaciones:
 o En la imagen ciclo 1 se realizar la validacin si la llave 1-1 no exista
en la variables hashes @MAP_MUERTOS_X_CICLO y dicha habitacin
se encuentre infectada (1) entonces pasar a almacenarse en la variable
@MAP_MUERTOS_X_CICLO contabilizando en la variable
@TOTAL_MUERTOS_X_CICLO a 10
o En la imagen ciclo 2 har la validacin de la llave 1-1, pero esta llave ya
existi en el primer ciclo, entonces no har la contabilizacin. Sin
embargo, las llaves 2-2 y 3-3 no existen entonces se almacenar en la
variable @MAP_MUERTOS_X_CICLO y como resultado la variable
@TOTAL_MUERTOS_X_CICLO ser 20. Cabe recordar que este ltimo
se resetea a 0 cuando es un nuevo ciclo.

o Finalmente retornara un arreglo de habitaciones modificado que lo

setearemos en la misma variable de habitaciones

- En la siguiente imagen almacenamos e incrementaremos la cantidad total de

muertos en la variable @MUERTOS_TOTALES la cual se incrementa de
acuerdo al clculo realizado entre la cantidad de muertos por ciclo de la variable
@TOTAL_MUERTOS_X_CICLO y multiplicndolo por la constante
CONST_PERSONA_X_HABITACION (10)

- En la siguiente imagen, con respecto a nuestras pruebas realizadas inicialmente

tenamos el inconveniente de poder almacenar un arreglo dentro de la propiedad
setCuadroInfeccioso del objeto objCiclo de tipo Ciclo ya que cuando
consultbamos en el objeto @VECTOR_TMP nos retornaba el arreglo de
habitaciones del ltimo ciclo. Es por ello tomamos otra alternativa de convertir
 el arreglo en una cadena utilizando el metodo join. Luego de ello lo
procesaramos esta cadena con un metodo encargado convertirlo otra vez en
arreglo. El metodo convertStringToArray es el encargado hacer esta funcin.

- En la siguiente imagen, almacenamos la cantidad de habitaciones infectadas que

hay en un ciclo determinado.

- En la siguiente imagen, almacenamos al objeto objCiclo la cantidad de muertos

que hay actualmente en el ciclo.

- Almacenamos al objeto objCiclo el porcentaje de infeccion la cual es el clculo

del total de habitaciones infectadas en el ciclo entre el total de salas existentes
en el hospital

- Almacenamos el total de muertos acumulados que hay en el momento en un

determinado ciclo.

- Almacenamos en la variable hashes @VECTOR_TMP el valor de la clave que

es el numero del ciclo y lo referenciamos el objeto objCiclo de tipo Ciclo.

- Luego de almacenar todas las informaciones en la variable de tipo Hashes,

dibujamos el resultado del proceso de infeccion que hay en cada habitacin de
la siguiente manera:

Retornando las posiciones de la siguiente forma:

- En el siguiente fragmento de cdigo realizaremos la salida de informacin que
hay en cada ciclo

Que retornara de la siguiente manera

A) Cuando estemos en el ciclo nmero mayor a 1 se ejecutar otro metodo

denominado procesoInicioInfeccion la cual pasa como parmetro la habitacin
anteriormente modificada, de igual manera dentro de este metodo realizamos el
recorrido del arreglo de habitaciones, validando que el dato de una posicin sea
mayor a -1.

a. Imagen A

En la imagen A lo que se realiza en esta lnea de cdigo es invocar a un

mtodo donde le pasamos como parmetro la posicin de la fila y columna de
una habitacin y el arreglo de habitaciones. El mtodo a invocar es el siguiente:
b. validarInfeccionPorHabitacion, este metodo realizara la bsqueda e
identificara y retornara el numero o cantidad, que se almacenara en una
variable llamada suma, de habitaciones infectadas a una habitacin
central, validando que los datos que hay en las posiciones sea mayor a -
1. Por ejemplo, en el siguiente grafico detallara como se realiza este
proceso.
i. Imagen 1
 La cantidad a devolver en este caso ser 2

ii. Imagen 2
La cantidad a devolver en este caso ser 4

Finalmente obviamos la posicin central de la siguiente manera:

Para la imagen1 e imagen2 ser 2 y 3 respectivamente. En los casos

anteriormente descritos observamos que los valores -1 son datos
auxiliares para realizar la bsqueda en una determinada posicin.

Luego de obtener el resultado de la cantidad de habitaciones infectadas,

invocaremos a un submetodo denominado validarInfeccion que se
pasaran como parmetro la cantidad de infecciones que hay alrededor
de una habitacin, la fila y columna de una posicin de una habitacin y
el arreglo de habitaciones. En este metodo se realizar las validaciones
correspondientes las cuales determinara el estado de una habitacin si
se infect o no.
En el metodo procesoInicioInfeccion realizamos las validaciones que
anteriormente hemos mencionado para calcular la cantidad total de
habitaciones infectadas y verificamos si la clave, la cual es la
concatenacin de la fila y columna, no exista y la habitacin se encuentre
infectada.

Al final del proceso de este mtodo retornaremos un arreglo de

habitaciones infectadas, como muestra en la imagen.
 Almacenaremos la informacin en el objeto objCiclo de tipo Ciclo al
igual como lo realizamos en el primer mtodo para luego almacenarlo
en la variable Hashes @VECTOR_TMP pasando como clave el nmero
del ciclo y referencindolo el objeto objCiclo.

FUNCIONAMIENTO DEL PROGRAMA

class Ciclo

def setCuadroInfeccioso=(value)
@cuadroInfeccioso = value
end

def getCuadroInfeccioso
@cuadroInfeccioso
end

def getIdCiclo()
@idCiclo
end

def setIdCiclo=(value)
@idCiclo = value
end

def getHabitacionesInfectadas()
@habitacionesInfectadas
end

def setHabitacionesInfectadas=(value)
@habitacionesInfectadas = value
end

def setCantidadMuertosPorCiclo=(value)
 @muertosPorCiclo = value
end

def getCantidadMuertoPorCiclo()
@muertosPorCiclo
end

def setPorcentajeInfeccion=(value)
@porcentaje = value
end

def getPorcentajeInfeccion()
@porcentaje
end

def setMuertosTotalesEnElMomento=(value)
@muertosTotales=value
end

def getMuertosTotalesEnElMomento()
@muertosTotales
end
end

class ProcesoInfecion

CONST_PERSONA_X_HABITACION = 10
#CONST_HABITACIONES = [[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,0,0,0,0,0,0,0,0,-1] ,
 # [-1,0,0,0,0,0,0,0,0,-1] ,
# [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]]

def definirHabitaciones()
habitaciones = [
[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,0,0,0,0,0,0,0,0,-1] ,
[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1]
]
end

def initialize()
@VECTOR_TMP = Hash.new
@TOTAL_HABITACION_INFECTADAS = 0
@MAP_MUERTOS_X_CICLO = Hash.new
@TOTAL_MUERTOS_X_CICLO = 0
@TOTAL_SALAS = cantidadHabitaciones()
@MUERTOS_TOTALES = 01
end

def cantidadHabitaciones()
room_arreglo = definirHabitaciones()
rooms = 0
for rows in 0...room_arreglo.length do
for col in 0...room_arreglo[rows].length do
 if room_arreglo[rows][col] >-1
rooms = rooms +1
end
end
end
room_arreglo=nil
return rooms
end

##METODO QUE SIRVE PARA PINTAR LAS POSICONES DE LAS INFECCIONES

def pintar(habitaciones)
for rows in 0...habitaciones.length do
for col in 0...habitaciones[rows].length do
if habitaciones[rows][col] >-1
if habitaciones[rows][col] ==1
print "X\t"
else
print "O\t"
end
end
end
print "\n"
end
end

def procesoInfeccionPorCiclo(ciclos, infeccion)

habitaciones = definirHabitaciones()
@MUERTOS_TOTALES = 0
if ciclos>0
print "MEMORIAL HOSPITAL"

for ciclo in 1..ciclos do

@TOTAL_HABITACION_INFECTADAS = 0
@TOTAL_MUERTOS_X_CICLO=0
 objCiclo = Ciclo.new
objCiclo.setIdCiclo = ciclo
if ciclo==1
habitaciones = inicioFocoInfeccioso(habitaciones, infeccion)
else
habitaciones = procesoInicioInfeccion(habitaciones)
end

@MUERTOS_TOTALES+=@TOTAL_MUERTOS_X_CICLO*CONST_PERSONA_X_
HABITACION
##Almacenamos en un Array las posiciones de las infecciones
objCiclo.setCuadroInfeccioso = convertStringToArray(
habitaciones.join(",") )

#puts habitaciones.join(",")
##Cantidad de Habitaciones infectadas

objCiclo.setHabitacionesInfectadas=(@TOTAL_HABITACION_INFECTADAS)
##Cantidad de Muertos por Ciclo

objCiclo.setCantidadMuertosPorCiclo=(@TOTAL_MUERTOS_X_CICLO*CONST_PER
SONA_X_HABITACION)
##Porcentaje de Infeccion
objCiclo.setPorcentajeInfeccion =
100*(@TOTAL_HABITACION_INFECTADAS/@TOTAL_SALAS.to_f )
##Total de Muertos que se acumulan en cada ciclo
objCiclo.setMuertosTotalesEnElMomento =
@MUERTOS_TOTALES

##Almacenmos en una variables Hash donde la clave es el

ciclo y el valor es el objeto Ciclo
##ejemplo 3 => Ciclo
@VECTOR_TMP[ciclo] = objCiclo
##funcion que permite y ubicar las posiciones de las
infecciones

pintar(objCiclo.getCuadroInfeccioso())
 ##Detalle de la informacion de cada ciclo
print "------------------------INFORMACION---------------------------\n"
print "> CICLO #{ciclo} \t Muertos en el ciclo
#{@TOTAL_MUERTOS_X_CICLO*CONST_PERSONA_X_HABITACION} \n"
print "> Habitaciones infectadas
#{@TOTAL_HABITACION_INFECTADAS} \n"
print "> Porcentaje de infeccion #{
100*(@TOTAL_HABITACION_INFECTADAS/@TOTAL_SALAS.to_f) } \n"
print "> Muertos totales #{ @MUERTOS_TOTALES} \n"
print "--------------------------------------------------------------\n"
#liberando en memoria
objCiclo = nil
## break if
@TOTAL_SALAS*CONST_PERSONA_X_HABITACION==@MUERTOS_TOTALES
end
end
end
###Metodo que usa como parametro un arreglo
def convertStringToArray(array___)
tmp = array___.split(",")
aux_array = definirHabitaciones()
indice = 0
for fila in 0..9 do
for columna in 0..9 do
aux_array[fila][columna] = tmp[indice].to_i
indice =indice + 1
end
end
return aux_array
end

def inicioFocoInfeccioso(habitaciones,infeccion)
for rows in 0...habitaciones.length do
for col in 0...habitaciones[rows].length do
if habitaciones[rows][col] > -1
for f_afecta in 0...infeccion.length do
 begin
f = (infeccion[f_afecta][0]).to_i
c = (infeccion[f_afecta][1]).to_i
if (f>0 && f<9) && (c>0 && c<9)
habitaciones[f][c] = 1
end
rescue
end
end
@TOTAL_HABITACION_INFECTADAS+=1 if
habitaciones[rows][col]==1
if !@MAP_MUERTOS_X_CICLO.key?("#{rows}-
#{col}") && habitaciones[rows][col]==1
@MAP_MUERTOS_X_CICLO["#{rows}-
#{col}"] = 1
@TOTAL_MUERTOS_X_CICLO+=1
end
end
end
end
return habitaciones
end

def procesoInicioInfeccion(habitaciones)
for rows in 0...habitaciones.length do
for col in 0...habitaciones[rows].length do
if habitaciones[rows][col]>-1
habitaciones[rows][col] =
validarInfeccionPorHabitacion(rows,col , habitaciones)
@TOTAL_HABITACION_INFECTADAS+=1 if
habitaciones[rows][col]==1
if !@MAP_MUERTOS_X_CICLO.key?("#{rows}-
#{col}") && habitaciones[rows][col]==1
@MAP_MUERTOS_X_CICLO["#{rows}-
#{col}"] = 1
@TOTAL_MUERTOS_X_CICLO+=1
end
 end
end
end
return habitaciones
end

def validarInfeccionPorHabitacion(fila, columna , habitaciones)

suma = 0
for f in (fila-1)..(fila+1) do
for c in (columna-1)..(columna+1) do
if habitaciones[f][c]>-1
suma+=habitaciones[f][c]
end
end
end
suma = suma - habitaciones[fila][columna]
return validarInfeccion(suma,fila,columna,habitaciones)
end

def validarInfeccion(suma , fila , columna , habitaciones)

####1
####2
####3
####4
####5
####6
case suma
when 2
if habitaciones[fila][columna]==1
habitaciones[fila][columna]=1
end
when 0
if habitaciones[fila][columna]==1
habitaciones[fila][columna] = 0
end
 when 1
if habitaciones[fila][columna]==1
habitaciones[fila][columna] = 0
end
when 3
if habitaciones[fila][columna]==0
habitaciones[fila][columna] = 1
end
else
if suma > 3
if habitaciones[fila][columna]==1
habitaciones[fila][columna] = 0
end
end
end
return habitaciones[fila][columna]
end
def main
print "Ingrese un ciclo : "
ciclo = gets.to_i
# room = definirHabitaciones()
infeccion = #[[1,7] , [1, 8] ,[2,8] , [7,1] ,[8,1]]
[[1,7],[1,2],[1,3],[1,4],[1,5],[2,3],[6,6],[2,4],
[4,8],[6,7],[4,7],[2,5],
[2,7],[3,7],[3,8],[3,6],
[2,6],[1,8],[1,6],[1,5],
[2,8],[7,1],[8,1],[8,3],
[8,4],[8,1],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[5,8]
,

[6,4],[6,1],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],[6,8]]

print "fecha inicio :#{Time.new().strftime("%Y-%m-%d %H:%M:%S")} \n"

procesoInfeccionPorCiclo(ciclo , infeccion)
 print "fecha fin : #{Time.new().strftime("%Y-%m-%d %H:%M:%S")} \n"

respuesta = 1
while respuesta==1 do
print "-----------------------------------------------\n"
print "Ingrese un ciclo para saber su informacion: "
ciclo_averiguar = gets.to_i
print "\n"
if ciclo_averiguar<=ciclo
cicloBean = @VECTOR_TMP[ciclo_averiguar]
print "-CICLO #{cicloBean.getIdCiclo()}\tMuertos en el ciclo
#{cicloBean.getCantidadMuertoPorCiclo()}\n"
print "-Habitaciones infectadas
#{cicloBean.getHabitacionesInfectadas()}\n"
print "-Porcentaje de infeccion
#{cicloBean.getPorcentajeInfeccion()}\n"
print "-Muertos totales hasta ese entonces
#{cicloBean.getMuertosTotalesEnElMomento()}\n"
pintar(cicloBean.getCuadroInfeccioso())
cicloBean = nil
else
print "debe ser menor a #{ciclo}"
end
print "\n"
print "DESEAS CONTINUAR : SI(1) / NO(<>1) "
respuesta = gets.to_i
end

end

end
i = ProcesoInfecion.new()
i.main