# Hilfe bei Java Hasübung



## Taren (19. Okt 2016)

Hallo,

ich hab ein Problem bei einer Hausübung. Ich verstehe die Angabe nicht und hoffe ihr könnte mir helfen. Ich soll für folgende Angabe ein Quellcode schreiben:

"Schreiben Sie eine Klasse 'DenseIntervals' mit einer parameterlosen Konstruktor und der Methode 'public double findDense(double[] points, double width)'. Der Aufruf 'findDense(points, width)' soll einen Wert x zurückgeben, sodass die Anzahl der Werte in 'points', die im Intervall [x, x+width] liegen, maximal ist."

Wäre euch echt für eine Lösung dankbar... ich hab keine Ahnung, was eigentlich gesucht werden.


----------



## Salo (19. Okt 2016)

Hier solltest du nur mit konkreten problemen kommen.
Falls dier jemand die Hausaufgaben machen soll, dann erstelle deinen Thread im Forum "HAUSAUFGABEN".


----------



## Robat (19. Okt 2016)

@Salo hat recht. Hier macht dir niemand deine Hausaufgaben 

Versuch deine Java-Kenntnisse anzuwenden und stell konkrete Fragen - dann wird dir auch geholfen 

Die Klasse, den Konstruktor und die Methode (an sich ohne wirkliche funktionalität) solltest du ja zmd alleine anlegene können 

Gruß
Robert


----------



## VfL_Freak (19. Okt 2016)

Moin,



Taren hat gesagt.:


> ich hab keine Ahnung, was eigentlich gesucht werden


ein kleiner Tipp hierzu  
*Dense *bedeutet *Dichte*, hier also wohl die Anzahl der Werte in points !!

Gruß Klaus


----------



## Xyz1 (19. Okt 2016)

Spoiler: Mögliche Lösung:





```
class DenseIntervals {
    DenseIntervals() {
    }
    public double findDense(double[] points, double width) {
        double res = Double.NaN;
        int max = 0;
        for (int i = 0; i < points.length; i++) {
            int tmp = 0;
            for (int j = i; j < points.length; j++) {
                if (points[j] <= points[i] + width) {
                    tmp++;
                }
            }
            if (tmp > max) {
                res = points[i];
                max = tmp;
            }
        }
        return res;
    }
    public static void main(String[] args) {
        Random ran = new Random();
        double[] array = {
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble()
        };
        System.out.println(Arrays.toString(Arrays.stream(array).map((double operand) -> (int) (operand * 100) / 100.0).toArray()));

        DenseIntervals di = new DenseIntervals();
        double res = di.findDense(array, 0.33);
        System.out.println("res = " + res);
    }
}
```



width: 0.33

```
[0.33, 0.66, 0.8, 0.77, 0.32, 0.43]
res = 0.6642645963433187
```

0.66 + 0.33 ist 0,99. Die "Punkte" 0.66, 0.8 und 0.77 liegen im Intervall [0.66, 0.99].

Der Algo ist nicht optimiert...

Edit: Bei Streams hab ich jetzt erstmal einen abgebrochen. 
Edit 2: Merke gerade, vielleicht hab ich etwas an der Aufgabenstellung nicht verstanden...
Edit 3: Studierst du Mathe o. Ä.?



Spoiler: Verbessert:





```
class DenseIntervals {
    DenseIntervals() {
    }
    public double findDense(double[] points, double width) {
        double res = Double.NaN;
        int max = 0;
        for (int i = 0; i < points.length; i++) {
            int tmp = 0;
            for (int j = 0; j < points.length; j++) {
                if (points[i] <= points[j] && points[j] <= points[i] + width) {
                    tmp++;
                }
            }
            if (tmp > max) {
                res = points[i];
                max = tmp;
            }
        }
        return res;
    }
    public static void main(String[] args) {
        Random ran = new Random();
        double[] array = {
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble(),
            ran.nextDouble()
        };
        System.out.println(Arrays.toString(Arrays.stream(array).map((double operand) -> (int) (operand * 100) / 100.0).toArray()));

        DenseIntervals di = new DenseIntervals();
        double res = di.findDense(array, 0.5);
        System.out.println("res = " + res);
    }
}
```


----------



## JCODA (19. Okt 2016)

VfL_Freak hat gesagt.:


> Moin,
> 
> 
> ein kleiner Tipp hierzu
> ...



setzen, 6. Falsch. Was getan werden muss, steht doch eindeutig dabei:_ Der Aufruf 'findDense(points, width)' soll einen Wert x zurückgeben, sodass die Anzahl der Werte in 'points', die im Intervall [x, x+width] liegen, maximal ist._


----------

