Actividad 2.

Identificacin de
errores en
mtodos de
ordenacin
DEDA_U2_A2_JCM
Prof: Carmen Gmez Prez
Alumno: Javier Chvez Mocios

La siguiente actividad te permitir identificar errores en la codificacin de un caso prctico en el que se han
utilizado mtodos de ordenacin.
Caso: Patentes
Las antiguas patentes (de automviles), por ejemplo PL7812, estn compuestas por un string de dos
caracteres, en el ejemplo PL, y por un nmero entero de cuatro dgitos, en el ejemplo 7812. Suponga que
exista una clase Patente y otra TablaDePatentes de la siguiente forma:

public class Patente {
private String letras ;
private int numero ;
public Patente () {}
public String obtLetras () { return letras ; }
public int obtNumero () { return numero ; }
}
public class TablaDePatentes {
private String [] tabla ;
public TablaDePatentes () { tabla = new String [9999]; }
public boolean buscar (Patente patente ) {}
otros mtodos
}

La idea es que TablaDePatentes almacena en el atributo tabla todas las patentes autorizadas a
estacionarse en el campus San Joaqun. En particular, si la patente PL7812 est autorizada, entonces tabla
[7812] = PL, y si la patente JK2345 est autorizada, entonces tabla [2345] = JK. Adems, si dos o ms
patentes autorizadas tienen el mismo nmero, entonces sus pares de letras aparecen consecutivamente en
el string correspondiente de tabla. Por ejemplo, si las patentes PL7812 y MB7812 estn autorizadas,
entonces tabla [7812] = PLMB; y si las patentes JK2345, RC2345 y DW2345 estn todas autorizadas,
entonces tabla [2345] = JKRCDW.
Escriba el mtodo buscar de la clase TablaDePatentes, que busca rpidamente la Patente en el atributo
tabla, y devuelve true (verdadero) si patente est en tabla, y false (falso) en caso contrario.
Criterios de solucin:
Lo primero que tenemos que hacer es declarar el mtodo como nos indican en el enunciado. Luego, con
los mtodos de la clase Patente, obtenemos las letras y los nmeros que la componen. Con el nmero de
la patente obtenemos lo almacenado en el arreglo y luego debemos recorrer este string obteniendo
substring de largo 2 e ir comparando cada substring con las letras de la patente a buscar. Si coincide con
alguno retornamos true, de lo contrario retornamos false.
Posible solucin:
public boolean buscar (Patente patente ) {
int num = patente. obtNumero ();
String letras = patente . obtLetras ();
String validas = tabla [ num ];
if( validas != null ){
int largo = validas . length ();
int k = 1;
while (k < largo ) {
if ( letras . equals ( validas . substring (k - 1, k + 1)))
return true;
k = k + 2;
}
}
return false ;
}

Ahora:
1. Crea un proyecto nuevo en NetBeans.
2. Transcribe el cdigo que se encuentra lneas arriba.
3. Identifica los errores en el cdigo.
4. Con comentarios (// o /*, */) documenta los errores encontrados y realiza las correcciones necesarias
para que el programa pueda funcionar correctamente.
5. Una vez corregido el cdigo, ejecuta el programa.
6. Si la ejecucin ha sido correcta guarda el archivo con los comentarios realizados.
7. Documenta el cdigo explicando de forma breve pero concisa las partes del mismo donde se ha
empleado algn mtodo de ordenacin, seala de forma puntual qu mtodo de ordenacin se ha
empleado y por qu.






public class Patente {
private String letras;
private int numero;
public Patente(String letra, int num) { //Creamos el constructor pasandole como parametros las letras
y numeros
this.letras = letra;
this.numero = num;
}
public String obtLetras() {
return this.letras;
}
public int obtNumero() {
return this.numero;
}
}
Aqui te faltaba un getTabla para trabajar con ella desde otra clase

public class TablaDePatentes {
private Patente[] tabla;


public TablaDePatentes() {
tabla = new Patente[2]; //Hacemos el array de tamao 2 para no volvernos locos. No es muy
eficiente hacer un array de 9999 posiciones como tenias
}

public Patente[] getTabla(){
return this.tabla;
}

/**

*
*/
public boolean buscar(Patente patente) {
int num = patente.obtNumero();
String letras = patente.obtLetras();
boolean encontrado = false;
int len = tabla.length;

for (int i = 0; i < tabla.length && encontrado == false; i++) { //El bucle seguira iterando hasta que
acabe la tabla o hasta que encontrado == true.
if (tabla[i].obtLetras().equals(letras)) { //Comparamos las dos primeras posiciones del
resultado de la tabla que coincida con las letras
if (tabla[i].obtNumero()==num) { //Comparamos las 3 ultimas posiciones del resultado
de la tabla que coincida con las letras
encontrado = true; //Al encontrarlo, encontrado == true por lo tanto sale del bucle y
retorna el encontrado==true, si este caso nunca se da retornata encontrado == false;
}
}
}
return encontrado;
}
}
Y una clase PRINCIPAL

public class Principal {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Patente patente = new Patente("PV", 1415); //Creamos una patente con los siguientes datos
Patente patente2 = new Patente("HM", 1515); //Lo mismo de arriba
TablaDePatentes ClaseTablaPatente = new TablaDePatentes(); //Creamos algo de tipo
TablaDePatentes
Patente[] tabla = ClaseTablaPatente.getTabla(); //Hacemos uso del getTable() que te comentado
antes para trabajar con el array Patente[ ]
tabla[0] = patente; //Aadimos las patentes creadas mas arriba
tabla[1] = patente2; //Lo mismo
Patente patenteParaBuscarTRUE = new Patente("PV", 1415); //Creamos una patente que
buscaremos que dara TRUE al ser igual que la primera creada
Patente patenteParaBuscarFALSE = new Patente("SP", 1111); //Creamos otra patente que
buscaremos que dara FALSE al no existir arriba
System.out.println(ClaseTablaPatente.buscar(patenteParaBuscarTRUE)); //Hacemos uso del
metodo buscar con la patente que devolvera true
System.out.println(ClaseTablaPatente.buscar(patenteParaBuscarFALSE)); //Y lo mismo para la
de false.
}
}