orcid.org/0000-0002-8243-2186
SOLUCIONES NUBEPUNTOS
1. Un
método tal que dado un valor real nx devuelva el número de puntos que tienen
abscisa mayor de nx.
// Esquema de
filtro+contador. Normalmente los contadores se definirían Integer pero por
// compatibilidad
con el método count de Java 8 devolvemos un Long
public Long getNumPuntosAbsMayor(Double nx) {
Long cont=0L; // La L indica que
es un Long
for (Punto p:nube){
if (p.getX().compareTo(nx)>0){
cont++;
}
}
return cont;
}
// Java 8
public Long getNumPuntosAbsMayor(Double nx) {
return nube.stream().filter(x->x.getX().compareTo(nx)>0).count();
}
2. Un
método tal que dado un valor de TipoCuadrante devuelva el número de puntos en
ese cuadrante, no olvide los puntos sobre los ejes.
public Long
getNumPuntosCuadrante(TipoCuadrante t){
Long cont=0L; // La L indica que es un Long
for(Punto p: nube){
if (p.getCuadrante().equals(t)){
cont++;
}
}
return cont;
}
// Java 8
public Long
getNumPuntosCuadrante(TipoCuadrante t){
return nube.stream().filter(p->p.getCuadrante().equals(t)).count();
}
3. Un
método tal que dado un valor real d devuelva el número de puntos cuya distancia
al origen es menor que d.
// igual que los anteriores
public Long getNumPuntosDistOrigenMenor(Double d) {
Long
cont= 0L;
for (Punto p:nube){
if (p.getDistanciaAlOrigen().compareTo(d)<0){
cont++;
}
}
return cont;
}
// Java 8
public Long
getNumPuntosDistOrigenMenor(Double d) {
return nube.stream().
filter(x->x.getDistanciaAlOrigen().compareTo(d)<0).count();
}
4. Devuelva
un Punto que sea el centro de gravedad de la nube. Esto es, el punto cuyas
coordenadas son la media de las coordenadas de los puntos.
// Esquema de suma
con media aritmética al final
public Punto getCentroGravedad() {
Double sumx=0.,sumy=0.;
for(Punto p:nube){
sumx = sumx + p.getX();
sumy = sumy + p.getY();
}
return new PuntoImpl(sumx/nube.size(),sumy/nube.size());
}
// En Java 8 podemos
trabajar con la media directamente
public Punto getCentroGravedad() {
Double avgx = nube.stream().
collect(Collectors.averagingDouble(Punto::getX));
Double
avgy = nube.stream().
collect(Collectors.averagingDouble(Punto::getY));
return new PuntoImpl(avgx,avgy);
}
5. Devuelva
si existe algún punto sobre el eje de abscisas.
// esquema existe
public Boolean existePuntoEjeAbscisas() {
Boolean res=false;
for(Punto p:nube){
if (p.getY().equals(0.)){
res=true;
}
}
return res;
}
// En Java 8
public Boolean existePuntoEjeAbscisas() {
return nube.stream().anyMatch(x->x.getY().equals(0.));
}
6. Dado
un Punto p y un radio r devuelva si existe algún punto dentro del círculo de
centro p y radio r. (Esquema existe)
// esquema existe
public Boolean existePuntoDentroCirculo(Punto
c, Double r) {
Boolean res=false;
for(Punto p:nube){
if (p.getDistanciaOtroPunto(c).compareTo(r)<0){
res=true;
}
}
return res;
}
// En Java 8
public Boolean
existePuntoDentroCirculo(Punto c, Double r)
{
return nube.stream().
anyMatch(x->x.getDistanciaOtroPunto(c).compareTo(r)<0);
}
7. Dado
un valor real d, devuelve si es cierto que todos los puntos están a una
distancia al origen menor que d.
// esquema para todo
public Boolean estanTodosADistMenor(Double
d) {
Boolean res=true;
for(Punto p:nube){
if (p.getDistanciaAlOrigen().compareTo(d)>0){
res=false;
}
}
return res;
}
// En Java 8
public Boolean
estanTodosADistMenor(Double d) {
return nube.stream().
allMatch(x->x.getDistanciaAlOrigen().compareTo(d)<0);
}
8. Devuelve
el Punto más lejano al origen de coordenadas.
//Máximo usando un
comparator y el método max de la clase Collections. En Java 7 el
// Comparator es una
clase que se debe definir aparte
public class
ComparadorDistanciaOrigen implements Comparator<Punto> {
public int compare(Punto p, Punto q){
return p.getDistanciaAlOrigen().compareTo(q.getDistanciaAlOrigen());
}
}
public Punto
getMasLejanoOrigen() {
return Collections.max(nube, new
ComparadorDistanciaOrigen());
}
// En Java 8 no hace
falta definir la clase Comparator sino que usamos la propiedad
// distanciaAlOrigen
de Punto junto con el método comparing. El get es necesario por si la
// colección está
vacía.
public Punto
getMasLejanoOrigen() {
return nube.stream().
max(Comparator.comparing(Punto::getDistanciaAlOrigen)).get();
}
9. Dado
un Punto p, devuelva el punto de la nube más cercano.
// Es un problema de
mínimo que tiene la dificultad de que el Comparator debe tener un
// atributo (base) que
es el punto al que le calculamos el vecino y que debe ser argumento
// en el constructor
public class
ComparadorDistanciaPunto implements Comparator<Punto> {
Punto base;
public
ComparadorDistanciaPunto(Punto p){
base=p;
}
public int compare(Punto p1, Punto p2){
return p1.getDistanciaOtroPunto(base).
compareTo(p2.getDistanciaOtroPunto(base));
}
}
public Punto
getPuntoMasCercano(Punto p) {
return Collections.min(nube, new
ComparadorDistanciaPunto(p));
}
// Esto es un mínimo
con Comparator aunque eb Java 8 ahora no nos basta con invocar a un
// método get, sino
que hay que definir el Comparator, aunque no es necesaria una clase y
// se puede hacer en
el mismo código de NubeImpl mediante una lambda expresión.
public Comparator<Punto>
comparadorDistanciaPunto(Punto base){
return (x,y)->
x.getDistanciaOtroPunto(base).
compareTo(y.getDistanciaOtroPunto(base));
}
public Punto getPuntoMasCercano(Punto p) {
return nube.stream().min(comparadorDistanciaPunto(p)).get();
}
10. Dado
un valor real d, devuelva una NubePuntos con aquellos que estén a una distancia
menor que d del origen.
// Este es un
esquema de filtro, como queremos encapsular la colección de Punto devolvemos
// un objeto NubePuntos
y no un List<Punto>. Para ello nos hace falta un constructor de
// NubePunto a
partir de un List<Punto>. Este
constructor será private y sólo se usará en
// este método. El
constructor público será leyendo desde un fichero. De esta manera el
// atributo de tipo
List<Punto> queda oculto.
public NubePuntos
getPuntosMenorDistanciaOrigen (Double d){
List<Punto>fil=new ArrayList<Punto>();
for (Punto p:nube){
if (p.getDistanciaAlOrigen().compareTo(d)<0){
fil.add(p);
}
}
return new NubePuntosImpl(fil);
}
// En Java 8 el
filtro se consigue con el método filter para seleccionar y el método
// collect para
devolver una Colección de tipo List en este caso.
public NubePuntos
getPuntosMenorDistanciaOrigen (Double d){
List<Punto> fil = nube.stream().
filter(x->x.getDistanciaAlOrigen().compareTo(d)<0).
collect(Collectors.toList());
return new NubePuntosImpl2(fil);
}
No hay comentarios:
Publicar un comentario