# Array Aufgabe



## derHulki (20. Mai 2015)

Ich komme mit Containerklassen, speziell Arrays noch nicht  zurecht.
Hier eine Aufgabe:

Ergänzen Sie die folgende Methode minMax() um folgende Funktionalität:Es soll sowohl der größte als auch der kleinste Wert innerhalb des übergebenen Arrays zahlen ermittelt werden. Die beiden Werte sollen dann in einem zweielementigen Array zurückgegeben werden, wobei der kleinere an Position 0 und der größere an Position 1 stehen soll.

(Sie dürfen davon ausgehen, dass der größte Wert nicht dem kleinsten Wert entspricht.)

public int[] minMax(int[][] zahlen) {

Ich hatte die Aufgabe probiert, aber habe nur Blödsinn produziert.
Könnte mir jmd. erklären wie ich hier am besten starten könne? Was die wichtigesten Schritte beim arbeiten mit Arrays sind?

mfg


----------



## Maggot (20. Mai 2015)

Zeig doch einmal das was du probiert hast. Und wird der Methode wirklich ein 2Dimensionaler Array übergeben? (public int[] minMax(int[][] zahlen)


----------



## strußi (20. Mai 2015)

eines übergebene Arrays  also nix mit [][] nur []

public int [] minMax( int[] zahlen){
 SPOILER:
 int min =Zahlen[ 0];
 int max =zahlen[ 0];
 int[] retval =new int[2];
for(...

oder direkt
SPOILER 2
methode
int[] retval ={zahlen[ 0], zahlen[ 0]};
for( ...


----------



## derHulki (21. Mai 2015)

Habe die Aufgabe kopiert und in der Tat, im Parameter wird ein 2dimensionales Array übergeben.

Ich habe das Thema Container leider nicht sogut verstanden, deshalb habe ich nicht wirklich einen Code.
Bei mir macht schon die deklaration der Arrays probleme.


```
public int[] minMax(int[][] zahlen){
        int[] res = {zahlen[][]};
        for(int[] x : zahlen){
            for(int y : x){
                
            }
        }
    
    }
```

Also ich denke, mit diesen Forschleifen wird jetzt der Parameter(2dim Array) komplett durchlaufen oder?
Jetzt, wie kann ich irgendwie vergleichen bzw. angeben, dass er  das min und max nehmen soll?
Oben geb ich auch int[] res = {zahlen[][]}; an, ist das so korrekt, also ich möchte sozusagen ein leeres Arrays für res übergeben, welches dann verglichen werden soll mit dem Parameter?

mfg


----------



## strußi (21. Mai 2015)

ja wird er

typ[] =wie eine CD-Regal. 
typ[][] =wie ein kasten bier.

damit du dir das besser vorstellen kannst wäre eine "alte" for-schleife nicht schlecht.

```
int rows =5;
int cols =10
//erstellen
int[][] name = new int[ row][ cols];
// befüllen
for( int row =0; row <name.length; row++){
 for( int col =0; col < name[ row].length; col++){
   name[ row][ col] = row +col;
 }
}
//ausgeben
for( int row =0; row <name.length; row++){
 for( int col =0; col < name[ row].length; col++){
   System.out.print( name[ row][ col] +" ");
 }
 System.out.println("");
}
```


----------



## derHulki (21. Mai 2015)

Ok habs jetzt etwas besser verstanden, bei deinem Beispiel wird sozusagen ein Array mit 5 Zeilen und jeweils 10 int Spalten erzeugt.

Zurück zur Aufgabe:

```
public class MinMax {
    public int[] minMax(int[][] zahlen) {
        int[] res = {zahlen[0][0], zahlen[0][0]};
        for (int[] i = 0; i<zahlen.length; i++){
            for(int o =0; o<zahlen[i].length; o++){
                res[0] = 
                res [1] =
            }
        }
    }
}
```

Hier mal der Anfang dazu.
Eigentlich wollte ich erst der Variable res leere Arrays von zahlen übergeben, warum funktioniert das nicht?
Sowas, int[] res = {zahlen[][], zahlen[][]}
Das ergab aber einen Fehler, jetzt dachte ich mir, mache ich sie 0, aber was hab ich genau damit erreicht? Jetzt ist das Arrays von Zahlen 0 Zeilen 0 Spalten 0 intwerte. Bitte um erklärung.

Jetzt muss ich ja das int[] res Array zurückgeben und an [0] das Minimum und and [1] das Maximum speichern. Wie kann ich das machen?
Vieleicht mit den Vergleichsoperatoren? Und warum kann ich überhaupt res[0] und [1] vergleichen/übergeben, wenn ich es voher mit zahlen[0][0], zahlen[0][0] deklariert hab. Ich check das nicht.

Hoffe ihr/du versteht was ich meine und könnt mir helfen.

mfg


----------



## strußi (21. Mai 2015)

also wenn du sagst int[] res = zahlen[][];  =weist du welchen wert du aus dem ArrayArray haben möchtest? das programm nicht, ich auch nicht.

also die erste zelle mittes koordinaten(0/0) bestimmen, wie beim schach jedes feld einen buchstaben und eine zahl hat, das bestimmt wo es ist.


klar mit vergleichsoperatoren wie sonst?

Aufgabenstellung
du hast also eine unbekannt große getränkekiste, in der ist eine flasche die fast leer ist und eine die voller als der rest ist.
dein problem ist, du kannst nicht durch das glas sehen.

jetzt hast du startwerte für das min/Max (res[0] =min res[1] =max. 
nun gehst du her, "nimmst jede flasche in die hand" und schaust ob mehr drin ist als dein jetziges maximum, dann wird des dein neues maximum (res[1] <zahlen.... res[1] =zahlen ...) oder ob weniger drin ist als dein minimum, dann wird das dein neues min(res[0] >zahlen.... res[0] =zahlen ...) anschließend den "return res" nicht vergessen

lösung in 1er minute programmierbar.


----------



## derHulki (21. Mai 2015)

Also ich hab das mal so gemacht:


```
public class MinMax {
        public int[] minMax(int[][] zahlen) {
            int[] res = {zahlen[0][0], zahlen[0][0]};
            for (int[] i = {0}; i[0]<zahlen.length; i++]{
                for(int o =0; o<zahlen[i].length; o++){
                    res[0] = (o< res[0] ? o : res[0]);
                    res [1] = (o> res[1] ? o : res[1]);
                }
            } return res;
        } 
    } public static void main(String[]args){
}
}
```

Der Compiler liefter mir in der ersten forschleife bei i++ einen Fehler. Denke das hat was mit int und Array zutun, wie lass ich ein Array hochzählen?

So nochmal zum Verständnis wegen dem Code:
Ich defeniere int[] res mit 2 Werten von der Variable Zahlen. Hier fange ich mit der Zelle [0][0] für das min und [0][0] für das max an.
Richtig soweit?
Dann durchläuft er die 2 forSchleifen um alle Zellen von dem Array zuprüfen.

Danach habe ich mir gedacht das res[0] an der position 0 jeweils mit der Zähler in der forschleife verglichen wird.
Genauso wie  res[1].
Also ist sozusagen mein res[0] die Kooridinaten des eingegeben Parameters int[][] zahlen an der Stelle int[0][0] und damit wird es dann immer verglichen? Richtig?

mfg


----------



## Saheeda (22. Mai 2015)

Die Syntax einer for-Shleife ist immer gleich, egal, ob du über eine Liste/Array/Collection iterierst, oder irgendwie anders nen Zähler brauchst:


```
for (int i = 0; i < zahlen.length; i++) {
			for (int o = 0; o < zahlen[i].length; o++) {
				
	}
}
```


----------



## strußi (22. Mai 2015)

dein problem ist, du nimmst den zähler-wert aus der zweiten schleife um zu testen.
du MUSST auf die das zahlen[ i][ o] zugreifen und dagegen mit dem res[ 0] und res[ 1] testen.

du kannst auch ne if() else if() machen


----------



## strußi (22. Mai 2015)

anmerkung: hast du meinen code nicht angeschaut, bzw. nicht verstanden? da steht genau, wie du auf die einzelne zelle in einem zahlen[][] zugreifen kannst.

lese dir die grundlagen arrays noch einmal durch, weil das was du codiert hast, ist pathologisch


----------



## derHulki (22. Mai 2015)

So auf ein neues.

Es gibt ja viele Möglichkeiten eine Aufgabe zu lösen, hauptsache sie ist am Ende gelöst 

Hier der alte Code:

```
public class MinMax {
    public int[] minMax(int[][] zahlen) {
        int[] res = {zahlen[0][0], zahlen[0][0]};
        for (int i = 0; i<zahlen.length; i++){
            for(int o =0; o<zahlen[i].length; o++){
                res[0] = (zahlen[ i][ o]< res[0] ? zahlen[ i][ o] : res[0]); 
                res [1] =(zahlen[ i][ o]> res[1] ? zahlen[ i][ o] : res[1]);
            }
        }return res;
    }
}
```

Hier mit if/else:


```
public class MinMax1 {
    
        public int[] minMax(int[][] zahlen) {
            int[] res = {zahlen[0][0], zahlen[0][0]};
            for (int i = 0; i<zahlen.length; i++){
                for(int o =0; o<zahlen[i].length; o++){
                    if(res[0]>zahlen[i][o]){
                        res[0] = zahlen[i][o];
                        
                    }else if(res[1]<zahlen[i][o]){
                        res[1] = zahlen[i][o];
                        
                    }
                }
            } return res;
        }
    }
```

Sind dort noch Fehler oder passen die Codes so?

mfg


----------



## strußi (22. Mai 2015)

würde sagen stimmt so, aber probier es doch einfach mal aus, indem du ein zahlen[][] mit werten befüllst es durch die methode jagst und anschließend das ergebnis ausgibst.

mein tipp
nimm kein o für eine zählervariable weil es der 0 ähnelt.

im allgemeinen nimmt man "sprechende" variablennamen, für ein [][] z.b. int r und int c für row und column, das macht das programmieren einfacher


----------

