Problema 1. (3 puntos) Segundo Parcial de Programación 2 Curso 2010/2011

Segundo Parcial de Programación 2
Curso 2010/2011
Problema 1. (3 puntos)
Dada la siguiente clase:
1 public class Vector3D {
2 private double x;
3 private double y;
4 private double z;
5 public Vector3D(double x, double y, double z) {
6
this.x = x; this.y = y; this.z = z;
7 }
8 public void add(Vector3D other) {
9
x += other.x; y += other.y; z += other.z;
10 }
11 public void normalize() {
12
double mag = Math.sqrt(x*x + y*y + z*z);
13
x = x/mag; y = y/mag; z = z/mag;
14 }
15 public static Vector3D mistery(Vector3D v1, Vector3D v2) {
16
Vector3D result = new Vector3D(v1.x, v1.y, v1.z);
17
v2.normalize(); result.add(v2); return result;
18 }
19 public String toString() {
20
return “x=” + String.valueOf(x)
21
+ “ y=” + String.valueOf(y)
22
+ “ z=” + String.valueOf(z);
23 }
24 }
Y dado el siguiente código que la utiliza:
1
2
3
4
5
6
Vector3D first = new Vector3D(1.0, 2.0, 3.0);
Vector3D second = new Vector3D(0.0, 0.0, 3.0);
Vector3D third = Vector3D.mistery(first, second);
println(“first: “ + first.toString());
println(“second: “ + second.toString());
prinltn(“third: ” + third.toString());
Indicad qué escribe dicho código en la pantalla. Para ello, mostrad cómo se
ejecutan las diferentes llamadas a métodos indicando en todo momento cada uno
de los objetos referenciados, ya sea por las variables del programa principal, por
los parámetros, variables locales, o por la referencia mágica this (cuando ésta
existe).
Problema 2. (3 puntos)
Un amigo biólogo está analizando secuencias de ADN y quiere que le ayudemos a
buscar fragmentos interesantes dentro de ellas. Como está trabajando con ADN
muy deteriorado, en vez de un único bloque de ADN, lo que obtiene después del
análisis es una cadena que contiene espacios en blanco en las partes que no se han
podido recuperar. Diremos que un fragmento es interesante si contiene como
subcadena a alguno de los marcadores predefinidos. Para representar estos
Segundo Parcial de Programación 2
Curso 2010/2011
marcadores usaremos el vector de cadenas MARKERS, que estará predefinido en
nuestro programa.
Lo que quiere es que le implementemos una función para saber cuántos
fragmentos interesantes hay en los pedazos de ADN que ha podido recuperar. Es
decir:
1 public class ADNAnalyser extends ConsoleProgram {
2 private String[] MARKERS = { “taca”, “gata”, “caca” };
3 private int countInteresting(String dna) {
4
¿?
5 }
6 public void run() {
7
String analysis = readLine(“Resultado del análisis: “);
8
int numInterentingFragments = countInteresting(analysis);
9
println(“Número de interesantes: “ + numInterestingFragments);
10 }
11 }
Recordad el uso de la descomposición en métodos auxiliares y la elección de
nombres adecuados tanto para las variables como para los métodos.
Algunos métodos útiles


class StringTokenizer:
o new StringTokenizer(String str): devuelve una instancia de
StringTokenizer que lee trozos de la cadena str separados por
caracteres en blanco.
o new StringTokenizer(String str, String delims): devuelve una
instancia de StringTokenizer que lee trozos de la cadena str
separados por alguno de los caracteres en delims.
o boolean hasMoreTokens(): indica si quedan más trozos que extraer
del StringTokenizer.
o String nextToken(): devuelve el siguiente trozo disponible.
class String:
o char charAt(int index): devuelve el carácter correspondiente a la
posición index.
o String substring(int begin, int end): obtiene la subcadena que
empieza en la posición begin y se extiende hasta, pero no incluye,
end.
o boolean equals(String other): indica si la cadena receptora es igual a
la dada.
o boolean equalsIgnoreCase(String other) indica si la cadena
receptora es igual a la dada, ignorando diferencias entre mayúsculas
y minúsculas.
o int indexOf(String s): devuelve el índice de la primera aparición de s
en la cadena receptora o -1 si no aparece.
o int indexOf(String s, int begin): igual que la anterior, pero solamente
considerando las posiciones de la cadena receptora a partir de begin.
o String toUpperCase(): devuelve la cadena que contiene los mismos
caracteres que la cadena receptora pero en mayúsculas.
Segundo Parcial de Programación 2
Curso 2010/2011
o String toLowerCase():devuelve la cadena que contiene los mismos
caracteres que la cadena receptora pero en minúsculas.
Problema 3. (4 puntos)
Queremos hacer una clase para representar polinomios. Recordad que un
polinomio es una expresión de la forma:
𝑃(𝑥) = 𝑎0 + 𝑎1 𝑥 + 𝑎2 𝑥 2 + ⋯ + 𝑎𝑛 𝑥 𝑛
dónde 𝑛 es el grado del polinomio (𝑎𝑛 ≠ 0). Para un polinomio de grado 𝑛
necesitaremos 𝑛 + 1 coeficientes.
Por tanto definiremos una clase, denominada Polynomial, con las siguientes
operaciones:
 new Polynomial(int maxDegree): que creará un polinomio con grado
máximo degree.
 int getMaxDegree(): devuelve el grado máximo del polinomio.
 int getDegree(): devuelve el grado correspondiente al coeficiente no nulo
de grado más alto. Si todos los coeficientes son nulos, devuelve 0.
 void setCoefficient(int degree, double coeff): que indica que el
coeficiente del grado degree es coeff. Si el grado es superior al definido
como máximo para el polinomio, la operación no hace nada.
 double getCoefficient(int degree): que devuelve el coeficiente de ese
grado dentro del polinomio. Si el grado es superior al definido como
máximo para el polinomio, devuelve 0.0
 static Polynomial add(Polynomial p1, Polynomial p2): que devuelve la
suma de los dos polinomios. Recordad que el grado de la suma es el grado
correspondiente al polinomio de grado más alto. Además, querremos que el
resultado sea un polinomio normalizado.
 void normalize(): ajusta el polinomio de manera que el coeficiente de
grado máximo no sea nulo (excepto para el caso en que solamente quedara
el coeficiente de grado 0). Después de normalizar, getDegree y
getMaxDegree devuelven el mismo valor.
Lo que se pide es que diseñéis e implementéis la clase Polynomial con los métodos
y constructores mostrados.
Recordad el uso de la descomposición en métodos auxiliares y la elección de
nombres adecuados tanto para las variables como para los métodos.