|
|||||||
|
|
|
|||||
|
|
|||||||
|
|||||||
|
|
|
|||||
|
|
|||||||
Profesor : Luis Caceres
Ayudante : Pedro Silva Mingram
fecha : 11 de Junio 2004
Realizar en Java un programa que simule la infeccion de un gusano computacional en la memoria de un computador, usando Strings, Arreglos y Excepciones.
Especificaciones
a) La memoria sera representada por una matriz de 20 filas y 60 columnas, a la cual se le asignará aleatoriamente caracteres pertenecientes al conjunto :
static char [ ]caracter = {a,e,i,o,u,x,y,z};
Además deberá declararse como una variable de clase estática (lo mismo para las demas variables).
Ejemplo : 5 x 10
a a y x o a y e e a
e i z z i x x i i o
e e a x u e e y y u
u z x o o u u a e z
a y y i u z y z a e
gusano : a x u e e y
Se recomienda implementar un metodo void inicializarMemoria( ) y void mostrarMemoria( ).
b) El gusano será representado por un arreglo unidimensional de tamaño fijo igual a 6, el cual contendrá un espacio de la memoria, que el usuario debera indicar a traves del teclado numerico, a traves de movimientos a la derecha,izquierda, arriba o abajo.
static char [ ]gusano = new char[6];
*nota : la posicion inicial del gusano sera (FG = 0 , CG = 0).
Ej : a x u e e y
c) Una vez posicionado en la memoria realizara las infecciones correspondientes :
.- Si el numero de vocales es igual al numero de consonantes entonces el gusano invertira el orden de los caracteres.
.- Si el numero de vocales es mayor al numero de consonantes entonces el gusano asignara en forma aleatoria una consonante en alguna posicion del arreglo.
.- Si el numero de vocales es menor al numero de consonantes entonces el gusano asignara en forma aleatoria dos vocales en alguna posicion del arreglo.
Para realizar dichas funciones, se recomienda implementar los siguientes métodos :
int numVocalesGusano( ) : retorna el numero de vocales que tiene el gusano
int numConsonantesGusano( ) : retorna el numero de consonantes que tiene el gusano
void invertirGusano( ) : invierte el orden del gusano
void asignarVocalGusano( ) : asigna aleatoriamente una vocal del conjunto caracter
void asignarConsonanteGusano( ) : asignar aleatoriamente una consonante del conjunto caracter
Para la asignación aleatoria se recomienda usar el metodo estático de la clase Math,
Math.random( ), el cual retorna un número real entre 0.0 y 1.0 (no incluyéndolos), que es muy útil para generar posiciones aleatorias.
Si se quiere generar un número aleatorio entero entre 0 y N, se debe multiplicar la función random( ) por N+ 1, y se debe realizar una conversión de tipo ( cast ), para transformar el resultado real a un número entero.
Ej : Programa que genera 100 números aleatorios entre 0 y 9 ..... {0,1,2,3,4,5,6,7,8,9}
class NumAleat
{
public static void main(String[ ] args)
{
int num;
for(int i = 0; i < 100; i++)
{
num = (int) ( Math.random() * 10 );
System.out.print(num + " ");
}
}
}
*nota : La conversion debe ser sobre la multiplicación y no sobre la función random, ya que en es este último caso, la generación del número siempre sería cero. El error de programación sería : num = (int) Math.random( ) * 10; , y aunque esta instrucción compila sin problema, produce un error en tiempo de ejecución.
Aplicando lo anterior, se pide generar una posicion aleatoria para el gusano y una posicion aleatoria correspondiente a consonantes.
Como la posicion de los caracteres consonantes son 5, 6 y 7 , podemos generar un numero aleatorio entre 0 y 2, para posteriormente sumarle 5.
asignación de consonantes
int pc = 0, pg = 0;
pc = (int) ( Math.random( ) * 3 ); /* genera numeros : { 0, 1, 2 } para la posicion del caracter */
pg = (int) ( Math.random( ) * 5 ); /* genera numeros : { 0 , ... , 4 } para la posicion del gusano */
gusano[pg] = caracter[5 + pc]; /* asigna una consonante de posicion 5, 6, 7 */
Por otro lado, para determinar el número de consonantes se especifica utilizar el metodo charAt(int index) de la clase String, para hacer una comparacion entre el String copia del gusano y el arreglo caracter.
contador de vocales
int cont = 0;
String temp = new String(gusano); /* ej : a a x y o z */
for(int i = 0; i < temp.length( ); i++)
for(int k = 0; k < caracter.length - 3; k++) /* k : 0, 1, 2, 3, 4 */
{
if ( temp.charAt(i) == caracter[k]) cont++;
}
return cont;
*nota : para contar consonantes revisar el algoritmo anterior y revisar los indices que debe generar k = { 5,6,7 }.
Para la inversion del gusano, se recomienda usar el algoritmo de intercambio :
tmp = a[ i ]
a[ i ] = a[ j ]
a[ j ] = tmp
d) El movimiento del gusano estara determinado por la opción que ingrese por teclado el usuario del programa.
Las opciones de movimientos son : 4 : IZQUIERDA , 6 : DERECHA , 8 : ARRIBA , 2 : ABAJO.
(usar teclado numérico)
Para no provocar un acceso a una direccion inválida, se tendra que verificar las posiciones limites de fila y columna dentro de la memoria, haciendo una asignación redundante.
Idea del método infección( opcion )
f = FG; /* se almacena en una variable temporal la fila actual del gusano */
c = CG; /* se almacena en una variable temporal la columna del gusano */
siwtch( opcion )
{
case IZQUIERDA : c--; break;
:
:
case ABAJO : f++; break;
}
try
{
memoria[ f ][ c ] = memoria[ f ][ c ];
memoria[ f + gusano.length - 1 ][ c ] = memoria[ f + gusano.length - 1 ][ c ];
/* si los limites estan dentro de la memoria , se ejecutan las
infecciones, en caso contrario el flujo del programa salta al
bloque catch
*/
int k = 0;
/* asignacion del pedazo de memoria al gusano */
for(k = 0; k < gusano.length; k++ )
{
gusano[ k ] = memoria[ f ][ c + k ];
}
numVocales = numVocalesGusano( );
numCons = numConsonantesGusano( );
/* ejecutar infecciones */
if ( numVocales == numCons ) invertirGusano( );
else
if ( numVocales > numCons ) asignarConsonanteGusano( );
else
for(t = 0; t < 2; t++) asignarConsonante( );
/* reflejar efecto del gusano en la memoria */
for ( k = 0; k < gusano.length; k++)
{
memoria[ f ][ c + k ] = gusano[ i ];
}
/* asigna nueva posicion al gusano */
FG = f;
CG = c;
}
catch (ArrayIndexOutOfBoundsException e )
{
throw new ExcepcionGusano( generarMensajeExcepcion( f , c ) );
}
Obviamente para poder implementar la excepcion del gusano, hay que declarar una clase que herede de la clase Exception y realizar dentro de la clase Gusano, un método que a partir de la fila y la columna, genere un mensaje de error.
Clase ExcepcionGusano
class ExcepcionGusano extends Exception
{
public ExcepcionGusano(String s)
{
super(s);
}
}
Generación del mensaje de excepción
static String generarMensajeExcepcion( int fila , int columna)
{
String s = "El gusano no se puede mover hacia ";
if ( columna < 0 | | c >= memoria.length )
{
if ( fila >= 0 && fila < memoria[0].length )
{
if (columna < 0 ) s += "a la izquierda";
else s += "a la derecha";
}
}
else
{
/* implementar para arriba y abajo */
}
return s;
}
Finalmente, se pide que al ingresar la opcion 1, el programa se termine.
Metodo principal main
inicializarMemoria( );
introduccion( ); /* explica el programa */
do
{
try
{
mostrarMemoria( );
Leer opcion
if ( opcion != 1 ) infeccion(opcion);
}
catch (ExcepcionGusano e)
{
System.out.println( e.getMessage( ) );
}
} while (opcion ! = 1);