Problemas - Universidad Politécnica de Madrid

Dpto. Ingeniería de Sistemas Telemáticos
Universidad Politécnica de Madrid
ETSI Telecomunicación,CiudadUniversitaria,28040Madrid
FUNDAMENTOS DE PROGRAMACIÓN. SEPTIEMBRE 2002.
Normas de examen:
o Con libros y apuntes.
o Duración: 90 minutos
o Responda a cada bloque de preguntas en hojas separadas
o NO SE CONTESTARÁ NINGUNA PREGUNTA DURANTE EL EXAMEN
Problema 1
Sea el siguiente Código:
class Nacional {
private String Nombre;
private int dni;
private char letra;
public Nacional (String Nombre, int dni, char letra) {
this.Nombre = Nombre;
this.dni = dni;
this.letra = letra;
}
public String DimeNombre(){ return Nombre; }
public int DimeDni
(){ return dni;
}
public char DimeLetra
(){ return letra;}
public String DimeNif
(){ return ""+dni+letra; }
}
class Extranjero {
private String Nombre;
private int
NumPasaporte;
public Extranjero (String Nombre, int Pasaporte){
this.Nombre = Nombre;
this.NumPasaporte = Pasaporte;
}
public String DimeNombre
(){ return Nombre; }
public int DimeNumPasaporte(){ return NumPasaporte;
}
}
Se desea que el siguiente programa funcione correctamente:
public static void main (String args[]){
Persona p1 = new ???? ;
System.out.println ("p1:"+p1.DimeNombre()+" "+p1.Identificacion ());
}
donde una persona puede ser tanto nacional como extranjero.
Problema 1.1 (2 puntos)
Proponga una solución basada en crear una clase llamada Persona, para que sin modificar las clases
Nacional ni Extranjero, el método main anterior funcione correctamente. Complete la línea
“ Persona p1 = new ???? ;” para este caso.
Solución:
class Persona {
private String Nombre ="";
private String identificacion ="";
public Persona (Nacional n) {
Nombre = n.DimeNombre();
identificacion = n.DimeNif ();
}
public Persona (Extranjero e) {
Nombre = e.DimeNombre ();
identificacion = ""+e.DimeNumPasaporte();
}
public String DimeNombre () { return Nombre; }
public String Identificacion () { return identificacion; }
}
…
public static void main (String args[]){
Persona p1 = new Persona (new Nacional (“Pepe”, 999999,'A' )) ;
System.out.println ("p1:"+p1.DimeNombre()+" "+p1.Identificacion ());
}
Problema 1.2 (2 puntos)
Proponga una solución basada en crear una Interface llamada Persona y haga las modificaciones
necesarias en el código de las clases Nacional y Extranjero para que funcione correctamente el
método main anterior. Complete la línea “Persona p1 = new ???;” para este caso.
Solución:
…
interface Persona {
public String DimeNombre ();
public String Identificacion ();
}
class Nacional implements Persona {
private String Nombre="";
private int dni=0;
private char letra='A';
…
public String Identificacion
(){ return ""+dni+letra;}
}
class Extranjero implements Persona {
private String Nombre="";
private int
NumPasaporte=0;
…
public String Identificacion
(){ return ""+NumPasaporte;}
}
…
public static void main (String args[]){
Persona p1 = new Nacional (“Pepe”, 999999,'A' ) ;
System.out.println ("p1:"+p1.DimeNombre()+" "+p1.Identificacion ());
}
Problema 2 (3 puntos)
Escribir un programa que imprima por pantalla todos los pares de enteros positivos (a, b) tales que
a < b < 1000 y que (a2 + b2 + 1)/(ab) sea un entero.
public class pares {
static public void main (String args[]) {
for (int b= 1; b <= 1000; b++)
for (int a=1; a < b; a++)
if ( ( (a*a + b*b + 1) % (a*b)) == 0)
System.out.println(a + " " + b);
}
}
Problema 3 (3 Puntos)
Suponga que la siguiente clase se utiliza para almacenar información sobre una persona.
public class Persona {
int dni;
String nombre;
String direccion;
Persona padre;
Persona madre;
public Enumeration Antepasados() {}
}
Los campos nombre, dni y direccion almacenan los datos de la persona. En los campos padre y
madre se almacenan referencias a sus padres, o el valor null si estos no se conocen. El método
Antepasados devuelve una enumeración que sirve para recorrer todos los antepasados conocidos de
la persona.
Nota: podrán existir otros atributos y métodos, pero no son de interés para este ejercicio.
Implemente el método Antepasados, y todos los elementos necesarios para que funcione.
Solución 1
En esta solución creo un vector donde almaceno todos los antepasados
de la persona.
El padre y la madre se almacenan directamente.
Los abuelos y antepasados anteriores se almacenan calculando
previamente sus antepasados.
La enumeración que devuelvo es la que me proporciona el vector creado.
public Enumeration Antepasados() {
Vector v = new Vector(); // Este vector almacena los antepasados.
if (padre != null) {
v.add(padre); // Guardo el padre.
// Guardo los antepasados del padre.
Enumeration e = padre.Antepasados();
while (e.hasMoreElements())
v.add(e.nextElement());
}
if (madre != null) {
v.add(madre); // Guardo la madre.
// Guardo los antepasados de la madre.
Enumeration e = madre.Antepasados();
while (e.hasMoreElements())
v.add(e.nextElement());
}
return v.elements(); // Retorno el Enumeration del Vector.
}
Solución 2
Es similar a la solución 1, pero creo una clase independiente que
implementa la interface Enumeration.
public Enumeration Antepasados() {
return new EnumerationPers(this);
}
class EnumerationPers implements Enumeration {
private Vector v; // Este vector almacena los antepasados.
EnumerationPers(Persona p) {
v = new Vector();
if (p.padre != null) {
v.add(p.padre); // Guardo el padre.
// Guardo los antepasados del padre.
Enumeration e = p.padre.Antepasados();
while (e.hasMoreElements())
v.add(e.nextElement());
}
if (p.madre != null) {
v.add(p.madre); // Guardo la madre.
// Guardo los antepasados de la madre.
Enumeration e = p.madre.Antepasados();
while (e.hasMoreElements())
v.add(e.nextElement());
}
}
public boolean hasMoreElements() {
return ! v.isEmpty();
}
public Object nextElement() throws NoSuchElementException
{
if (v.isEmpty()) throw new NoSuchElementException();
return v.remove(0);
}
}
Solución 3
Creo también una clase independiente que implementa la interface
Enumeration.
En vez de crear un vector para almacenar los antepasados, lo que
guardo son referencias a los padres, y enumerados a los abuelos, que
son los que usaré para devolver todos los antepasados.
class EnumerationPers implements Enumeration {
private Persona padre, madre; // Los padres.
private Enumeration epadre, emadre; // Abuelos y anteriores.
EnumerationPers(Persona p) {
padre = p.padre;
madre = p.madre;
epadre = padre != null ? padre.Antepasados() : null;
emadre = madre != null ? madre.Antepasados() : null;
}
public boolean hasMoreElements() {
return (padre != null) || (madre != null);
}
public Object nextElement() throws NoSuchElementException
{
if (padre != null) {
if (epadre.hasMoreElements()) {
return epadre.nextElement();
} else {
Object res;
res = padre;
padre = null; // Ya he terminado con los ancestros paternos
return res;
}
}
if (madre != null) {
if (emadre.hasMoreElements()) {
return emadre.nextElement();
} else {
Object res;
res = madre;
madre = null; // Ya he terminado con los ancestros maternos
return res;
}
}
throw new NoSuchElementException();
}
}