# Zweidimensionales array kopieren und in eindimensionales überführen



## jono (21. Nov 2019)

Guten Morgen, 

Unzwar möchte ich wie schon der Titel sagt die Werte eines zweidimensionalen Arrays in ein eindimensionales kopieren. Zudem soll der größte Wert jedes einzelnen Arrays weggelassen werden. 
Wichtig ist auch das die Arrays unterschied-
liche Größen haben können. 
Es soll dann wie folgt aussehen:
(new int[][]{{1,11,3,2},{5,-4,6,2,4,2},{8,9,7}}) gibt das Array {8, 7, 5, 4, 3, 2, 2, 2, 1, -4} zurück.
Kann mir da einer behilflich sein, mir ist nicht bewusst geworden wie ich Werte eines zweidimensionalen in ein eindimensionales überführen und noch den max wert weglassen.


----------



## mrBrown (21. Nov 2019)

Wie würdest du es denn per Hand machen?


----------



## jono (21. Nov 2019)

Erstmal eine Tabelle anlegen mit beliebig vielen spalten und Zeilen und diese mit unterschiedlich vielen integer Werten füllen; die größten Zahlen des jeweiligen Arrays auslassen und dann in eine eindimensionale Tabelle überführen.


----------



## mrBrown (21. Nov 2019)

Deine Beschreibung, wie du eine zweidimensionales Array in ein eindimensionales überführst und dabei die größten Zahlen auslässt, ist wirklich "die größten Zahlen des jeweiligen Arrays auslassen und dann in eine eindimensionale Tabelle überführen"? 

Angenommen, dir gibt jemand dieses Array: {{1,11,3,2},{5,-4,6,2,4,2},{8,9,7}}

Was würdest du dann *Schritt für Schritt* machen, damit dieses dabei raus kommt: {8, 7, 5, 4, 3, 2, 2, 2, 1, -4}


----------



## jono (21. Nov 2019)

Sry, ich antworte gleich ich bin noch in einer Vorlesung.


----------



## jono (21. Nov 2019)

{{1,11,3,2},{5,-4,6,2,4,2},{8,9,7}}
Zuerst würde ich aus dem sozusagen 1. Array die 1,3 u. 2 nehmen und die 11 streichen und dasselbe mit den anderen 2 ebenfalls; die 5,-4, 2,4,2 und beim dritten array die 8 und die 7 sodass dann dass folgt - >
{8, 7, 5, 4, 3, 2, 2, 2, 1, -4}


----------



## jono (21. Nov 2019)

Bzw da wir es aufsteigend sortieren sollen noch den Bubble sort verwenden aber das hat ja erstmal nichts mit meiner Frage zu tun


----------



## mrBrown (21. Nov 2019)

jono hat gesagt.:


> Zuerst würde ich aus dem sozusagen 1. Array die 1,3 u. 2 nehmen und die 11 streichen und dasselbe mit den anderen 2 ebenfalls; die 5,-4, 2,4,2 und beim dritten array die 8 und die 7 sodass dann dass folgt - >


Und wenn du jetzt 4376546785 Arrays hast, die jeweils 466597657 Werte haben, dir also nicht merken kannst, welche du gestrichen hast?


----------



## jono (21. Nov 2019)

Vielleicht stelle mich gerade auch an, oder kann der Frage nicht ganz folgen, aber das wäre dann jedes mal das Maximum eines Arrays welches gestrichen wird?..


----------



## jono (21. Nov 2019)

ich*


----------



## mihe7 (21. Nov 2019)

jono hat gesagt.:


> Vielleicht stelle mich gerade auch an, oder kann der Frage nicht ganz folgen, aber das wäre dann jedes mal das Maximum eines Arrays welches gestrichen wird?..


Mal anders, stell Dir vor, Du gibst mir eine x-beliebige Tabelle

```
a11 a12 a13
a21 a22 
a31 a32 a33
```
Jetzt erklärst Du mir allgemein(!) Schritt für Schritt (halt einen Algorithmus), was ich tun muss, um daraus eine "Zeile zu machen". Das Sortieren und Maximum weglassen, kannst Du Dir dabei vorerst sparen.


----------



## jono (21. Nov 2019)

Ich weiß ehrlich gesagt nach mehrmaligem Überlegen nicht weiter.


----------



## tfausw (22. Nov 2019)

Hallo, ich stehe vor dem selben Problem.
Folgendes wäre bis dato jetzt mein Ansatz.

Für das was ich jedoch benötige, ist ein int[] als Rückgabe gefordert. return neu; gibt [I@15db9742 aus, mit System.out.println(Arrays.toString(neu)); ist eben {3,6} die Ausgabe.


```
public static int[] combine(int[][]array) {
        int[] neu = new int [array.length];   
    
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                neu[i] = array[i][j];
            }
        }
        return neu;
    }

public static void main(String[] args) {
    System.out.println(combine(new int[][]{{1,2,3},{4,5,6}}));
    }
}
```


----------



## mihe7 (22. Nov 2019)

```
Sei n := Anzahl der Elemente (aller!) im array
neu := neues Array der Länge n
c := 0
für jede Zeile i in array {
  für jede Spalte j in array[i] {
    neu[c] = array[i][j];
    erhöhe c um 1
  }
}
return neu
```


----------



## tfausw (22. Nov 2019)

Habs übrigens nochmal überarbeitet weil ich teilweise Quark da oben geschrieben habe  return neu gibt [I@15db9742, also {3,6} aus. 
Ist schon spät


----------



## mihe7 (22. Nov 2019)

Mach

```
public static void main(String[] args) {
    System.out.println(Arrays.toString(combine(new int[][]{{1,2,3},{4,5,6}})));
    }
}
```
draus. EDIT: und importiere java.util.Arrays.


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> ```
> Sei n := Anzahl der Elemente (aller!) im array
> neu := neues Array der Länge n
> c := 0
> ...



wenn ich den Algorithmus nun richtig verstanden habe, sollte folgendes umgesetzt werden:


```
int[] neu = new int [array.length];      
        int x = 0;
       
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                neu[x] = array[i][j];
                x++;
            }
        }
       
        return neu;
    }
```

Jedenfalls habe ich es so verstanden. Problem nun nur, dass "x++;" einen Fehler auspuckt. "java.lang.ArrayIndexOutOfBoundsException: 2"
at Xx.Method(Xx.java:20)
at Xx.main(Xx.java:32)


----------



## mihe7 (22. Nov 2019)

Ja, Du hast den ersten Schritt im Algorithmus nicht umgesetzt 


Dein Array enthält zwei Arrays und daher ist array.length==2. Die Anzahl aller Elemente ist im konkreten Fall aber `array[0].length+array[1].length`, hier also 6.


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Dein Array enthält zwei Arrays und daher ist array.length==2. Die Anzahl aller Elemente ist im konkreten Fall aber `array[0].length+array[1].length`, hier also 6.



Klappt in der Tat für 2 Arrays, für x Arrays ist das dann wieder ne andere Sache, muss ich mir im Traum mal paar Gedanken bis Morgen machen .


----------



## tfausw (22. Nov 2019)

So, nun bin ich davon überzeugt, dass wir die x Arrays nun mit array.length ermitteln. Würde es mit einer Zählschleife machen und sagen wir mal "counter" pro Durchgang um 1 erhöhen, um array[n].length letztendlich zu nutzen. Nächste Baustelle ist dann die Umsetzung, falls es vom logischen her richtig ist.


----------



## mihe7 (22. Nov 2019)

Nicht ganz, Du musst für jedes n (0 <= n < array.length) eine Anzahl (z. B. "counter") um array[n].length erhöhen.


----------



## tfausw (22. Nov 2019)

Dann hätten wir quasi also folgendes: 


```
int counter = 0;
        for (int a = 0; 0 <= a && a < array.length; a++) {
        counter++;
    }
```

Nun wäre aber 


```
int[] neu = new int [array[counter].length];
.
.
.
.
.
```

nicht das richtige, oder muss ich das dann auch im weiteren Code noch anpassen?


----------



## kneitzel (22. Nov 2019)

Nein, das ist nicht korrekt. @mihe7 hat ja schon darauf hingewiesen, dass counter nicht um 1 zu erhöhen ist.

Du sollst Äpfel liefern. Du bekommst einfach Zettel, auf denen steht eine Zahl (die gibt dann an, wie viele Äpfel jemand möchte).
Du willst nun wissen, wie viele Äpfel insgesamt notwendig sind.

Was Du derzeit machst:
- Du gehst alle Zettel durch und für jeden Zettel zählst Du einen Zähler um eins hoch.
- Dann nimmst Du den Zettel mit der Nummer deines Zählers und die Zahl darauf ist dann die Anzahl der Äpfel, die Du insgesamt liefern sollst.

Mal davon abgesehen, dass der Code so auch keinen Sinn macht:
- Bedingung 0<=a ist immer gegeben, da du von 0 an hochzählst....
- Das Ergebnis, das da raus kommt, ist doch klar: Wenn Du n mal 1 zu 0 addierst, dann kommt n raus. Also warum adierst Du das erst?

Aber wie gehst Du denn genau bei dem Apfel Beispiel vor?


----------



## tfausw (22. Nov 2019)

JustNobody hat gesagt.:


> Nein, das ist nicht korrekt. @mihe7 hat ja schon darauf hingewiesen, dass counter nicht um 1 zu erhöhen ist.


Korrekt, habe ich verpeilt.

Naja zum Äpfel Beispiel, wenn ich x Zettel mit x Anzahl von Äpfeln kriege, würde ich einfach alle Zettel nehmen und deren Anzahl summieren.

Sprich:


```
int counter = 0;
        for (int a = 0;a < array.length; a++) {
        counter += array[a].length;
    }
```


----------



## mihe7 (22. Nov 2019)

tfausw hat gesagt.:


> würde ich einfach alle Zettel nehmen und deren Anzahl summieren.


Tada. Du würdest aber nicht alle Zettel nehmen, sondern immer einen nach dem anderen


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Tada. Du würdest aber nicht alle Zettel nehmen, sondern immer einen nach dem anderen



Ich würde theoretisch bei folgendem: 


```
int[] neu = new int [array[counter].length];
```

nun ein counter nach dem anderen nehmen .. praktisch ist das wieder so ein Ding


----------



## kneitzel (22. Nov 2019)

tfausw hat gesagt.:


> ```
> int counter = 0;
> for (int a = 0;a < array.length; a++) {
> counter += array[a].length;
> ...



Top, und dann hast Du in counter die benötigte Größe - also dementsprechend kannst Du den Part jetzt bestimmt auch noch anpassen (falls nicht schon längst passiert).


----------



## kneitzel (22. Nov 2019)

tfausw hat gesagt.:


> Ich würde theoretisch bei folgendem:
> 
> 
> ```
> ...



Evtl. weiter im Apfel Beispiel bleiben:
Du hast doch nun ermittelt, wie viele Äpfel insgesamt benötigt werden.

Warum da einen Counter nach dem anderen nehmen? Sind denn Zwischenergebnisse wichtig?

Ich bin gerade am überlegen (und @mihe7 kann da evtl. etwas zu sagen):
Vielleicht hilft es wirklich, die Probleme rigoros zu unterteilen. Software Entwickler achten immer darauf, dass Methoden klein bleiben - und wenn selbst "Profis" das machen um Fehler zu vermeiden, dann kann es doch auch nur gut sein für Anfänger.

Du hast also jetzt den Code, um von einem Zweidimensionalen Array die Anzahl der gespeicherten Werte zu ermitteln. Mach das als eigenständige Methode! Dann teste diese etwas und wenn alles zu funktionieren scheint: Lass die Finger von der Methode und nutze sie nur noch.

Also Du hast dann sowas wie


```
public static int getElementCount(int array[][]) {
  int counter = 0;
  for (int a = 0;a < array.length; a++) {
    counter += array[a].length;
  }
  return counter;
}
```

Wenn Du da jetzt die Finger von läßt, dann kommst Du auch nicht mehr in die Versuchung, da mit irgendwelchen Zwischenergebnissen etwas machen zu wollen!


----------



## tfausw (22. Nov 2019)

Wir hatten ja bei 2 Arrays folgendes:

```
int[] neu = new int [array[0].length + array[1].length];
```
Deswegen dachte ich, dass wir, da wir die insgesamte Anzahl ermittelt haben, dort nun einen counter nach dem anderen sprich [array[n].length] nehmen.

Das ... new int [array[counter].length]; keinen Sinn macht, da sind wir uns vermutlich alle einig, deswegen muss meines Verständnisses nach counter pro Einheit array[n].length +1 ausgeben, bis counter erreicht wurde? Bzw. counter -1 bis 0?


----------



## mihe7 (22. Nov 2019)

tfausw hat gesagt.:


> Deswegen dachte ich, dass wir, da wir die insgesamte Anzahl ermittelt haben, dort nun einen counter nach dem anderen sprich [array[n].length] nehmen.


Dein counter entspricht ja gerade der Summe `array[0].length + array[1].length + .... + array[n].length`, d. h. du musst hier nur schreiben: `int[] neu = new int[counter];`

Mit der Methode von @JustNobody kannst Du die ersten Schritte des Algorithmus einfach so schreiben:

```
// Sei n := Anzahl der Elemente (aller!) im array
int n = getElementCount(array);
// neu := neues Array der Länge n
int[] neu = new int[n];
```

Mal ne dumme Frage, zwischenrein: hast Du den Code in #24 nachträglich eingefügt? Ich frage, weil ich da kein "Bearbeitet" sehe und ich den vorher nicht gesehen habe   Das Gleiche ist mir gerade auch bei einem anderen Thread aufgefallen. Oder liegt es an meinen Augen?


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Dein counter entspricht ja gerade der Summe `array[0].length + array[1].length + .... + array[n].length`, d. h. du musst hier nur schreiben: `int[] neu = new int[counter];`
> 
> Mit der Methode von @JustNobody kannst Du die ersten Schritte des Algorithmus einfach so schreiben:
> 
> ...


Danke schon mal  und nein nicht nachträglich, wenn dann steht bei den Posts ja auch bearbeitet.


----------



## mihe7 (22. Nov 2019)

tfausw hat gesagt.:


> nein nicht nachträglich, wenn dann steht bei den Posts ja auch bearbeitet.


Ja, deswegen habe ich gefragt. Im anderen Thread war das Wort, das ich überlesen habe ungefähr 3 cm hoch... ich erblinde


----------



## tfausw (22. Nov 2019)

Soo, nun haben wir x Arrays in ein eindimensionales Array erfolgreich "umgewandelt". Nächster step wäre, der passiert jedoch vor dem zusammenführen, dass wir die jeweils höchsten Werte der Arrays eliminieren, ich orientiere mich mal an den Werten des Threaderstellers: {1,11,3,2},{5,-4,6,2,4,2},{8,9,7}

Mein Ansatz wäre dieser:

```
int max = 0;
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        if (array[i].length > max) {
            max = array[i][j];
System.out.println(max); // einfach zum überprüfen was rauskommt
        }
    }
}
```

Ausgabe: 1 (aus welchem Grund auch immer), 11 (so weit so gut )

Ausgabe sollte aber sein: 11, 6, 9

Kurz am Ende mein Gedankengang weshalb ich es mir so überlegt habe:
Durch die beiden for Schleifen gehen wir ja durch die Arrays, deshab dachte ich, dass so wie im Code dann die jeweils höchsten Werte ausgegeben werden.


----------



## mihe7 (22. Nov 2019)

Dein Gedankengang ist schon richtig, aber: wenn Du von jedem Array das Maximum haben willst, musst Du das Maximum vor der Untersuchung eines jeden Arrays wieder auf 0 setzen, sonst gilt ja noch das alte Maximum.


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Dein Gedankengang ist schon richtig, aber: wenn Du von jedem Array das Maximum haben willst, musst Du das Maximum vor der Untersuchung eines jeden Arrays wieder auf 0 setzen, sonst gilt ja noch das alte Maximum.


Verstehe.

Hätte auf Anhieb jetzt gesagt, dass ich das dann einfach nach dem Schleifendurchlauf initialisieren lasse, aber das klappt leider nicht.


----------



## mihe7 (22. Nov 2019)

Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:

```
public int getMaximum(int[] arr) {
}
```


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:
> 
> ```
> public int getMaximum(int[] arr) {
> ...




```
public static int getMaximum(int[]arr) {
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
```

wäre meine Lösung für deine Aufgabe.


----------



## kneitzel (22. Nov 2019)

Was wäre, wenn in dem Array nur negative Zahlen wären?


----------



## tfausw (22. Nov 2019)

würde vielleicht dann noch einen Fall für negative Zahlen einbauen? Keine Ahnung


----------



## mihe7 (22. Nov 2019)

Und womit würdest Du dann max initialisieren?


----------



## tfausw (22. Nov 2019)

0?


----------



## kneitzel (22. Nov 2019)

Wenn nur negative Zahlen in dem Array sind, dann würde was als Maximum ausgegeben?

Was ist denn der Wertebereich von Integer?


----------



## tfausw (22. Nov 2019)

wenn nur negative Zahlen im Array sind wäre das Maximum das nächste gegen 0, denke ich mal. Wertebereich war doch irgendwie 2 hoch 32 - -2 32 -1 oder so ähnlich


----------



## kneitzel (22. Nov 2019)

Ja, nur dass das -1 bei den Positiven Zahlen kommt. Und es gibt in der Klasse Integer Konstanten, die den maximalen und minimalen Wert enthalten. Auf was sollte man dann max setzen, damit der Wert angepasst wird?


----------



## tfausw (22. Nov 2019)

-1? Bin bisschen verwirrt gerade


----------



## mihe7 (22. Nov 2019)

Mal andersrum gefragt: wenn Du die Elemente {4, 9, 1} hast, mit welcher Wahrscheinlichkeit ist das Maximum dann 0?


----------



## tfausw (22. Nov 2019)

mihe7 hat gesagt.:


> Mal andersrum gefragt: wenn Du die Elemente {4, 9, 1} hast, mit welcher Wahrscheinlichkeit ist das Maximum dann 0?


wenn du damit bspw. den int meinst der mit 0 initialisiert wird, in dem Fall 100%?
oder 0% da 9 das Maximum ist, bin gerade einfach raus sorry


----------



## mihe7 (23. Nov 2019)

OK, ich formulier es mal anders: muss das Maximum einer Menge nicht auch Teil dieser Menge sein?


----------



## tfausw (23. Nov 2019)

Sollte im besten Falle so sein oder? Sonst macht es ja normalerweise keinen Sinn.


----------



## mihe7 (23. Nov 2019)

tfausw hat gesagt.:


> Sonst macht es ja normalerweise keinen Sinn.


Und warum gehst Du dann in Deinem Code erstmal davon aus, dass das Maximum 0 ist?


----------



## tfausw (23. Nov 2019)

Wüsste leider nicht, wie man sonst am besten das Maximum bestimmt


----------



## mihe7 (23. Nov 2019)

Dein Code ist ja fast richtig, es geht nur um die Initialisierung von max. Da nimmst Du einfach mal 0 an. Stattdessen könntest Du auch einfach das erste Element verwenden. In der Schleife brauchst Du das erste Element natürlich nicht nochmals zu überprüfen und beginnst daher nicht mehr bei 0 sondern bei 1:

```
public static int getMaximum(int[]arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
```

Soweit klar?


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Dein Code ist ja fast richtig, es geht nur um die Initialisierung von max. Da nimmst Du einfach mal 0 an. Stattdessen könntest Du auch einfach das erste Element verwenden. In der Schleife brauchst Du das erste Element natürlich nicht nochmals zu überprüfen und beginnst daher nicht mehr bei 0 sondern bei 1:
> 
> ```
> public static int getMaximum(int[]arr) {
> ...


Tatsächlich hätte ich dies nach einigen paar Minuten überlegen als Lösung vorgeschlagen.
Soweit klar ja und macht natürlich auch Sinn.

Nun aber nicht anwendbar auf das 2D Array?


Wir gehen ja Zeilen und Spalten durch und für jedes Array wollen wir das Maximum.
Wenn ich das jetzt anwenden würde, würde ich folgendes wieder haben:


```
int max = array[0].length; // bin mir hier jedoch sicher, dass das falsch ist 
        for (int i = 0; i < array.length; i++) {
            for (int j = 0;j < array[i].length; j++) {
            if (array[i].length > max) {
                max = array[i][j];
            }
        }  
    }
```

Ausgabe da aber leider vom 2. Array die 1. 3 Werte


----------



## mihe7 (23. Nov 2019)

Langsam... Du hast jetzt eine Methode `getMaximum(int[] arr)`, die das Maximum eines eindimensionalen Arrays liefert. Kannst Du die Methode vielleicht in einer Schleife verwenden, um für jedes Array (eines 2D-Arrays) das Maximum zu ermitteln?


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Langsam... Du hast jetzt eine Methode `getMaximum(int[] arr)`, die das Maximum eines eindimensionalen Arrays liefert. Kannst Du die Methode vielleicht in einer Schleife verwenden, um für jedes Array (eines 2D-Arrays) das Maximum zu ermitteln?


Naja entweder wir nutzen eine while-Schleife, oder zählen quasi wieder durch eine for-Schleife.


----------



## mihe7 (23. Nov 2019)

Ja, Code will ich sehen


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Ja, Code will ich sehen


Vermute, dass meine Initialisierung falsch ist, wüsste aber keine andere. 


```
public static int getMaximum(int[][]arr) {
        int max = arr.length;
        for (int x = 0; x < arr.length; x++) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
            if (arr[i].length > max) {
                max = arr[i][j];
            }
          }
        }
    }
        return max;
}
```


----------



## mihe7 (23. Nov 2019)

Wir schreiben aneinander vorbei, es geht darum, die oben, für den eindimensionalen Fall entwickelte Methode getMaximum zu verwenden:

```
public void zeigeMaxima(int[][] array) {
    for (int i = 0; i < array.length; i++) {
        int[] arr = array[i]; // das i-te Array aus array
        int max = getMaximum(arr);
        System.out.println(max);
    }
}
```
Soweit verständlich?


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Wir schreiben aneinander vorbei, es geht darum, die oben, für den eindimensionalen Fall entwickelte Methode getMaximum zu verwenden:
> 
> ```
> public void zeigeMaxima(int[][] array) {
> ...


Ist in dem Fall verständlich.

 Aber wie wäre es, wenn man alles in einer Methode schreibt? Wie auch beim Threadersteller.


```
for (int x = 0; x < array.length; x++) {
            int[]arr = array[x];
            int max = arr[0];
        for (int i = 0; i < array.length; i++) {
            for (int j = 0;j < array[i].length; j++) {
            if (array[i].length > max) {
                max = array[i][j];
                System.out.println(max);
            }
          }  
         }
        }
```

Wäre ungefähr so in die Richtung gegangen. Ausgabe: 11 , 5 , -4, 6 ; sprich erstes Array richtig, danach werden einfach die 1. 3 Werte des 2. Arrays ausgegeben. Wo wäre in dem Fall der Fehler?


----------



## mihe7 (23. Nov 2019)

Genau deswegen habe ich in #36 nach der Methode gefragt  Du kannst den Aufruf von getMaximum() durch den Code in der Methode ersetzen (gut, dass Du für das äußere Array schon x als Indexvariable verwendet hast, dann brauch ich das nicht mehr umbenennen):

```
for (int x = 0; x < array.length; x++) {
            int[]arr = array[x]; 
            // code der Methode getMaximum()
            int max = arr[0];
            for (int i = 1; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            // Ende der Methode getMaximum()
            System.out.println(max);
       }
```
Und wenn Du jetzt die Deklaration `int[] arr = array[x]` entfernen willst, dann musst Du `arr` überall noch durch `array[x]` ersetzen:

```
for (int x = 0; x < array.length; x++) {
            // code der Methode getMaximum()
            int max = array[x][0];
            for (int i = 1; i < array[x].length; i++) {
                if (array[x][i] > max) {
                    max = array[x][i];
                }
            }
            // Ende der Methode getMaximum()
            System.out.println(max);
       }
```


----------



## tfausw (23. Nov 2019)

Verstehe!  
So, nun haben wir ja schon bisschen was geschafft. Danke dafür schon mal. 

Wenn ich nun max löschen würde, wäre mein Ansatz vermutlich max = null zu setzen. 
Denn wenn ich beispielsweise sage:

```
max = max*0;
```
wird eben die 0 gespeichert.


----------



## mihe7 (23. Nov 2019)

Nein. Mit max = max*0 änderst Du nur den Wert der Variablen max und zwar auf 0. Man kann in einem Array auch nichts löschen (nur andere Werte setzen).


----------



## tfausw (23. Nov 2019)

jono hat gesagt.:


> ...die Werte eines zweidimensionalen Arrays in ein eindimensionales kopieren.
> Zudem soll der größte Wert jedes einzelnen Arrays weggelassen werden.
> Wichtig ist auch das die Arrays unterschiedliche Größen haben können.



Bisher haben wir das max ermittelt und im späteren Schritt schon das 2D Array in ein eindimensionales überführt. Wie soll das denn dann möglich sein, wenn die max Werte jedes einzelnen arrays weggelassen (= gelöscht?) werden sollen?
Quasi ein new int[] ohne max?


----------



## mihe7 (23. Nov 2019)

Naja, es ging ja erstmal darum, ein paar Grundlagen zu erarbeiten: wie findet man ein Maximum, wie lässt sich im Prinzip ein 2D-Array in ein 1D-Array kopieren.

Jetzt heißt es, erstmal zurück auf Anfang. Beschreib doch mal in Worten, was Du machen müsstest, um die Aufgabe zu lösen, Du kannst jetzt dabei voraussetzen, dass Du in einem Array das Maximum ermitteln kannst.


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Naja, es ging ja erstmal darum, ein paar Grundlagen zu erarbeiten: wie findet man ein Maximum, wie lässt sich im Prinzip ein 2D-Array in ein 1D-Array kopieren.
> 
> Jetzt heißt es, erstmal zurück auf Anfang. Beschreib doch mal in Worten, was Du machen müsstest, um die Aufgabe zu lösen, Du kannst jetzt dabei voraussetzen, dass Du in einem Array das Maximum ermitteln kannst.



Da hast du Recht! Habe auch schon gut was gelernt!! 

Ich schreibe einfach mal den Algorithmus in Stichworten nieder:
- Methode, welches ein 2d int-array erhält und ein 1d int-array zurückgibt
- werte aus den einzelnen arrays nehmen und in ein 1d array kopieren, dabei soll aus jedem einzelnen array jeweils die größte zahl weggelassen werden
- das resultierende array absteigend sortieren (mit bubble-, selection - oder insertionsort)
- einzelne arrays können unterschiedliche größen haben
- sollte irgendein array "null" oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden


Also würde ich vermuten, dass wir erst die max Werte der einzelnen Arrays ermitteln, daraufhin diese eliminieren, oder neue arrays ohne diese werte schaffen, diese dann in ein 1d array kopieren, dann absteigend sortieren, dabei beachten, dass unterschiedliche größen möglich sind und am anfang einen test, ob eins der arrays = null oder leer ist -> return new int[] {}; vermutlich.

Habe natürlich nebenbei fleißig gecoded und probiert, bin jetzt bei dem Fall, dass ich die höchsten Werte der Arrays ermittelt habe und die 2d arrays in ein 1d array kopiert habe (jedoch noch mit den max werten)


----------



## mihe7 (23. Nov 2019)

tfausw hat gesagt.:


> Also würde ich vermuten, dass wir erst die max Werte der einzelnen Arrays ermitteln, daraufhin diese eliminieren, oder neue arrays ohne diese werte schaffen, diese dann in ein 1d array kopieren, dann absteigend sortieren, dabei beachten, dass unterschiedliche größen möglich sind und am anfang einen test, ob eins der arrays = null oder leer ist -> return new int[] {}; vermutlich.


Das ist schon mal der grobe Plan, wenn Du das aber genauer formulierst, wirst Du auf Probleme stoßen:

```
Falls arrays == null oder leer ist, leeres Array zurückgeben.
Für jedes Array a aus arrays wiederhole {
    max := Maximum aus a ermitteln
    b := Array a aber ohne max
    und nu?
}
```


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Das ist schon mal der grobe Plan, wenn Du das aber genauer formulierst, wirst Du auf Probleme stoßen:
> 
> ```
> Falls arrays == null oder leer ist, leeres Array zurückgeben.
> ...




```
Falls arrays == null oder leer ist, leeres Array zurückgeben.
Für jedes Array a aus arrays wiederhole {
    max := Maximum aus a ermitteln
    b := Array a aber ohne max
   
    b absteigend sortieren
    return b; 
}
```

Oder missverstehe ich etwas ?


----------



## mihe7 (23. Nov 2019)

Ein return innerhalb einer Schleife gibt keinen Sinn, da dann schon bei der ersten Iteration b zurückgegeben wird.


----------



## mihe7 (23. Nov 2019)

Und noch was, nachdem Du die Sortierung ja schon ins Spiel gebracht hast: wenn Du b absteigend sortierst, wo steht dann das Maximum?


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Ein return innerhalb einer Schleife gibt keinen Sinn, da dann schon bei der ersten Iteration b zurückgegeben wird.


Ja da hast du recht, das war auch nicht so gemeint wie es da steht  oder war einfach falsch gedacht von mir. 



mihe7 hat gesagt.:


> Und noch was, nachdem Du die Sortierung ja schon ins Spiel gebracht hast: wenn Du b absteigend sortierst, wo steht dann das Maximum?


Am Anfang, also sind die ersten x Indexstellen von x Arrays deren Maxima


----------



## mihe7 (23. Nov 2019)

Genau, was aber immer noch nicht die Frage klärt, was mit dem Array b anschließend geschehen soll.


----------



## tfausw (23. Nov 2019)

mihe7 hat gesagt.:


> Genau, was aber immer noch nicht die Frage klärt, was mit dem Array b anschließend geschehen soll.


Weiß gerade nicht worauf du hinaus möchtest, wenn wir folgendes haben, ist die Logik doch vollendet, oder sehe ich das falsch? 



```
Falls arrays == null oder leer ist, leeres Array zurückgeben.
Für jedes Array a aus arrays wiederhole {
    max := Maximum aus a ermitteln
    b := Array a aber ohne max
 
}

b absteigend sortieren {
}
return b;
```
(Form mal außer Acht gelassen)


----------



## mihe7 (23. Nov 2019)

Geh doch mal Deinen Algorithmus für 3 Arrays Schritt für Schritt durch, dann erhältst Du am Ende etwa folgendes:

```
b := Array arrays[0] aber ohne das Maximum
b := Array arrays[1] aber ohne das Maximum
b := Array arrays[2] aber ohne das Maximum
sortiere b absteigend
gib b zurück
```
Du weist also b dreimal ein anderes Array zu, bevor Du das letzte sortiert zurückgibst. Das ist jetzt nicht das, was die Aufgabe verlangt, oder?


----------



## jono (23. Nov 2019)

```
import java.util.Arrays;
public class Functionality {
 public static void main(String[] args) {
 
 System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
 
 }
 
 public static int[] flatternAndSortWithoutBiggest(int[][] array) {
  if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
 
     int[] eindim = new int[9];
        int[][] zweidim = {
                new int[] {1,2,3},
                new int[] {4,5,6},
                new int[] {7,8,9} };
        int counter = 0;
        for (int i = 0; i < zweidim.length; i++) {
            for (int j = 0; j < zweidim[i].length; j++) {
             
             eindim[counter] = zweidim[i][j];
                counter++;
        }
           
     }
        return eindim;
   }
 
 }
```


----------



## jono (23. Nov 2019)

Ich habe bisher das, kannst du einfach mal näher erläutern wie ich denn an das maximum von "zweidim" des jeweiligen "new int" komme es gibt ja z.B. die max Funktion aber mit der komme ich da auch nicht weiter kannst du mir mal etwas auf die sprünge helfen ?


----------



## mihe7 (23. Nov 2019)

OK, wahrscheinlich habe ich Dich zu sehr verwirrt. Vergiss mal für einen Moment alles, denn es geht jetzt um die Aufgabe als Ganzes.

Die Schritte sind ja relativ einfach formuliert, ich greife mal Deine Sicht der Dinge auf:

```
1. Falls array == null gilt oder array leer ist, gib ein leeres Array zurück
2. Entferne das Maximum in jedem Array aus array
3. Überführe das 2D-Array array in ein 1D-Array arr
4. Sortiere arr absteigend
5. Gib arr zurück
```

In Code

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
    if (array == null || array.length == 0) {
        throw new IllegalArgumentException ("Array null oder leer!");
    }
    removeEachMaximum(array);
    arr = flattened(array);
    sortDescending(arr); // alternativ: arr = sortDescending(arr)
    return arr;
}
```

Die flattened-Methode haben wir schon behandelt. Das Sortieren sparen wir uns für den Moment, bleibt also noch removeEachMaximum.

Wie kann das funktionieren?

```
i := 0
So lange i < array.length, wiederhole {
    array[i] := array[i] ohne dessen Maximum
    i++
}
```

In Code:

```
public static void removeEachMaximum(int[][] array) {
    for (int i = 0; i < array.length; i++) {
         array[i] = arrayOhneMaximum(array[i]);
    }
}
```

Und jetzt überlegst Du Dir einfach, wie arrayOhneMaximum aussehen könnte.


----------



## tfausw (23. Nov 2019)

Also ich würde vermutlich alle Werte < max in ein neues int[] kopieren (arrayOhneMaximum)


----------



## mihe7 (23. Nov 2019)

Naja, mach mal


----------



## tfausw (23. Nov 2019)

ja naja, weiß ich nicht genau, hätte halt sowas gesagt wie: 


```
int [] xy = new int [array[i] - max]
```

oder so ähnlich .. wüsste leider abgesehen von der Logik her nicht genau wie ich das nun im Code schreiben würde


----------



## mihe7 (23. Nov 2019)

Du musst ein Array passender Größe anlegen und dieses entsprechend befüllen.


----------



## jono (23. Nov 2019)

```
public static void removeEachMaximum(int[][] array) {
    for (int i = 0; i < array.length; i++) {
         array[i] = arrayOhneMaximum(array[array.length-1]);
    }
}
```


----------



## jono (23. Nov 2019)

Geht das in die Richtung? Denn im Prinzip wird die Länge des jeweiligen Arrays im zweidimensionalen Array um 1 Einheit (nämlich um das Maximum) verringert


----------



## jono (23. Nov 2019)

Obwohl sry ist komplett falsch der Ansatz


----------



## mihe7 (23. Nov 2019)

Ein klares Jein  Auf der einen Seite muss an der Methode removeEachMaximum nichts geändert werden, auf der anderen Seite stimmt es, dass das Array um ein Element (das Maximum) kürzer werden muss. Die Frage ist also, wie muss arrayOhneMaximum implementiert werden?

Das Skelett dazu:

```
// liefert ein Array, das alle Element aus arr mit Ausnahme des Maximums enthaelt.
public int[] arrayOhneMaximum(int[] arr) {
    int[] ergebnis = new int[arr.length-1];
    // fuelle ergebnis
    return ergebnis;
}
```


----------



## jono (23. Nov 2019)

Kannst du evtl. einen kleinen Hinweis geben, wie ich das befüllen kann, um nun das array ohne maximum zu erhalten?


----------



## mihe7 (24. Nov 2019)

Ich kann Dir sogar einen großen Hinweis geben: nimm einen Zettel und einen Stift, male Dir 5 Kästchen untereinander, nummerierst diese von 0 bis 4 und trägst dort irgendwelche zufälligen Zahlen ein. Daneben malst Du Dir nochmal 4 Kästchen:


IndexInputOutput0522312890221943529242149-------

Dann überlegst Du, welche Schritte Du ganz genau(!) machen musst, um alle Zahlen - außer dem Maximum - in die vier Kästchen zu übertragen. Es bringt Euch gar nichts, wenn ich Euch die ganze Lösung hinschreibe.


----------



## tfausw (24. Nov 2019)

Naja, ich ziehe alle Werte < max rüber. (Algorithmisch)


```
public int[] arrayOhneMaximum(int[] arr) {
    int[] ergebnis = new int[arr.length-1];
    for (int i = 0; i < array.length; i++) {
    if (max < xx){ // xx = werte?
      ergebnis = array[i];
     }
  }
    return ergebnis;
}
```


----------



## mihe7 (24. Nov 2019)

tfausw hat gesagt.:


> Naja, ich ziehe alle Werte < max rüber. (Algorithmisch)


Das ist viel zu ungenau. Lass mal den Code weg: was würdest Du bei der Tabelle aus #86 als allererstes machen?


----------



## tfausw (24. Nov 2019)

mihe7 hat gesagt.:


> Das ist viel zu ungenau. Lass mal den Code weg: was würdest Du bei der Tabelle aus #86 als allererstes machen?


Index 0 -> rüber
Index 1 -> rüber
Index 2 -> rüber
Index 3 max
Index 4 -> rüber 

Hoffe das ist das, was du meinst


----------



## mihe7 (24. Nov 2019)

Nein. Ich will wissen, was Du als allererstes machst, wenn ich Dir die Tabelle in die Hand drücke.


----------



## mihe7 (24. Nov 2019)

Zum besseren Verständnis, worauf ich hinaus will, wende ich Deinen Algorithmus mal an:


IndexInputOutput0100100155211310 12412

Index 0 -> rüber
Index 1 -> rüber
Index 2 -> rüber
Index 3 max
Index 4 -> rüber


----------



## jono (24. Nov 2019)

Das Einzige was bei genauer Betrachtung geschieht ist dass man Zahl für Zahl darauf Prüft ob sie kleiner als das Maximum ist. Wenn ja, dann soll sie ausgegeben werden der index spielt doch da keine Rolle.


----------



## jono (24. Nov 2019)

Wenn array_ =max dann new int [array.length - max]_


----------



## mihe7 (24. Nov 2019)

jono hat gesagt.:


> Das Einzige was bei genauer Betrachtung geschieht ist dass man Zahl für Zahl darauf Prüft ob sie kleiner als das Maximum ist.


So, und das Maximum fliegt Dir auf telepathischem Wege zu?


----------



## jono (24. Nov 2019)

Nein das muss ich definieren in dem ich sage das jede Zahl kleiner sein muss als das Maximum


----------



## jono (24. Nov 2019)

Ich kann das auch maximum auch initialisieren aber dann wäre der Wert ja nicht mehr variabel sprich wenn ich andere Werte ins Array setze müsste ich das max wieder neu initialisieren und dann könnte ich mit einer Schleife über den Index arbeiten bis index gleich max ist


----------



## mihe7 (24. Nov 2019)

Es geht zunächst ganz einfach darum, dass man erst das Maximum ermitteln muss, ansonsten kann man schlecht die Werte mit dem Maximum vergleichen  

D. h. der Algorithmus beginnt damit, das Maximum aus der Tabelle zu ermitteln. Danach geht es weiter mit:


jono hat gesagt.:


> Zahl für Zahl darauf Prüft ob sie kleiner als das Maximum ist.



Hier


jono hat gesagt.:


> soll sie ausgegeben werden der index spielt doch da keine Rolle.


hast Du noch einen Gedankenfehler, denn Du musst ja angeben, in welche Zeile (=Index) der Tabelle der Wert eingetragen werden soll.


----------



## Snaer (24. Nov 2019)

Zur Bestimmung des Maximums habe ich nun folgenden Code verwendet :

```
int max1 = b[0][0];
        int max2= b[1][0];
        for (int k=1; k<b[0].length;k++) {
            if (b[0][k] > max1) max1= b[0][k];
            
            for (int i=1; i<b[1].length;i++) {
                if (b[1][k] >max2) max2=b[1][k];
                    }
            }
```
Nun stelle ich mir jedoch die Frage, wie genau man die Maxima jeweils löschen kann. 
Mein Ansatz bisher sieht so aus

```
int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                a[count] = b[i][j];
                count++;
                if (a[count] == max1)
                    a[count]= a[count]-max1;
            }
```
Allerdings denke ich mal wenn ich a[count] -max1 rechnen würde, dass die Stelle nicht gelöscht wird sondern einfach durch ersetzt werden würde oder irre ich mich da?


----------



## kneitzel (24. Nov 2019)

Also mehrerer Ideen:
A) Man könnte Elemente verschieben. Du könntest das Maximum also z.B. am Anfang oder am Ende halten. Dann hast du einen geschlossenen Bereich, den du später behandeln kannst.
B) Du kannst Dir die Stelle merken (statt dem Wert). Dann kannst du bei der Behandlung eines Arrays immer prüfen, ob die Stelle das Maximum ist oder nicht um dann das Maximum ggf. zu ignorieren.


----------



## Snaer (24. Nov 2019)

JustNobody hat gesagt.:


> Also mehrerer Ideen:
> A) Man könnte Elemente verschieben. Du könntest das Maximum also z.B. am Anfang oder am Ende halten. Dann hast du einen geschlossenen Bereich, den du später behandeln kannst.
> B) Du kannst Dir die Stelle merken (statt dem Wert). Dann kannst du bei der Behandlung eines Arrays immer prüfen, ob die Stelle das Maximum ist oder nicht um dann das Maximum ggf. zu ignorieren.


Meinst du quasi mit einer Sortier Methode ? Also sprich das ich beide Arrays mit einer Methode wie bubble oder insertion sortieren lasse?


----------



## kneitzel (24. Nov 2019)

Snaer hat gesagt.:


> Meinst du quasi mit einer Sortier Methode ? Also sprich das ich beide Arrays mit einer Methode wie bubble oder insertion sortieren lasse?


Gegenfrage: Musst Du denn das ganze Array sortieren?
Es geht doch lediglich darum, dass das Maximum an einem bestimmten Ort steht.

Wenn du Bubblesort betrachtest: Wann und wie hättest Du denn da Maximum an einer bestimmten Stelle?


----------



## Snaer (24. Nov 2019)

Die Stelle des Maximums variiert doch je nachdem welches Array man vor sich hat. 
Also angenommen man bekommt irgendein Array zugewiesen dessen Länge man nicht kennt, dann muss ich es doch vollständig sortieren um das Maximum jeweils am Anfang oder Ende zu haben oder irre ich mich da ?


----------



## mihe7 (24. Nov 2019)

Es geht ja darum, dass ihr nicht ein Array habt, sondern mehrere (die wiederum in einem Array gehalten werden). Dem entsprechend gibt es nicht ein Maximum sondern für jedes Array eines.

Werden nun die vielen Arrays zu einem Array zusammengefasst, dürfen die Maxima nicht mitkopiert werden. Die Frage ist: woher weißt Du beim Kopieren, welchen Wert Du auslassen musst?

Dazu kannst Du Dir entweder für jedes Array die Stelle merken, an der das Maximum steht und diese Stelle beim Kopieren auslassen oder aber Du bestimmst (durch Verschiebung) vor dem Kopieren, dass das Maximum z. B. am Anfang des Arrays steht. Dann brauchst Du nur alle Elemente ab dem zweiten kopieren, und hast so das Maximum ausgelassen.


----------



## kneitzel (24. Nov 2019)

Snaer hat gesagt.:


> Die Stelle des Maximums variiert doch je nachdem welches Array man vor sich hat.
> Also angenommen man bekommt irgendein Array zugewiesen dessen Länge man nicht kennt, dann muss ich es doch vollständig sortieren um das Maximum jeweils am Anfang oder Ende zu haben oder irre ich mich da ?


Wie funktioniert den Bubblesort? Kannst Du kurz beschreiben, wie Bubblesort funktioniert? Das sollte dann die Frage auch beantworten. 

Aber ansonsten: Du kannst die Arrays auch alle komplett sortieren wenn Dir das mit dem Bubblesort nichts sagen sollte. Dann wäre aber beim Zusammenbauen des End-Arrays (Das wohl sortiert sein soll, oder irre ich mich da) mein Vorschlag, sich QuickSort im Detail anzusehen.


----------



## Snaer (24. Nov 2019)

mihe7 hat gesagt.:


> Es geht ja darum, dass ihr nicht ein Array habt, sondern mehrere (die wiederum in einem Array gehalten werden). Dem entsprechend gibt es nicht ein Maximum sondern für jedes Array eines.
> 
> Werden nun die vielen Arrays zu einem Array zusammengefasst, dürfen die Maxima nicht mitkopiert werden. Die Frage ist: woher weißt Du beim Kopieren, welchen Wert Du auslassen musst?
> 
> Dazu kannst Du Dir entweder für jedes Array die Stelle merken, an der das Maximum steht und diese Stelle beim Kopieren auslassen oder aber Du bestimmst (durch Verschiebung) vor dem Kopieren, dass das Maximum z. B. am Anfang des Arrays steht. Dann brauchst Du nur alle Elemente ab dem zweiten kopieren, und hast so das Maximum ausgelassen.




```
int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                a[count] = b[i][j];
                count++;
                if (a[count] == max1)
                    a[count]= a[count]-max1;
            }
```
Zum Verständnis liege ich hiermit zumindest auf dem richtigen Weg die Arrays in eines zu kopieren? Also abgesehen von dem a[count] -max1.


JustNobody hat gesagt.:


> Wie funktioniert den Bubblesort? Kannst Du kurz beschreiben, wie Bubblesort funktioniert? Das sollte dann die Frage auch beantworten.
> 
> Aber ansonsten: Du kannst die Arrays auch alle komplett sortieren wenn Dir das mit dem Bubblesort nichts sagen sollte. Dann wäre aber beim Zusammenbauen des End-Arrays (Das wohl sortiert sein soll, oder irre ich mich da) mein Vorschlag, sich QuickSort im Detail anzusehen.


BubbleSort funktioniert doch so, dass immer 2 Werte die nebeneinander liegen verglichen und gegebenenfalls getauscht werden. Das läuft dann jedoch doch so lange bis die Methode keine Werte mehr tauschen musste oder nicht?


----------



## kneitzel (24. Nov 2019)

Wend Du nun einmal von Index 0 an durchgehst und immer den größten Wert an die höhere Stelle schiebst: wo steht nach dem ersten Durchgang der größte Wert?


----------



## Snaer (24. Nov 2019)

Okay stimmt damit wäre es beim ersten Durchgang direkt am Rand mein Fehler 
Aber leider fällt mir nichts ein wie ich die Stelle dann beim übertragen ignorieren kann


----------



## mihe7 (24. Nov 2019)

Ich glaube, wir müssen das wirklich nochmal von Anfang an erklären und besser visualisieren.

Stellt Euch mal ein Regal vor. Ein solches hat eine endliche Anzahl an Fächern. Wir nehmen an, dass in jedes Fach genau ein Gegenstand passt und dass alle Fächer nebeneinander liegen. Die Kapazität des Regals ist endlich und entspricht genau der Anzahl der Fächer. Außerdem nummerieren wir die Fächer durch von links nach rechts, beginnend bei 0. 

Zusätzlich nehmen wir an, dass an jedem Fach ein sich automatisch schließendes Türchen (wir haben ja bald Advent) angebracht ist. D. h. um zu sehen, was sich in einem Fach befindet, muss man erst das Türchen öffnen.

Auf jedem Gegenstand im Regal befinde sich ein Preiszettel und wir gehen jetzt erstmal davon aus, dass das Regal vollständig gefüllt ist.

*Frage: wie findet man den Gegenstand mit dem höchsten Preis?*

Variante #1: man sieht sich den Preis des Gegenstands im ersten Fach an. Wir merken uns, dass das der bislang höchste Preis ist und dieser im Fach 0 gefunden wurde. Jetzt öffnet man ein Türchen nach dem anderen und vergleicht den Preis des Gegenstands im jeweiligen Fach mit dem gemerkten, bislang höchsten Preis. Wurde ein höherer Preis gefunden, ersetzt dieser den bislang höchsten Preis und wir merken uns wieder, in welchem Fach dieser gefunden wurde. Ist kein Türchen mehr übrig, ist der bislang höchste Preis auch der höchste Preis und wir wissen, in welchem Fach sich der teuerste Gegenstand befindet.

Variante #2: Wir beginnen wieder beim ersten Fach. Wir vergleichen den Preis mit dem des Gegenstands, der sich hinter dem nächsten Fach befindet. Ist der Gegenstand im linken Fach teurer als der im rechten Fach, vertauschen wir die Gegenstände. Das wiederholt man nun für jedes Fach mit Ausnahme des letzten (da es dann kein nächstes Fach mehr gibt). Hat man das einmal durch, befindet sich der teuerste Gegenstand im letzten Fach.

*Frage: wie erreicht man mit Variante #1 auch, dass sich der teuerste Gegenstand im letzten Fach befindet?*

Naja, wir wissen ja, hinter welchem Fach sich der teuerste Gegenstand verbirgt. Folglich brauchen wir nur den Gegenstände dieses Fachs mit dem Gegenstand im letzten Fach zu tauschen.

_________________

So, an dieser Stelle ein Einschub. Wir stellen uns wieder ein Regal vor. Jetzt wollen wir aber nichts finden sondern Gegenstände hinzufügen. Um uns die Sache zu vereinfachen, nehmen wir an, dass ein Regel immer von links aus lückenlos befüllt wird. 

*Frage: woher weiß man, in welches Fach der neue Gegenstand gelegt werden muss?*

Da das Regal immer von links aus und immer lückenlos gefüllt werden soll, ist das trivial: man schreibt sich auf, wie viele Gegenstände man schon ins Regal gelegt hat.

*Frage: wie fügt man also einen Gegenstand dem Regal hinzu?*

Nun, wenn im Regal x Gegenstände liegen, dann ist das Fach x das nächste leere. D. h. wir legen in Fach x den Gegenstand und auf unserem Zettel erhöhen wir das x um eins. Natürlich funktioniert das nur, so lange noch Platz ist.

_________________

Zurück zum Thema: wir haben nun unser gefülltes Regal von oben und wissen, in welchem Fach sich der teuerste Gegenstand befindet. Jetzt bauen wir ein zweites Regal, das höchstens ein Fach weniger besitzt als das erste (mehr darf es ruhig haben).

*Frage: wie überträgt man nun alle Gegenstände - mit Ausnahme des teuersten - in das zweite Regal?*

Wenn der Gegenstand sich im letzten Fach befindet, ist das trivial: wir beginnen beim ersten Fach, nehmen den Gegenstand heraus und fügen ihn dem zweiten Regal hinzu (s. o.) Dann folgt das nächste Fach usw. Das machen wir so lange wir noch nicht das letzte Fach des ersten Regals erreicht haben, da sich dort der teuerste Gegenstand befindet, der nicht übertragen werden soll.

Befindet sich der Gegenstand nicht im letzten Fach, funktioniert das ganz analog, muss aber bei jedem Fach prüfen, ob es sich nicht um das Fach mit dem teuersten Gegenstand handelt. In diesem Fall wird das Fach einfach ausgelassen. Die Übertragung ist vollständig abgeschlossen, wenn alle Fächer (inkl. des letzten) behandelt wurden.

*Frage: wie funktioniert es, wenn es mehrere "ursprüngliche Regale" gibt? (Zweidimensionaler Fall)*

Das könnt Ihr Euch anhand des Regals selbst überlegen.


----------



## tfausw (24. Nov 2019)

Also wenn ich für meine Person spreche, ist die Logik hinter dem Problem sicherlich klar. #108 hat es ja wirklich nochmal sehr gut zusammengefasst und erläutert.
Werde mich morgen auf jeden Fall nochmal an dieses Problem ransetzen.


----------



## jono (24. Nov 2019)

```
int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,2,3}, 
	               new int[] {4,5,6}, 
	               new int[] {7,8,9} }; 

	       int counter = 0; 
	       for (int i = 0; i < zweidim.length; i++) { 
	           for (int j = 0; j < zweidim[i].length; j++) {
	        	   
	        	   eindim[counter] = zweidim[i][j]; 
	               counter++; 
	    	  }
	       
	           
	           boolean swapped;
	           do {
	           swapped = false;
	           for( i = 1; i<array.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	           }
	           
	        }
	           
	           
	     }while(swapped);
	           
	    
	         
	    	 }
	    } 
	}return eindim;
```


----------



## jono (24. Nov 2019)

Ausgabe ist [3,2,1,0,0,0,0,0,0]
Zwar absteigend aber nicht so wie ich es natürlich wollte deshalb wollte ich fragen ob du den Fehler im Code erkennst ich habe ihn nicht erkannt


----------



## mihe7 (24. Nov 2019)

```
swapped = false;
               for( i = 1; i<array.length;i++) {
```
Willst Du hier nicht bis eindim.length gehen?


----------



## jono (24. Nov 2019)

Es passiert trotzdem dasselbe.


----------



## mihe7 (24. Nov 2019)

Moment, damit wir nicht aneinander vorbeischreiben: was willst Du eigentlich machen?


----------



## jono (24. Nov 2019)

Absteigend sortieren, in dem Fall [ 9, 8, 7, 6, 5, 4, 3, 2, 1]


----------



## mihe7 (24. Nov 2019)

OK, dann habe ich Dich schon richtig verstanden. Leider ist die Formatierung in Deinem Code oben sch... Du musst erst vollständig kopieren und anschließend sortieren. Die schließende, geschweifte Klammer nach while(swapped) gehört vor boolean swapped = false, um die for-Schleife erstmal abzuschließen.


----------



## jono (24. Nov 2019)

Ja okay, das mit der Klammer mache ich dann jetzt. 
Was genau meinst du damit dass ich erst vollständig kopieren muss ich habe vollständig kopiert also es kommt [1,2,3,...,9] als Ausgabe ohne den Sortierungscode raus.


----------



## jono (24. Nov 2019)

Komischerweise entstehen Fehlermeldungen wenn ich die geschweifte Klammer so versetze was ja eigentlich auch Sinn macht


----------



## jono (24. Nov 2019)

Warum habe ich denn sozusagen unvollständig kopiert


----------



## mihe7 (24. Nov 2019)

Im Code oben kopierst Du das erste Teilarray, dann sortierst Du das Ausgabearray, dann kopierst Du das zweite Teilarray, dann sortierst Du das Ausgabearray usw. EDIT: und beim Kopieren änderst Du noch den Zähler i.



jono hat gesagt.:


> Komischerweise entstehen Fehlermeldungen wenn ich die geschweifte Klammer so versetze was ja eigentlich auch Sinn macht


Warum sollte das Sinn machen? Das einzige, was ich mich frage ist, wo die vielen schließenden Klammern vor dem return herkommen.


```
int[] eindim = new int[9];
           int[][] zweidim = {
                   new int[] {1,2,3},
                   new int[] {4,5,6},
                   new int[] {7,8,9} };

           int counter = 0;
           for (int i = 0; i < zweidim.length; i++) {
               for (int j = 0; j < zweidim[i].length; j++) {                
                   eindim[counter] = zweidim[i][j];
                   counter++;
               }
           }
                       
           boolean swapped;
           do {
               swapped = false;
               for(int i = 1; i<eindim.length;i++) {
                   if(eindim[i]>eindim[i-1]) {
                       int swap = eindim[i-1];
                       eindim[i-1] = eindim[i];
                       eindim[i] = swap;
                       swapped = true;
                   }            
                }                           
           } while(swapped);

           return eindim;
```


----------



## jono (24. Nov 2019)

wie soll ich denn jedes teilarray einzeln kopieren und dann auch noch für jedes teilarray ein sortiercode oder wie ?


----------



## jono (24. Nov 2019)

Ich dachte jetzt dass das so funktioniert da unter "eindim" doch eigentlich alle werte gespeichert sind ich meine bei ausgabe ohne sortiercode kommt ja auch die ausgabe aller drei teilarrays raus deshalb ...


----------



## jono (24. Nov 2019)

Kannst du mir da bitte bisschen mehr weiterhelfen ich verzweifel sonst ich gebe mir ja schon Mühe aber jetzt jedes einzeln kopieren und wieder sortieren klingt jetzt etwas überfordernd


----------



## jono (24. Nov 2019)

Ich weiß echt nicht wie ich jetzt jedes Teilarray kopieren soll und nochmal einzeln sortieren soll mit BubbleSort , da habe ich absolut keine Ahnung.


----------



## mihe7 (24. Nov 2019)

jono hat gesagt.:


> wie soll ich denn jedes teilarray einzeln kopieren und dann auch noch für jedes teilarray ein sortiercode oder wie ?


Das ist doch das, was Du im Code vorhin machst. Der Code aus #120 sollte doch passen. Hier nochmal mit Kommentaren:

```
int[] eindim = new int[9];
           int[][] zweidim = {
                   new int[] {1,2,3},
                   new int[] {4,5,6},
                   new int[] {7,8,9} };

           // Kopiere alle Teilarrays aus zweidim nach eindim
           int counter = 0;
           for (int i = 0; i < zweidim.length; i++) {
               for (int j = 0; j < zweidim[i].length; j++) {                
                   eindim[counter] = zweidim[i][j];
                   counter++;
               }
           }
                       
           // Sortiere eindim
           boolean swapped;
           do {
               swapped = false;
               for(int i = 1; i<eindim.length;i++) {
                   if(eindim[i]>eindim[i-1]) {
                       int swap = eindim[i-1];
                       eindim[i-1] = eindim[i];
                       eindim[i] = swap;
                       swapped = true;
                   }            
                }                           
           } while(swapped);

           // Fertig
           return eindim;
```


----------



## mihe7 (24. Nov 2019)

Und, nachdem sich in Deinen Teilarrays das Maximum bereits am Ende befindet, könntest Du mit einer klitzekleinen Änderung bereits das letzte Element beim Kopieren des Teilarrays weglassen. Dann wären die Maxima nicht mehr in eindim enthalten.


----------



## TheP3aceguy (24. Nov 2019)

Wie schafft man es dann, dass man vorher schon ein Array mit der passenden Länge anlegt? Da liegt momentan mein Problem


----------



## mihe7 (24. Nov 2019)

Indem Du die Elemente zählst. Das hatten wir schon in #28 (https://www.java-forum.org/thema/zw...imensionales-ueberfuehren.186409/post-1201291). Natürlich musst Du das noch ein wenig anpassen, weil Du berücksichtigen musst, dass es weniger Elemente sind.


----------



## jono (25. Nov 2019)

Für die Änderung die Maxima zu entfernen habe ich schon etwas, wozu ich noch eine Frage stellen wollte,die ich aber auf morgen verlegen will. 
Das Problem ist ja das meine Ausgabe nicht wie gewünscht ist nämlich von 9 absteigend bis zur 1. Das funktioniert nicht.


----------



## jono (25. Nov 2019)

Für die Änderung die Maxima zu entfernen habe ich schon etwas, wozu ich noch eine Frage stellen wollte,die ich aber auf morgen verlegen will. 
Das Problem ist ja das meine Ausgabe nicht wie gewünscht ist nämlich von 9 absteigend bis zur 1. Das funktioniert nicht.


----------



## TheP3aceguy (25. Nov 2019)

mihe7 hat gesagt.:


> Indem Du die Elemente zählst. Das hatten wir schon in #28 (https://www.java-forum.org/thema/zw...imensionales-ueberfuehren.186409/post-1201291). Natürlich musst Du das noch ein wenig anpassen, weil Du berücksichtigen musst, dass es weniger Elemente sind.



Sorry, nicht gesehen gehabt. Vielen Dank!


----------



## mihe7 (25. Nov 2019)

jono hat gesagt.:


> Für die Änderung die Maxima zu entfernen habe ich schon etwas, wozu ich noch eine Frage stellen wollte,die ich aber auf morgen verlegen will.
> Das Problem ist ja das meine Ausgabe nicht wie gewünscht ist nämlich von 9 absteigend bis zur 1. Das funktioniert nicht.


Natürlich funktioniert das.

Hier mal der Code von oben mit einer Klasse rum:

```
import java.util.*;

public class Test {
    public static int[] doit() {
           int[] eindim = new int[9];
           int[][] zweidim = {
                   new int[] {1,2,3},
                   new int[] {4,5,6},
                   new int[] {7,8,9} };

           // Kopiere alle Teilarrays aus zweidim nach eindim
           int counter = 0;
           for (int i = 0; i < zweidim.length; i++) {
               for (int j = 0; j < zweidim[i].length; j++) {                
                   eindim[counter] = zweidim[i][j];
                   counter++;
               }
           }
                       
           // Sortiere eindim
           boolean swapped;
           do {
               swapped = false;
               for(int i = 1; i<eindim.length;i++) {
                   if(eindim[i]>eindim[i-1]) {
                       int swap = eindim[i-1];
                       eindim[i-1] = eindim[i];
                       eindim[i] = swap;
                       swapped = true;
                   }            
                }                           
           } while(swapped);

           // Fertig
           return eindim;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(doit()));
    }
}
```

Liefert als Ausgabe:

```
[9, 8, 7, 6, 5, 4, 3, 2, 1]
```


----------



## jono (25. Nov 2019)

Okay, hatte eben ja gesagt, dass die Ausgabe [3,2,1,0, 0,0,0,0,0] war, deshalb. 
Dann wird es jetzt funktionieren. Vielen Dank für die Hilfe. Morgen frage ich dann mal wegen Weglassen vom Maximum


----------



## jono (25. Nov 2019)

Und nochmal zur #120, da war es so dass die vielen Klammern da waren, weil ich die klasse und die Main nicht mitkopiert hatte.


----------



## mihe7 (25. Nov 2019)

jono hat gesagt.:


> Okay, hatte eben ja gesagt, dass die Ausgabe [3,2,1,0, 0,0,0,0,0] war, deshalb.


LOL, das war um 20:28 Uhr, also vor gut vier Stunden


----------



## tfausw (25. Nov 2019)

Ich habe das jetzt alles mal so ein wenig umgedacht.


```
int [] result = new int ??
        int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
            result[counter] = r[i]; 
            counter++;
            }
        }
```

Was da gemacht wird, ist ja nicht so schwer. Sortieren und den letzten Index nicht mit übernehmen.

Jetzt weiß ich leider nicht, wie ich int [] result deklariere, damit die Werte vom 2D in 1D gespeichert werden, oder habe ich jetzt quasi die ganze Logik kaputt gedacht?

Hatte mir

```
int[] result = new int [array.length * (array[0].length - 1)];
```
angedacht, aber in dem Fall mit dem obigen Code, werden Rechenfehler erzeugt (Werte werden verändert) + 1 Wert wird zu wenig ausgegeben.


----------



## mihe7 (25. Nov 2019)

S. #128


----------



## tfausw (25. Nov 2019)

Also, laut Ausgabe habe ich jetzt die benötigte Anzahl an Werten, hoffe das ist kein Zufall, sondern richtig. 

folgendes: 

```
int counter2 = 0;
        for (int i = 0; i < array.length; i++) {
            counter2 += array[i].length;
        }
        
        int [] result = new int [counter2 - (array[0].length - 1)];
        
        int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
            result[counter] = r[i];   
            counter++;
            }
        }
```

Bei den Beispielwerten {1,11,3,2},{5,-4,6,2,4,2},{8,9,7} = 13 Elemente, werden 10 Ausgegeben, leider wie erwähnt immer noch mit Rechenfehler ( [8, 7, 2, 2, 1, 0, 0, 0, 0, -4] ).


----------



## kneitzel (25. Nov 2019)

Das ist aber Zufall. Mach mal das erste Array länger oder kürzer.


----------



## Snaer (25. Nov 2019)

JustNobody hat gesagt.:


> Das ist aber Zufall. Mach mal das erste Array länger oder kürzer.


Gibt es eine Möglichkeit die Länge des neuen Arrays an die des mehrdimensionales Array anzupassen, ohne zuvor die Länge der einzelnen Teilarrays zu kennen?
Bislang hatte ich die Länge des neuen Arrays so initialisiert, indem ich die Längen der einzelnen Teilarrays addiert habe, allerdings funktioniert dies ja nicht, wenn ich selbst nicht weiß wie viele Teilarrays vorhanden sind.


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Bislang hatte ich die Länge des neuen Arrays so initialisiert, indem ich die Längen der einzelnen Teilarrays addiert habe, allerdings funktioniert dies ja nicht, wenn ich selbst nicht weiß wie viele Teilarrays vorhanden sind.


Kannst Du das Problem mal näher erläutern? Ich verstehe es gerade nicht


----------



## tfausw (25. Nov 2019)

mihe7 hat gesagt.:


> S. #128


Also muss ich quasi das new int[] nur richtig anpassen? Also so, dass x Elemente von n Arrays im neuen Array weniger sind?


----------



## Snaer (25. Nov 2019)

Also ich bin bislang von einen zweidimensionalen Array mit festen Werten ausgegangen. Zum Beispiel {1,2,3,4}{5,6,7,8}. 
Um die Werte in ein eindimensionales Array zu übertragen, muss ich ja darauf achten, dass das eindimensionale Array nicht kleiner ist als die beiden Teilarrays. 
Daher habe ich die Länge dadurch bestimmt indem ich die es quasi so initialisiert hatte:

```
int n = b[0].length + b[1].length
int [] a = new int [n]
```
Nun stehe ich, aber vor dem Problem, dass ich nicht weiß, wie ich vorgehen kann, wenn ich keine Informationen darüber habe wie viele Teilarrays vorhanden sind und wie viele einzelne Produkte in diesen enthalten sind. 
Mein Idee war es bisher noch mehr Werte auf n zu addieren, allerdings würde dies denke ich zu Fehlern führen.


----------



## Snaer (25. Nov 2019)

Snaer hat gesagt.:


> Also ich bin bislang von einen zweidimensionalen Array mit festen Werten ausgegangen. Zum Beispiel {1,2,3,4}{5,6,7,8}.
> Um die Werte in ein eindimensionales Array zu übertragen, muss ich ja darauf achten, dass das eindimensionale Array nicht kleiner ist als die beiden Teilarrays.
> Daher habe ich die Länge dadurch bestimmt indem ich die es quasi so initialisiert hatte:
> 
> ...


Ich muss mich entschuldigen, vor lauter Seiten habe ich übersehen, dass das Problem bereits in #28 erläutert wurde.


----------



## kneitzel (25. Nov 2019)

Und das Problem hast du doch auch schon gelöst:

```
int counter2 = 0;
        for (int i = 0; i < array.length; i++) {
            counter2 += array[i].length;
        }
```
Da summierst Du ja die Anzahl der Felder in allen Arrays zusammen.

Aber was machst Du danach? Erläutere das mal in Worten. Und dann schau genau an, was Du da machst.


----------



## tfausw (25. Nov 2019)

JustNobody hat gesagt.:


> Und das Problem hast du doch auch schon gelöst:
> 
> ```
> int counter2 = 0;
> ...


Würde es dann reichen den letzten Index also array.length -1 nicht mit zu übernehmen? Weil das wäre ja dann im sortierten Fall der max Wert und somit ein Wert pro Array weniger.


----------



## mihe7 (25. Nov 2019)

tfausw hat gesagt.:


> Würde es dann reichen den letzten Index also array.length -1 nicht mit zu übernehmen? Weil das wäre ja dann im sortierten Fall der max Wert und somit ein Wert pro Array weniger.


Allmählich kommen wir der Sache näher


----------



## Snaer (25. Nov 2019)

Mir fällt jedoch keine geschickte Lösung zum tauschen ein mit unbekannten Längen :/

```
public class beispiel {
    public static void main(String[] args) {
        int [][] b = {
                new int [] {1,2,3,4},
                new int [] {4,3,2,1},
                new int[] {0,7,8,4,3},
                new int[] {-13,4} };
        int n =0;
        int [] a ;
        for (int i = 0; i < b.length; i++) {
              n += b[i].length;
        }
        a = new int [n];
        System.out.println(a.length);
        int[] c = {};
        int tmp1 = b[0][0];
        int tmp2 = b[1][0];
        if (b[0] == null || b[1] == null || b.length < 1)
        for (int i = 1; i < b[0].length; i++) {
            if (b[0][i] > tmp1) {
                tmp1 = b[0][i];
                b[0][i] = b[0][b[0].length - 1];
                b[0][b[0].length - 1] = tmp1;
            }
        }
        for (int i = 0; i < b[1].length; i++) {
            if (b[1][i] > tmp2) {
                tmp2 = b[1][i];
                b[1][i] = b[1][b[1].length - 1];
                b[1][b[1].length - 1] = tmp2;
            }
        }
```
So klappt es zwar die größte Zahl immer an die letzte Stelle zu setzen, jedoch allerdings wieder nur wenn ich zuvor weiß wie viele Teilarrays vorhanden sind.
Aber wie bekomme ich es hin den größtern Wert für jedes Teilarray heraus zu finden wenn ich nicht weiß wie viele es überhaupt gibt?


----------



## kneitzel (25. Nov 2019)

Also wie schon gesagt: Erläutere doch erst einmal in Worten, was Du machen willst. Hör auf in Code zu denken! Werde Dir erst klar darüber, was gemacht werden muss, dann kannst Du darüber nachdenken, wie Du es in Code ausdrücken kannst.



mihe7 hat gesagt.:


> Allmählich kommen wir der Sache näher



Aber es ist ein herumraten. Und dafür, dass er doch schon fast fertig war und nur eine Kleinigkeit geändert werden muss, ist es erstaunlich, dass immer noch falsche Ideen kommen und man eben so Hinweise nicht befolgen will.

Wenn man sich einmal klar macht, dass man die Anzahl der Arrays abziehen will, dann kommt man auch sehr schnell darauf, dass die Anzahl doch einfach array.length ist und dann sollte einem die -1 nicht erst in den Kopf kommen....

Ansonsten frage ich mich, ob wir dies nicht zu komplex machen. Ich würde die -1 direkt in der Schleife abziehen - und zwar nur, wenn das Array überhaupt Elemente hat. Was passiert denn, wenn ein Array leer ist? Da fällt er doch dann wieder auf die Nase ...


----------



## kneitzel (25. Nov 2019)

Snaer hat gesagt.:


> Mir fällt jedoch keine geschickte Lösung zum tauschen ein mit unbekannten Längen :/


Hatte ich es hier im Thread geschrieben oder in einem anderen:

Unterteil die Probleme in Methoden! Profis schreiben in der Regel keine solchen Methoden und halten ihre Methoden deutlich kleiner, damit diese einfacher zu schreiben sind, man den überblick behält und alles gut lesbar ist.

Das alles wird sofort ganz einfach, wenn Du einfach eine Methode schreibst, die ein Array bekommt und bei diesem Array dann den maximalen Wert ans Ende stellt.

Dann kannst Du eine Methode schreiben, die dies für alle Arrays in einem Array macht.

==> So sollte es auch für Dich deutlich einfacher und übersichtlicher werden!


----------



## tfausw (25. Nov 2019)

JustNobody hat gesagt.:


> Wenn man sich einmal klar macht, dass man die Anzahl der Arrays abziehen will, dann kommt man auch sehr schnell darauf, dass die Anzahl doch einfach array.length ist und dann sollte einem die -1 nicht erst in den Kopf kommen....


Habe ich tatsächlich gerade. Jedoch nach wie vor irgendwo einen Rechenfehler. Und doch ich mache mir sogar sehr viele Gedanken über die Hinweise. 



JustNobody hat gesagt.:


> Ansonsten frage ich mich, ob wir dies nicht zu komplex machen. Ich würde die -1 direkt in der Schleife abziehen - und zwar nur, wenn das Array überhaupt Elemente hat. Was passiert denn, wenn ein Array leer ist? Da fällt er doch dann wieder auf die Nase ...


Habe ich tatsächlich auch, klappt nur nicht so ganz..


```
for (int i = 0; i < array.length; i++) {
    if (array == null || array.length == 0) {
        return new int[] {}; // leeres Array der Länge 0 ausgeben
    }
}
```


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Aber es ist ein herumraten. Und dafür, dass er doch schon fast fertig war und nur eine Kleinigkeit geändert werden muss, ist es erstaunlich, dass immer noch falsche Ideen kommen und man eben so Hinweise nicht befolgen will.


Leider. Ich verstehe es ehrlich auch nicht. Aber da es gleich drei Leute sind, die hier ein Problem haben, zweifle ich langsam an mir selbst. *Heul-Smiley*


----------



## tfausw (25. Nov 2019)

mihe7 hat gesagt.:


> Leider. Ich verstehe es ehrlich auch nicht. Aber da es gleich drei Leute sind, die hier ein Problem haben, zweifle ich langsam an mir selbst. *Heul-Smiley*


Ich glaube es liegt weniger an euch, ich für meinen Teil verzweifle selber fast, obwohl man ja scheinbar nah dran ist und vermutlich denkt man was ähnliches, drückt es nur anders aus oder denkt zu komplex.


----------



## kneitzel (25. Nov 2019)

tfausw hat gesagt.:


> oder denkt zu komplex.


Ja, das dürfte es aus meiner Sicht sein. Daher wäre meine Tendenz, wirklich mehr in Methoden zu unterteilen.

Wollen wir dies mal versuchen? Wir sind schon bei #154 - also können wir jetzt auch richtig den Thread nutzen.

1.  Schreib eine Methode `public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount)`
==> Also es wird ein Array gegeben (z.B. {1, 2, 3}) und die Info, wie viele Elemente ignoriert werden sollen (z.B. 1) und dann soll zurück gegeben werden, wie viele Elemente da zu berücksichtigen sind. (In dem Beispiel wäre meine Erwartungshaltung 2.
Bedenke, dass evtl. mehr Elemente ignoriert werden sollen als vorhanden sind. Dann wäre 0 zurück zu geben.

Kannst Du diese Methode mal hier rein schreiben?


----------



## mihe7 (25. Nov 2019)

JustNobody hat gesagt.:


> Kannst Du diese Methode mal hier rein schreiben?


Puh, gerade noch rechtzeitig gesehen - ich war gerade dabei seinen Code umstrukturiert zu posten


----------



## kneitzel (25. Nov 2019)

Und wenn, dann wäre es auch nicht so wild. Aber ich habe die Hoffnung, dass es etwas bringt, wenn wir wirklich hier mal alles in einzelne Methoden packen. Denn die Algorithmen selbst bekommen sie ja zumindest teilweise hin.


----------



## tfausw (25. Nov 2019)

JustNobody hat gesagt.:


> Kannst Du diese Methode mal hier rein schreiben?




```
public static int shortMethod(int array[], int ignoreCount) {
        if (ignoreCount > array.length) return 0;
        
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            count = array[i];
                
        } 
        int result = count - ignoreCount;
        return result;
    }
```

Wäre meine Lösung.


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Aber wie bekomme ich es hin den größtern Wert für jedes Teilarray heraus zu finden wenn ich nicht weiß wie viele es überhaupt gibt?


Du weißt doch, wie viele es sind: b.length


----------



## kneitzel (25. Nov 2019)

Wir wollen nicht die Werte des Arrays aufaddieren. Es geht nur um die Größe des Arrays. Also so:

```
public static int getElementCountOfArrayWithIgnoredElements(int array[], int ignoreCount) {
    if (array.length <= ignoreCount) return 0;
    
    return array.length - ignoreCount;
}
```

Kannst Du nun eine Methode schreiben, die die Anzahl der Elemente in einem zweidimensionalen Array (Einem Array von Arrays) ermittelt?



```
public static int getElementCountOfArraysWithIgnoredElements(int array[][], int ignoreCountPerArray) {
}
```

Tipp 1: Nutz dazu die obere Methode. 
Tipp 2: Jede Methode ist sehr klein. Es werden in der Regel nie mehr als 5 Befehle zu erwarten sein ...


----------



## mihe7 (25. Nov 2019)

tfausw hat gesagt.:


> Wäre meine Lösung.


Hast Du die einmal ausprobiert? Hat sich erledigt (s. vorherigen Kommentar von @JustNobody )


----------



## tfausw (25. Nov 2019)

mihe7 hat gesagt.:


> Hast Du die einmal ausprobiert? Hat sich erledigt (s. vorherigen Kommentar von @JustNobody )


Ja, bei mir kam ja auch dasselbe raus nur war deutlich länger, deswegen wundert mich das gerade


----------



## mihe7 (25. Nov 2019)

tfausw hat gesagt.:


> bei mir kam ja auch dasselbe raus


Nein, bei Dir kam der Wert des letzten Elements im Array abzgl. ignoreCount raus - oder 0, falls ignoreCount die Array-Länge übersteigt. D. h. bei {1,2,3} kommt für ignoreCount==1 tatsächlich 2 raus, bei {1,2,4} dagegen 3.


----------



## tfausw (25. Nov 2019)

mihe7 hat gesagt.:


> Nein, bei Dir kam der Wert des letzten Elements im Array abzgl. ignoreCount raus - oder 0, falls ignoreCount die Array-Länge übersteigt. D. h. bei {1,2,3} kommt für ignoreCount==1 tatsächlich 2 raus, bei {1,2,4} dagegen 3.


Tatsache, sorry.


----------



## mihe7 (25. Nov 2019)

tfausw hat gesagt.:


> Tatsache, sorry.


Wichtig ist, dass Du (Deinen) Code verstehst, also nachvollziehen kannst. Das ist mit ein Grund, warum man das in kleinere Methoden aufteilt. Nachvollziehen kannst Du das gedanklich oder wirklich auf Papier. Mit Übung wird es leichter. Bei Schleifen wirklich jede Iteration einzeln durchgehen.

Zurück zum Thema: wo bleibt die Methode aus #159?


----------



## tfausw (25. Nov 2019)

Möchte schon fast gar nichts falsches mehr sagen .


```
public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
       
        int result = 0;
        for (int i = 0; i < array.length; i++) {
        result += array[i].length - ignoreCountPerArray;
           
            }
        return result;
    }
```


----------



## kneitzel (25. Nov 2019)

tfausw hat gesagt.:


> Möchte schon fast gar nichts falsches mehr sagen .



Da musst Du Dir keine Sorgen machen. Nur eben sieh es uns nach, falls mal etwas Ungeduld sichtbar sein sollte. An Anfang ist Programmieren nicht einfach nur eben fällt es uns hier im Forum teilweise schwer, den richtigen Ansatz zu finden.



tfausw hat gesagt.:


> ```
> public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
> 
> int result = 0;
> ...



Ja, sehr schön. Aber nicht die andere Methode verwendet. Dadurch fehlt der Check, ob denn genug Element im Array sind.

```
public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
  int result = 0;
  for (int i = 0; i < array.length; i++) {
    result += getElementCountOfArrayWithIgnoredElements(array[i].length, ignoreCountPerArray);
  }
  return result;
}
```

So sähe es mit der Methode aus.

Nun brauchen wir als nächstes eine Method, die das größte Element ans Ende packt. Wenn Du bereits ein Sortieralgorithmus hast, dann nimm einfach den. (Der macht zwar zuviel, und hat ein schlechteres Laufverhalten, aber das kann man ggf ignorieren.)

Und wenn Du das hast, dann bauchen wir noch ein copyArray(source, sourceStart, sourceEnd, target, targetStart)
mit source und target den Arrays und das andere sind die indices - also welcher Bereich vom source kopiert werden soll und wohin im target es gehen soll.


----------



## tfausw (25. Nov 2019)

JustNobody hat gesagt.:


> Ja, sehr schön. Aber nicht die andere Methode verwendet. Dadurch fehlt der Check, ob denn genug Element im Array sind.
> 
> ```
> public static int count2dPlusRemove(int array[][], int ignoreCountPerArray) {
> ...


War zu blöd das so richtig zu schreiben, daran gedacht hatte ich, nur bisschen an der Sache vorbei gedacht. 



JustNobody hat gesagt.:


> Nun brauchen wir als nächstes eine Method, die das größte Element ans Ende packt. Wenn Du bereits ein Sortieralgorithmus hast, dann nimm einfach den. (Der macht zwar zuviel, und hat ein schlechteres Laufverhalten, aber das kann man ggf ignorieren.)




```
int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
                result[counter] = r[i];   
                counter++;
            }
        }
```

Das Array wird sortiert und das letzte Element wird nicht übernommen. (Falls richtig  ) 



JustNobody hat gesagt.:


> Da musst Du Dir keine Sorgen machen. Nur eben sieh es uns nach, falls mal etwas Ungeduld sichtbar sein sollte. An Anfang ist Programmieren nicht einfach nur eben fällt es uns hier im Forum teilweise schwer, den richtigen Ansatz zu finden.


Dafür nochmal wirklich herzlichsten Dank an euch, dass ihr Anfängern helft!


----------



## kneitzel (25. Nov 2019)

Ja, ist ok. Der Code scheint auf den ersten Blick das zu machen, was verlangt ist. Nur eben ging es mir auch etwas um die Unterteilung, damit man dann entsprechend viele kleine Methoden hat, die alle direkt selbsterklärend sind.

Aber wenn wir damit einen Abschluss gefunden haben sollten, dann soll es auch ok sein ... müssen ja nicht 300 voll kriegen


----------



## tfausw (25. Nov 2019)

Tatsächlich war es das leider glaube ich noch nicht  ..

Ich habe immer noch zwei Fehler:
1. (falls array null oder leer)


```
for (int i = 0; i < array.length; i++) {
            if (array == null || array.length == 0) {
                return new int[] {};
            }
        }

/* Ausgabe: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
/at Functionality.flatternAndSortWithoutBiggest(Functionality.java:29) Zeile 29 = result[counter] = r[i];
/    at Functionality.main(Functionality.java:54)
*/
```

2. Rechenfehler, Ausgabe [8, 7, 2, 2, 1, 0, 0, 0, 0, -4], bei Eingabe {1,11,3,2},{5,-4,6,2,4,2},{8,9,7}
(nachträglich wird absteigend sortiert)


```
int counter2 = 0;
        for (int i = 0; i < array.length; i++) {
            counter2 += array[i].length;
        }
      
        int[] result = new int [counter2 - array.length];

        int counter = 0;
        for (int[] r : array) {
            Arrays.sort(r);
            for (int i = 0; i < array.length - 1; i++) {
            result[counter] = r[i]; 
            counter++;
            }
        }
```


----------



## jono (25. Nov 2019)

```
public class Test {
    public static int[] doit() {
           int[] eindim = new int[9];
           int[][] zweidim = {
                   new int[] {1,2,3},
                   new int[] {4,5,6},
                   new int[] {7,8,9} };

           // Kopiere alle Teilarrays aus zweidim nach eindim
           int counter = 0;
           for (int i = 0; i < zweidim.length; i++) {
               for (int j = 0; j < zweidim[i].length; j++) {                
                   eindim[counter] = zweidim[i][j];
                   counter++;
               }
           }
                       
           // Sortiere eindim
           boolean swapped;
           do {
               swapped = false;
               for(int i = 1; i<eindim.length;i++) {
                   if(eindim[i]>eindim[i-1]) {
                       int swap = eindim[i-1];
                       eindim[i-1] = eindim[i];
                       eindim[i] = swap;
                       swapped = true;
                   }            
                }                           
           } while(swapped);

           // Fertig
           return eindim;
    }

    public static void main(String[] args) {
        System.out.println(Arrays.toString(doit()));
    }
}
```


----------



## jono (25. Nov 2019)

Wie bestimme ich denn jetzt hier jedes Maximum der Teilarrays aus "zweidim"? Diese muss ich dann auch löschen. Mit den vorherigen Beiträgen war es mir nicht ganz schlüssig


----------



## kneitzel (25. Nov 2019)

@*tfausw*

Den ersten Part hatten wir doch mit den Methoden etwas abgefackelt dachte ich.

Der Code macht so auch keinen Sinn: In der äußeren for Schleife greifst du auf array.length zu und dann prüfst Du, ob array null ist? Wäre array null, dann hättest Du bei array.length eine NPE bekommen.
Wäre array.length 0, dann wärst Du in die for schleife nicht rein gekommen, denn i startet bei 0 und läuft, so lange es kleiner array.length ist. 0 ist nicht kleiner 0, also würde er nie in die Schleife gehen.


----------



## kneitzel (25. Nov 2019)

jono hat gesagt.:


> Wie bestimme ich denn jetzt hier jedes Maximum der Teilarrays aus "zweidim"? Diese muss ich dann auch löschen. Mit den vorherigen Beiträgen war es mir nicht ganz schlüssig


Also bisher war die Kernidee, dass die Maxima nicht erst mit kopiert wurden. Dazu diente die Idee, das Maximum ans Ende zu setzen um dann das letzte Element in jedem Teil-Array von Anfang an nicht mit zu kopieren.

Ansonsten kannst Du auch gerne einen anderen Weg gehen, in dem Du dann nach dem aufbau des eindimensionalen Arrays hin gehst und dann
für jedes Teil-Array das Maximum ermitteln um dann im Ergebnis-Array ein Vorkommen vom ermittelten Maximum zu löschen.


----------



## jono (25. Nov 2019)

Die erste Idee kann ich halt nicht umsetzen weil die Arrayelemente in beliebiger Reihenfolge eingegeben werden können sollen, also das Maximum nicht ans Ende gebunden sein darf.

```
int max = Integer.MIN_VALUE;
for(int i: zweidim) if(max<i) max=i;
```

Ist das korrekt oder ist die Ermittlung so falsch weil mir wird max< i und das nach dem "=" rot angestrichen


----------



## kneitzel (25. Nov 2019)

Nur weil eine Eingabe in beliebiger Reihenfolge erfolgen kann, bedeutet dies doch nicht, dass man es nicht ändern darf, oder?

Und zweidim ist sozusagen ein Array of Arrays. i ist damit nicht ein int sondern ein int[].
Hinzu kommt, dass Du ja nicht das Maximum auf zweidim haben willst sondern jeweils von jedem Teil-Array.

Ihr macht euch euer Leben selbst unnötig schwer, in dem ihr zu viel auf einmal versucht... und dabei dann Code schreibt, der unleserlich und schwer zu verstehen ist.

Und wenn etwas rot angestrichen wird: Mal mit der Maus drüber gehen und schauen, was die IDE dann als Meldung ausspuckt. Zur Not einmal die Übersetzung starten!


----------



## jono (25. Nov 2019)

Das klingt so abstrakt, ja ist ein int[] das stimmt, aber die teilarrays sind ja "zweidim" zugehörig und wie spreche ich denn die Teilarrays an? Und wie setze ich die Maxima an die letzte Stelle der Teilarrays im Code


----------



## kneitzel (25. Nov 2019)

Also das wurde mehrfach in den Threads behandelt.

Ich habe jetzt einfach einmal einen kurzen Code geschrieben, der die Idee: "Abwandeln des QuickSort Algorithmus" aufgreift.


```
import java.util.Arrays;
import java.util.logging.Logger;

public class ArrayMerge {
    private final static Logger log = Logger.getLogger(ArrayMerge.class.getName());

    public static int[] quicksort(final int[] source) {
        return sort(source, 0, source.length-1);
    }

    public static int[] sort(final int[] source, final int start, final int end) {
        log.info("sort: " + start + " - " + end);
        int[] result;

        if (end - start > 0) {
            int[] first = sort(source, start, start + (end-start)/2);
            int[] second = sort(source, start + (end-start)/2 + 1, end);
            result = merge(first, second);
        } else {
            result = new int[] { source[start] } ;
        }
        log.info("sort(" + Arrays.toString(source) + ", " + start + ", " + end + ") = " + Arrays.toString(result));
        return result;
    }

    public static int[] merge(final int[] first, final int[] second) {
        return merge(first, first.length, second, second.length);
    }

    public static int[] merge(final int[] first, final int lengthFirst, final int[] second, final int lengthSecond) {
        // Normalen QuickSort Algorithmus könnte man durch ersetzen von lengthFirst und lengthSecond durch
        // first.length und second.length bekommen.
        int[] result = new int[lengthFirst + lengthSecond];

        int firstIndex = 0;
        int secondIndex = 0;
        int resultIndex = 0;
        while (resultIndex < result.length) {
            if (firstIndex < lengthFirst && secondIndex < lengthSecond) {
                // We take minimum from first and second
                if (first[firstIndex] < second[secondIndex]) {
                    result[resultIndex] = first[firstIndex];
                    firstIndex++;
                } else {
                    result[resultIndex] = second[secondIndex];
                    secondIndex++;
                }
            } else if (firstIndex < lengthFirst) {
                // We take element from first
                result[resultIndex] = first[firstIndex];
                firstIndex++;
            } else {
                // We take element from second
                result[resultIndex] = second[secondIndex];
                secondIndex++;
            }
            resultIndex++;
        }

        log.info("Merged: " + Arrays.toString(first) + " + " + Arrays.toString(second) + " = " + Arrays.toString(result));
        return result;
    }

    public static void main (String[] args) {

        // testing the QuickSort
        int[] array = { 17, 32, 3, 45, 1, 7 };
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(ArrayMerge.quicksort(array)));

        // Now merging the Arrays with ignoring of the highest Element.
        int[][] twodimarray = { { 21, 14, 7 },
                { 8, 32, 24, 16 },
                { 9, 18, 27} };

        int[] result = new int[0];

        for(int[] subArray: twodimarray) {
            if (subArray.length > 1)
                result = merge(result, result.length, quicksort(subArray), subArray.length - 1);
        }

        System.out.println(Arrays.toString(result));
    }
}
```

In dem Code findet man in erster Linie den QuickSort. Lediglich das merge wurde für die Anforderungen angepasst, so dass die zu behandelnde Größe mit angegeben werden kann. Die Parameter firstLength und secondLength kann man aber entfernen und dann im code duch die .length Angaben ersetzen um dann das altbekannte merge zu haben.

Und dann ist der gewünschte Code nur noch nach und nach ein Merge der Listen mit dem Zwischenergebnis.
Sollte ein Teilarray nicht mehr wie ein Element haben, so ist kein Merge notwendig.

Also wenn Ihr QuickSort hattet, eine relativ einfache Anpassung...

Edit: Habe sogar einige log Aufrufe eingebaut zum einfachen nachvollziehen der Sortierung. Falls es da noch Verständnisprobleme geben sollte.


----------



## jono (25. Nov 2019)

Ich darf laut Aufgabenstellung nur BubbleSort verwenden


----------



## kneitzel (25. Nov 2019)

Wie Du sortierst ist doch egal. Dann ersetz den quicksort Aufruf durch bubblesort.
Der wichtige Punkt ist lediglich der merge und das ist schlicht und einfach nur ein merge von zwei sortierten Arrays in ein sortiertes Zielarray. Und das war ja genau die Aufgabe, was zu schreiben war.


----------



## jono (25. Nov 2019)

```
import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}}; 

	       int counter = 0; 
	       for (int i = 0; i < zweidim.length; i++) { 
	           for (int j = 0; j < zweidim[i].length; j++) {
	        	   
	        	   eindim[counter] = zweidim[i][j]; 
	               counter++; 
	    	  
	       }
	       }
	       
	         boolean swapped;
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	           
	           
	           int max = Integer.MIN_VALUE;
	           for(int[] i : ) if(max<i) max=i;
	         
	           
	           return eindim;
    	 
	}    
           
         
}
```

Ich würde mich gerne an dem Code orientieren es ist schon alles fertig nur dass die Maxima aus den Teilarrays des "zweidim" noch ausgelassen werden müssen


----------



## jono (25. Nov 2019)

Ja stimmt , nur dein Code sieht so kompliziert aus ^^


----------



## jono (25. Nov 2019)

Ich kann jetzt nicht wirklich herausfiltern wie ich deinen Code bzw welchen Teil deines Codes ich jetzt sinnvoll an meinen anpassen kann das ist mein großes Problem


----------



## kneitzel (25. Nov 2019)

Die Idee ist mehrfach genannt worden und wurde sogar groß und breit erläutert: Du kannst die Teil-Arrays durchgehen und das Maximum an die letzte Stelle schreiben. Dann musst Du nur noch beim Kopieren jeweils die letzte Stelle auslassen....

Und genau das ist auch die Idee, die ich verfolgt habe ...


----------



## Snaer (25. Nov 2019)

jono hat gesagt.:


> Ja stimmt , nur dein Code sieht so kompliziert aus ^^


Klingt vielleicht dumm, aber ich muss mich anschließen. Leider fällt es mir schwer einen schnellen Überblick zu finden.


----------



## jono (25. Nov 2019)

Ich kann mit Deinen Hilfen von den vorherigen Seiten zu dem Problem "Maximum ermitteln und auslassen" auch nicht wirklich viel anfangen weil da Sachen drin stehen die ich z.B. nicht kenne und ich dementsprechend nicht weiß diese einzufügen. 
Ich wäre Dir sehr dankbar wenn du dich nochmal genau auf meinen Code beziehst um sozusagen individueller darauf einzugehen
Wie ermittelt man denn das Maximum von den Teilarrays von "zweidim" , bei Google kann ich da nicht mal etwas maßschneidern für mich sitze ja die ganze Zeit am Laptop überlege und suche nach Lösungen. Also wie sortiere ich Teilarrays? und wie ermittle ich das Maximum von den Teilarrays ? sortieren an sich ist nicht das Problem nur das sortieren bei meinen Teilarrays. Das ist mein Problem .


----------



## mihe7 (25. Nov 2019)

```
3 2 1
5 6 4
8 7 9
```

Für jede Zeile wird jetzt die Position des Maximums ermittelt und mit dem letzten Element getauscht:


```
3 2 1 -> Maximum an Index 0
```
Vertausche im Array den Wert an Index 0 mit dem Wert an Index 2 (letzter Index im Array)

```
1 2 3
```


```
5 6 4 -> Maximum an Index 1
```
Vertausche im Array den Wert an Index 1 mit dem Wert an Index 2 (letzter Index im Array)

```
5 4 6
```


```
8 7 9 -> Maximum an Index 2
```
Vertausche im Array den Wert an Index 2 mit dem Wert an Index 2 (letzter Index im Array)

```
8 7 9
```

Ergebnis

```
1 2 3
5 4 6
8 7 9
```

Jetzt kopiert man jedes dieser Arrays in 1D-Array, lässt aber jeweils das letzte Element aus:

```
1 2 3 --> 1 2
5 4 6 --> 1 2 5 4
8 7 9 --> 1 2 5 4 8 7
```


----------



## Snaer (25. Nov 2019)

mihe7 hat gesagt.:


> ```
> 3 2 1
> 5 6 4
> 8 7 9
> ...


Das Grund Prinzip ist schlüssig, aber ich tue mich schwer damit es in einem mehrdimensionalen Array umsetzen. Mein Ansatz bislang sieht so aus allerdings funktioniert es damit leider noch nicht. 

```
int tmp = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length; j++) {
                tmp = b[i][0];
                if (b[i][j] > tmp) {
                    tmp = b[i][j];
                    b[i][j] = b[i][b[i].length - 1];
                    b[i][b[i].length - 1] = tmp;
                }
            }
        }
```


----------



## jono (25. Nov 2019)

Okay sehr gut aufgegriffen, aber wie ermittelt man denn jetzt das Maximum davon ?


----------



## jono (25. Nov 2019)

Der erste Schritt ist für mich das größte Problem


----------



## Snaer (25. Nov 2019)

Mein Problem ist hauptsächlich die Umsetzung wenn man die Werte der einzelnen Arrays nicht kennt. 
Wenn man sich die Werte selbst vorgibt bekomme ich es an sich hin indem ich die einzelne Arrays durch gehe, aber das funktioniert bislang nur soweit ich die Arrays auch klar angebe also b[0]_ etc. mit meiner Schleife bei der ich versuche unbekannte Arrays umzusetzen klappt es allerdings leider nicht_


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Das Grund Prinzip ist schlüssig, aber ich tue mich schwer damit es in einem mehrdimensionalen Array umsetzen.


 Das ist das, was ich ziemlich am Anfang des Threads schon einmal zu erklären versucht habe (auch im Zusammenhang mit dem Maximum). Ihr müsst anfangen, die Dinge besser voneinander zu isolieren. Das funktioniert genauso wie mit einem 1D-Array, nur dass nochmal eine Schleife außenrum ist:

```
for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        // ermittle Index ix des größten Elements in subArray
        // und danach: vertausche ix und subArray.length-1 in subArray.
    }
}
```

Wie ermittelt man nun den Index des größten Elements in einem Array? 

```
int ix = 0;
int max = subArray[ix];
for (int k = ix + 1 ; k < subArray.length; k++) {
    if (subArray[k] > max) {
        max = subArray[k];
        ix = k;
    }
}
```

Danach steht in ix der Index des größten Elements. Wie vertauscht man nun das Element ix und das letzte Element in subArray?

```
int last = subArray.length - 1;
int tmp = subArray[ix];
subArray[ix] = subArray[last];
subArray[last] = tmp;
```

So, alles zusammen:


```
for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        // ermittle Index ix des größten Elements in subArray
        int ix = 0;
        int max = subArray[ix];
        for (int k = ix + 1 ; k < subArray.length; k++) {
            if (subArray[k] > max) {
                max = subArray[k];
                ix = k;
            }
        }

        // und danach: vertausche ix und subArray.length-1 in subArray.
        int last = subArray.length - 1;
        int tmp = subArray[ix];
        subArray[ix] = subArray[last];
        subArray[last] = tmp;
    }
}
```

Das ist aber ziemlich hässlich, daher lagert man die Dinge in Methoden aus:
Schöner:

```
for (int i = 0; i < array.length; i++) {
    int[] subArray = array[i];
    if (subArray.length > 0) {
        int ix = indexOfMax(subArray);
        swap(ix, subArray.length-1);
    }
}
```
Die Methoden sehen genauso wie der Code aus, den sie ersetzt haben, nur dass die Parameter ggf. anders benannt werden und am Ende ein return folgt.


----------



## Snaer (25. Nov 2019)

Tut mir Leid für die dumme Frage, aber verstehe ich es richtig das sich dieser Code jetzt auf ein 1D Array bezieht? Weil du ja angesprochen hast, dass man eine weitere Schleife außen rum benötigt oder ist array das 2 Dimensionale array?


----------



## mihe7 (25. Nov 2019)

Das array ist das 2D-Array, subArray ist das "aktuelle" 1D-Array (aus array) innerhalb der "Schleife außenrum".


----------



## Snaer (25. Nov 2019)

Könntest du mir es dann vielleicht ein wenig erläutern? 
Du beginnst ja mit der For Schleife in der i inkrementiert wird. Allerdings nur solange i < array.length ist. 
Dabei verstehe ich jetzt folgendes nicht ganz: array.length gibt ja bei einem 2D Array die Anzahl der Teil Arrays an wenn ich jetzt nicht völlig falsch liege.
Mit dem Code int [] subArray = array_ durchläuft man dann doch nicht vollständig jedes mögliche Array oder? Oder ist das quasi der Schritt in dem du alle möglichen Werte des 2D Arrays in das 1D transferierst?_


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Du beginnst ja mit der For Schleife in der i inkrementiert wird. Allerdings nur solange i < array.length ist.
> Dabei verstehe ich jetzt folgendes nicht ganz: array.length gibt ja bei einem 2D Array die Anzahl der Teil Arrays an wenn ich jetzt nicht völlig falsch liege.


array.length gibt an, wie viele Elemente array aufnehmen kann (sprich: die Größe von array). 

In diesem Fall handelt es sich bei den Elementen zufälligerweise um Arrays. Es spielt also gar keine Rolle, was in dem Array steckt: {a,b,c} hat drei Elemente, egal ob a nun ein int oder ein Array ist.



Snaer hat gesagt.:


> Mit dem Code int [] subArray = array[i] durchläuft man dann doch nicht vollständig jedes mögliche Array oder?


Nein, damit hole ich mir einfach das i-te Element aus array - bei dem es sich ja wieder um ein Array handelt. Das subArray durchlaufen wird erst in der zweiten Schleife.


----------



## Snaer (25. Nov 2019)

Dabei verstehe ich dann nicht ganz was die erste For Schleife genau bewirkt. 
Soweit ich es bislang verstanden habe werden die Indexe bei mehrdimensionalen Arrays quasi so angesprochen b[0][0] gibt mir dann den Wert des ersten Teilarrays am Index 0 aus.
Müsste ich dementsprechend nicht auch bei array dann zwei Klammern jeweils anpassen? 

Und damit sind die Werte ja noch nicht übertragen richtig? 
Da stellt sich mir nun das weitere Problem, dass das eindimensionale Array außerhalb der for Schleife nicht deklariert ist.


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Dabei verstehe ich dann nicht ganz was die erste For Schleife genau bewirkt.


Also, Du hast ein "äußeres Array", das mehrere "innere Arrays" enthält. Ähnlich einer Tabelle: die kann man als Array von Zeilen auffassen und jede Zeile als Array von Spalten.

Mit der äußeren for-Schleife durchlaufe ich nun die Indizes des äußeren Arrays (in der Tabelle: sozusagen die Zeilennummern) und hole mir mit array[i] das i-te innere Array (die i-te Zeile).



Snaer hat gesagt.:


> Soweit ich es bislang verstanden habe werden die Indexe bei mehrdimensionalen Arrays quasi so angesprochen b[0][0] gibt mir dann den Wert des ersten Teilarrays am Index 0 aus.


Das *kann* man machen, *weil* b[0] ein Array liefert  

```
int[] subArray = b[0];
int wert = subArray[4];
// ist analog zu
int wert = (b[0])[4];
// also
int wert = b[0][4];
```



Snaer hat gesagt.:


> Müsste ich dementsprechend nicht auch bei array dann zwei Klammern jeweils anpassen?


Nein, weil es in Java keine echten mehrdimensionalen Arrays gibt: es sind Arrays von Arrays. 



Snaer hat gesagt.:


> Und damit sind die Werte ja noch nicht übertragen richtig?


Nein. Der Code verschiebt lediglich das Maximum eines jeden Subarrays ans Ende.



Snaer hat gesagt.:


> Da stellt sich mir nun das weitere Problem, dass das eindimensionale Array außerhalb der for Schleife nicht deklariert ist.


Das macht ja nichts, Du kannst ja über array auf die einzelnen Arrays zugreifen.


----------



## Snaer (25. Nov 2019)

mihe7 hat gesagt.:


> Das macht ja nichts, Du kannst ja über array auf die einzelnen Arrays zugreifen.


Sind die Werte dadurch denn dann in array sortiert ? Weil du hattest in den Code doch nur Werte zu subArray zugewiesen und array nur für die For Schleife benutzt. 
Und wie bringe ich diese Werte jetzt ins 1D Array ? Mein Ansatz dabei sieht so aus 

```
int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length - 1; j++) {
                a[count] = b[i][j];
                count++;
            }
        }
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < a.length; i++) {
                if (a[i] > a[i - 1]) {
                    int swap = a[i - 1];
                    a[i - 1] = a[i];
                    a[i] = swap;
                    swapped = true;
                }
            }
        } while (swapped);
        System.out.println(Arrays.toString(a));
```
Problem dabei ist mit dem Ausgangsarray 
int[][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
                new int[] { -13, 4 } };
bekomme ich jedoch dabei die Ausgabe [8, 7, 4, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, -13]
Woher dabei die ganzen 0 kommen ist mir ehrlich gesagt ein Rätsel. 
Ich hatte versucht die letzte Stelle dadurch zu ignorieren indem ich das b_.length -1 durch eine -2 ersetzte , das führt allerdings nur dazu das die -13 durch eine weitere 0 ersetzt wird._


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Sind die Werte dadurch denn dann in array sortiert ?


Nein, das ist auch unnötig, da das Ausgabearray sowieso sortiert werden muss. 



Snaer hat gesagt.:


> Und wie bringe ich diese Werte jetzt ins 1D Array ? Mein Ansatz dabei sieht so aus


Ja, der passt.


Snaer hat gesagt.:


> Woher dabei die ganzen 0 kommen ist mir ehrlich gesagt ein Rätsel.


Du hast die Größe für a noch nicht richtig berechnet. Wenn Du ein Array der Größe 15 erzeugst, sind erstmal alle Werte im Array 0. Wenn Du jetzt 10 Werte in das Array kopierst, stehen am Ende 5 Nullen. Wenn Du jetzt noch absteigend sortierst, stehen die negativen Werte rechts von den 0en.


----------



## Snaer (25. Nov 2019)

mihe7 hat gesagt.:


> Ja, der passt.
> 
> Aber mit dem Ansatz funktioniert es ja noch nicht das die letzte Stelle des Arrays ignoriert wird.
> Ich dachte mir das ich durch b_.length-2 quasi die letzte Stelle dann ignorieren müsste aber dadurch verschwindet dann jedoch aufeinmal die -13 aus dem Array.
> _


_


mihe7 hat gesagt.:



			Du hast die Größe für a noch nicht richtig berechnet. Wenn Du ein Array der Größe 15 erzeugst, sind erstmal alle Werte im Array 0. Wenn Du jetzt 10 Werte in das Array kopierst, stehen am Ende 5 Nullen. Wenn Du jetzt noch absteigend sortierst, stehen die negativen Werte rechts von den 0en.
		
Zum Vergrößern anklicken....

Gibts dann einen anderen Weg damit ich quasi keine leeren Stellen bekomme? 
Ich hab die Länge meines ein dimensionalen Array so bestimmt : 


		Code:In die Zwischenablage kopieren


int n =0;
int []a;
for (int i = 0; i < b.length; i++){
n+=b[i].length;
}
a= new int [n];

_


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Gibts dann einen anderen Weg damit ich quasi keine leeren Stellen bekomme?


Klar, Du musst die Größe des Arrays richtig berechnen. Dazu kannst Du Dir anschauen, wie es in #159 und #166 gemacht wurde. Die Zielgröße erhältst Du logischerweise mit `count2dPlusRemove(b, 1)`.


----------



## jono (25. Nov 2019)

Mihe wo würdest du denn dein Code bei mir einfügen ? SubArray wäre dann bei mir eindim oder ?


----------



## mihe7 (25. Nov 2019)

Nein, eindim ist das Ausgabearray. Bei Dir ist array einfach zweidim und das mit dem subArray kannst Du so lassen.


----------



## Snaer (25. Nov 2019)

mihe7 hat gesagt.:


> Klar, Du musst die Größe des Arrays richtig berechnen. Dazu kannst Du Dir anschauen, wie es in #159 und #166 gemacht wurde. Die Zielgröße erhältst Du logischerweise mit `count2dPlusRemove(b, 1)`.


Was meinst du mit count2dPlusRemove ? Ist das eine Methode in Java? Ich kenne dazu nämlich leider noch nichts.

Hab mir die Beiträge jedenfalls angesehen es klappt schonmal das die Größe richtig berechnet wird danke, aber bei dem einfügen hakt es dennoch mit dem Code den ich zuvor schon hier gepostet habe. 

```
int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length - 1; j++) {
                a[count] = b[i][j];
                count++;
```
Mit dem Code wird leider jede Stelle weiterhin hinzugefügt und wenn ich die -1 durch -2 ersetze werden einige Zahlen nur durch 0 ersetzt.


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Was meinst du mit count2dPlusRemove ? Ist das eine Methode in Java? Ich kenne dazu nämlich leider noch nichts.


Das ist die Methode aus #166 



Snaer hat gesagt.:


> aber bei dem einfügen hakt es dennoch mit dem Code den ich zuvor schon hier gepostet habe.


Zeig mal, wie Du die Länge von a berechnest.


----------



## Snaer (25. Nov 2019)

Habe es in diesem Moment auch bemerkt mein Fehler ups ^^


```
int n =0;
        int ignoreCountPerArray=1;
        for (int i = 0; i < b.length; i++) {
              n += b[i].length -ignoreCountPerArray;
        }
        a = new int [n];
```

Dabei bekomme ich als Ausgabe [8, 7, 4, 3, 3, 2, 2, 1, 1, 0, -13]. An sich klappt damit zumindest das absteigende sortieren, aber das ignorieren der letzten Stelle will irgendwie nicht so ganz.


----------



## Snaer (25. Nov 2019)

Ich muss mich ergänzen tatsächlich wird die größte Zahl in jedem Array bis auf einem ignoriert.
int [][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
            new int[] { -13, 4 } };
Aus jedem Array wird die 4 gelöscht, aber die 8 bzw das gesamte 3. Array bleibt vorhanden


----------



## jono (25. Nov 2019)

```
import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}}; 
	     
	  
	       int counter = 0; 
	       for (int i = 0; i < zweidim.length; i++) { 
	           for (int j = 0; j < zweidim[i].length; j++) {
	        	   
	        	   eindim[counter] = zweidim[i][j]; 
	               counter++; 
	           }
	       }
	               
	               for (int i = 0; i < zweidim.length; i++) {
	            	    int[] subArray = zweidim[i];
	            	    if (subArray.length > 0) {
	            	        
	            	        int ix = 0;
	            	        int max = subArray[ix];
	            	        for (int k = ix + 1 ; k < subArray.length; k++) {
	            	            if (subArray[k] > max) {
	            	                max = subArray[k];
	            	                ix = k;
	            	            }
	            	        }

	            	        
	            	        int last = subArray.length - 1;
	            	        int tmp = subArray[ix];
	            	        subArray[ix] = subArray[last];
	            	        subArray[last] = tmp;
	            	        
	            	    }
	            	}
	                      
	       
	       
	         boolean swapped;
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	           
	           
	           
	         
	           
	           return eindim;
    	 
	}    
           
         
}
```

Jetzt muss ich noch das Maximum aus dem auszugebenden Array eindim entfernen oder ? wie mache ich das


----------



## mihe7 (25. Nov 2019)

Snaer hat gesagt.:


> Ich muss mich ergänzen tatsächlich wird die größte Zahl in jedem Array bis auf einem ignoriert.


Kannst Du mal den ganzen Code posten?


----------



## Snaer (25. Nov 2019)

```
public class beispiel {
    public static void main(String[] args) {
        int[][] b = { new int[] { 1, 2, 3, 4 }, new int[] { 4, 3, 2, 1 }, new int[] { 0, 7, 8, 4, 3 },
                new int[] { -13, 4 } };
        int n =0;
        int [] a ;
        int ignoreCountPerArray=1;
        for (int i = 0; i < b.length; i++) {
              n += b[i].length -ignoreCountPerArray;
        }
        a = new int [n];
        for (int i = 0; i< b.length;i++) {
            int[] subArray= b[i];
            if (subArray.length>0) {
                int ix=0;
                int max=subArray[ix];
                for (int k =ix+1;k<subArray.length;k++) {
                    if(subArray[k]>max) {
                        ix=k;
                    }
                }
                int last = subArray.length-1;
                int tmp=subArray[ix];
                subArray[ix]=subArray[last];
                subArray[last]=tmp;
            }
        }
        int count = 0;
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[i].length - 1; j++) {
                a[count] = b[i][j];
                count++;
            }
        }
        boolean swapped;
        do {
            swapped = false;
            for (int i = 1; i < a.length; i++) {
                if (a[i] > a[i - 1]) {
                    int swap = a[i - 1];
                    a[i - 1] = a[i];
                    a[i] = swap;
                    swapped = true;
                }
            }
        } while (swapped);
        System.out.println(Arrays.toString(a));
        
    }

}
```


----------



## mihe7 (25. Nov 2019)

jono hat gesagt.:


> Jetzt muss ich noch das Maximum aus dem auszugebenden Array eindim entfernen oder ? wie mache ich das


S. #204


----------



## mihe7 (25. Nov 2019)

@Snaer Du hast hier:

```
for (int k =ix+1;k<subArray.length;k++) {
                    if(subArray[k]>max) {
                        ix=k;
                    }
                }
```
vergessen, das max zu setzen. Vgl. #191:

```
for (int k = ix + 1 ; k < subArray.length; k++) {
    if (subArray[k] > max) {
        max = subArray[k];
        ix = k;
    }
}
```


----------



## jono (25. Nov 2019)

Ich glaube das Problem war gerade schonmal dran, 
die Ausgabe ist jetzt korrekt jedoch gibt er jetzt drei mal die 0 am Ende aus ,anstatt einfach von den 9 Elementen 
6 auszugeben.


----------



## mihe7 (25. Nov 2019)

S. #206, das a von @Snaer ist das eindim bei Dir.


----------



## Snaer (25. Nov 2019)

An sich klappt es nun vielen Dank die Ausgaben sind aufjedenfall die richtigen, nur bei der Abgabe bekomme ich noch Fehlermeldungen. Da muss ich mich dann wohl ran setzen


----------



## jono (25. Nov 2019)

Snaer , bei mir dasselbe...


----------



## Snaer (25. Nov 2019)

jono hat gesagt.:


> Snaer , bei mir dasselbe...


Sind wohl im selben Kurs was ?


----------



## jono (25. Nov 2019)

Sehr wahrscheinlich


----------



## jono (25. Nov 2019)

Was denkst du denn woran es jetzt liegt ?


----------



## jono (26. Nov 2019)

```
import java.util.Arrays;

public class Functionality {
 public static void main(String[] args) {
 
 System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
 
 }
 
 public static int[] flatternAndSortWithoutBiggest(int[][] array) {
 
  if (array == null || array.length == 0)
        throw new IllegalArgumentException ("Array null oder leer!");
 
     int[] eindim = new int[9];
        int[][] zweidim = {
                new int[] {1,2,322},  
                new int[] {4,567,6},
                new int[] {7,87,9}};
     
        int n =0;
                int ignoreCountPerArray=1;
                for (int i = 0; i < zweidim.length; i++) {
                      n += zweidim
                [i].length -ignoreCountPerArray;
                }
                eindim = new int [n];
   
        int count = 0;
         for (int i = 0; i < zweidim.length; i++) {
             for (int j = 0; j < zweidim[i].length - 1; j++) {
                 eindim[count] = zweidim[i][j];
                 count++;
             }
         }
         
         
                 
                 
                for (int i = 0; i < zweidim.length; i++) {
                  int[] subArray = zweidim[i];
                  if (subArray.length > 0) {
                     
                      int ix = 0;
                      int max = subArray[ix];
                      for (int k = ix + 1 ; k < subArray.length; k++) {
                          if (subArray[k] > max) {
                              max = subArray[k];
                              ix = k;
                          }
                      }
                     
                      int last = subArray.length - 1;
                      int tmp = subArray[ix];
                      subArray[ix] = subArray[last];
                      subArray[last] = tmp;
                   
                     
                     
                  }
                }
        boolean swapped;
               
            do {
            swapped = false;
            for(int i = 1; i<eindim.length;i++) {
            if(eindim[i]>eindim[i-1]) {
            int swap = eindim[i-1];
            eindim[i-1] = eindim[i];
            eindim[i] = swap;
            swapped = true;
                           }
           
                  }
           
           
              }while(swapped);
   
           
           
            return eindim;
     
 }    
           
         
}
```

Warum funktioniert es bei der Zahlenkombination im zweidim nicht ?


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> Warum funktioniert es bei der Zahlenkombination im zweidim nicht ?


Bei der Formatierung würde ich auch nicht funktionieren...


----------



## jono (26. Nov 2019)

Meinst du weil keine einzelnen Methoden vorhanden sind ?


----------



## mihe7 (26. Nov 2019)

Nein, ich meine, weil das keine Sau lesen kann  

Schau Dir mal an, was Du der Reihe nach machst (in groben Blöcken) und überleg Dir, ob das so stimmen kann...


----------



## jono (26. Nov 2019)

Okay, ich schaue mal , aber du hast den Fehler entdeckt ?


----------



## mihe7 (26. Nov 2019)

Natürlich, sonst würde ich nicht ohne Einschränkungen schreiben, dass Du Dir den Ablauf anschauen sollst


----------



## jono (26. Nov 2019)

```
import java.util.Arrays;


public class Functionality {

	public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(new int[][] {{1,2,3},{4,5,6},{7,8,9}})));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null|| array.length == 0) {
	        throw new IllegalArgumentException ("Array null oder leer!");}
		        
		
		   int[] eindim = new int[9]; 
	       int[][] zweidim = { 
	               new int[] {1,11,3,2},  
	               new int[] {5,-4,6,2,4,2}, 
	               new int[] {8,9,7}}; 
	     
	       
	       int n =0;
 	        int ignoreCountPerArray=1;
 	        for (int i = 0; i < zweidim.length; i++) {
 	              n += zweidim
 	       	[i].length -ignoreCountPerArray;
 	        }
 	        eindim = new int [n];
       	
 	       
            for (int i = 0; i < zweidim.length; i++) {
         	    int[] subArray = zweidim[i];
         	    if (subArray.length > 0) {
         	        
         	        int ix = 0;
         	        int max = subArray[ix];
         	        for (int k = ix + 1 ; k < subArray.length; k++) {
         	            if (subArray[k] > max) {
         	                max = subArray[k];
         	                ix = k;
         	            }
         	        }

         	        
         	        int last = subArray.length - 1;
         	        int tmp = subArray[ix];
         	        subArray[ix] = subArray[last];
         	        subArray[last] = tmp;
         	      
         	    
         	        
         	    }
            }
          
	       int count = 0;
	        for (int i = 0; i < zweidim.length; i++) {
	            for (int j = 0; j < zweidim[i].length -1; j++) {
	                eindim[count] = zweidim[i][j];
	                count++;
	            }
	        }
	   
	        
	        	        
	   
	                
	       boolean swapped;
	               
	           do {
	           swapped = false;
	           for(int i = 1; i<eindim.length;i++) {
	           if(eindim[i]>eindim[i-1]) {
	           int swap = eindim[i-1];
	           eindim[i-1] = eindim[i];
	           eindim[i] = swap;
	           swapped = true;
	                          }
	           
	                 }
	           
	           
	             }while(swapped);
	  
	           return eindim;
    	 
	}   
           
         
}
```

Das Problem habe ich behoben, jedoch werden bei der Abgabe noch 2 Fehlermeldungen angezeigt , warum ? Der Nulltest schlägt fehl und der testMultipleElementsArray.


----------



## jono (26. Nov 2019)

Hier ein screen


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> jedoch werden bei der Abgabe noch 2 Fehlermeldungen angezeigt , warum ?


Naja, Du verwendest in flatternAndSortWithoutBiggest nicht das übergebene, sondern ein fixes Array.


----------



## jono (26. Nov 2019)

Welches meinst du übergeben ?


----------



## jono (26. Nov 2019)

Was muss ich denn jetzt genau ändern? also weiß schon was du meinst mit dem fixen Array aber nicht wie ich das jetzt so wie gewünscht ändern kann


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> Welches meinst du übergeben ?


Ernsthaft? 

`int[] flatternAndSortWithoutBiggest(int[][] array)` deklariert eine "Funktion" (Methode) flatternAndSortWithoutBiggest, die als Parameter ein zweidimensionales int-Array erhält, auf das innerhalb der Methode über den Namen array zugegriffen werden kann.

In main übergibst Du ein Array an die Methode, das nimmst Du in der Methode aber nicht her, sondern definierst dort fix ein neues, zweidimensionales Array mit dem Namen zweidim.


----------



## jono (26. Nov 2019)

Ja ich weiß war etwas zu eilig geantwortet ich weiß schon was du damit meinst, die frage hätte lauten können wie ich das übergebene in der flatternAndSortWithoutBiggest-Methode jetzt auch anwende ?


----------



## jono (26. Nov 2019)

Habe das noch nie gemacht deshalb frage ich mal


----------



## jono (26. Nov 2019)

Also wie nehme ich das jetzt in der Methode her , klingt lächerlich, aber weiß es nun mal nicht


----------



## mihe7 (26. Nov 2019)

Allmählich gehen mir die Ideen aus, wie ich das noch erklären soll.


```
public void zeige(int x) { // Parameter x
    System.out.println(x); // wird hier verwendet
}
```

Aufruf:

```
zeige(5); // ruft Methode mit dem Argument 5 für Parameter x auf
```

Ergebnis ist die Anzeige von

```
5
```
auf der Konsole.

Noch ein Hinweis: es spielt dabei keine Rolle, ob der Parameter x, y, z, schlagMichTot oder sonstWie genannt wird:

```
public void zeige(int klimbim) {
    System.out.println(klimbim);
}
```
ist völlig analog zur oben definierten zeige-Methode.


----------



## jono (26. Nov 2019)

Echt nicht falsch verstehen, regt dich bestimmt auf, aber warum abstrahierst du das so? Ich weiß nicht wie ich das zweidim umbennen soll. Wäre echt dankbar wenn du mir das einfach gerade mal so sagen kannst , dann weiß ich es auch für die Zukunft.
Es ist ja alles gut, ich hatte in den vorherigen Seiten nur nichts dazu gefunden.
Bitte wende das mal auf mein Fall an bzw gebe genau an was zu machen ist.


----------



## jono (26. Nov 2019)

Wäre einfach viel hilfreicher wenn du das auf mein Beispiel anwendest mit int x und syso(x) bringt mich nicht weiter ist einfach nicht transparent genug meiner Auffassung nach, um das bei mir anzuwenden.


----------



## jono (26. Nov 2019)

In dem Fall müsstest du es mir glaube ich wirklich mal ausnahmsweise vorsagen


----------



## jono (26. Nov 2019)

```
public static void main(String[] args) {
		
	System.out.println(Arrays.toString(flatternAndSortWithoutBiggest(array)));
	
	}
	
	public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		
		if (array == null|| array.length == 0) {
			throw new IllegalArgumentException ("Array null oder leer!");}
		        
		
		   int[] eindim = new int[9]; 
	            array = { 
	               new int[] {1,2,3},  
	               new int[] {4,5,6}, 
	               new int[] {7,8,9}};
```

So verstehe ich das, aber so ist es nicht ausführbar


----------



## jono (26. Nov 2019)

Eigentlich ne banale Sache ist mir auch bewusst


----------



## kneitzel (26. Nov 2019)

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
==> Hier hast Du array - damit sollst Du arbeiten!
           int[][] zweidim = {
==> Hier hast Du ein neues Array erstellt mit dem Du aber arbeitest.
```

Also Du willst für mich einkaufen gehen. Du bekommst eine Einkaufsliste ("array") und prüfst diese: Ist diese auch nicht leer?

Dann ignorierst diese, erstellst Dir einfach eine eigene Einkaufsliste und gehst die dann einkaufen und wunderst Dich, dass ich unzufrieden bin, weil du mir nicht gekauft hast, was ich auf meine Einkaufsliste geschrieben habe ...

Mit der letzten Änderung:
Jetzt machst Du keine neue eigene Einkaufliste mehr - sondern du überschreibst meine Einkaufsliste.

Tipp: Mach gar keine neue Einkaufliste! Die Methode bekommt das zweidimensionale Array, also hast Du da kein eigenes mehr zu erstellen!


----------



## jono (26. Nov 2019)

Okay, vielen Dank, habe jetzt die 2. Fehlermeldung vom vorherigen Screen behoben. Jetzt besteht noch die 1.


----------



## jono (26. Nov 2019)

1) testNullElementArray(PublicTests)
java.lang.NullPointerException
	at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
	at PublicTests.testNullElementArray(PublicTests.java:33)


----------



## jono (26. Nov 2019)

War echt ein gutes Beispiel


----------



## jono (26. Nov 2019)

```
if (array == null|| array.length == 0) {
			throw new IllegalArgumentException ("Array null oder leer!");}
```

Das habe ich ja in meinem Code.
Und das soll erfüllt sein laut Aufgabenstellung: Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden.


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> 1) testNullElementArray(PublicTests)
> java.lang.NullPointerException
> at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)


Was steht denn in Functionality.java, Zeile 25?


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> Und das soll erfüllt sein laut Aufgabenstellung: Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden.


Dann solltest Du das auch tun und keine Exception werfen


----------



## jono (26. Nov 2019)

Das ist die gesamte Fehlermeldung

```
PublicTests.java: Test failed ✘ 
JUnit version 4.12
.E.
Time: 0.006
There was 1 failure:
1) testNullElementArray(PublicTests)
java.lang.NullPointerException
	at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
	at PublicTests.testNullElementArray(PublicTests.java:33)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(java.base@9-internal/Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(java.base@9-internal/NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(java.base@9-internal/DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(java.base@9-internal/Method.java:531)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runners.Suite.runChild(Suite.java:128)
	at org.junit.runners.Suite.runChild(Suite.java:27)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
	at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
	at org.junit.runner.JUnitCore.main(JUnitCore.java:36)

FAILURES!!!
Tests run: 2,  Failures: 1
```


----------



## jono (26. Nov 2019)

In der Zeile 25 ist nur ein "}"


----------



## jono (26. Nov 2019)

Was kommt dann anstatt der "throw new IllegalArgumentException ("Array null oder leer!");" dahin?


----------



## kneitzel (26. Nov 2019)

jono hat gesagt.:


> Was kommt dann anstatt der "throw new IllegalArgumentException ("Array null oder leer!");" dahin?


Ein Array der Länge 0 soll zurück gegeben werden.

Und ich würde eher vermuten, dass die NPE in der Zeile mit
`n += zweidim[i].length -ignoreCountPerArray;`
gekommen ist, denn die Aufgabe testet wohl, ob null innerhalb des zweidimensionalen Arrays ordentlich behandelt wird. Auf jeden Fall kann es nicht die Zeile mit } gewesen sein - evtl. hast Du nach dem Test noch etwas verändert ...


----------



## jono (26. Nov 2019)

Ja, genau das war die Zeile , hast Recht. 
Wie setze ich das dann genau um , return 0 ? 
So wahrscheinlich nicht  Aber was kommt nach dem return?


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> Wie setze ich das dann genau um , return 0 ?


Wie erzeugst Du denn ein eindimensionales Array?


----------



## jono (26. Nov 2019)

Mit return eindim ?


----------



## mihe7 (26. Nov 2019)

Nein, eindim ist ja nur eine Variable für ein konkretes eindimensionales Array. Die Frage ist: wie erzeugst Du ganz allgemein ein Array?


----------



## jono (26. Nov 2019)

int[] array = new int


----------



## firefighter56112 (26. Nov 2019)

Hallo zusammen,

vielen Dank für die vielen hilfreichen Tipps bezüglich dieser Aufgabe, diese haben mir sehr bei der Bearbeitung geholfen! 
Ich bin leider auch an dem Punkt angekommen, dass alles soweit funktioniert, nur bekomme ich ebenfalls beim testen eine NPE. Der Fehler tritt auf in Zeile 27 mit dem Aufruf der bubbleSort (bubbleSort(unsorted_)). Der Fehler tritt ebenfalls auf, wenn ich insertionSort anwende.
Daher vermute ich, dass mein Fehler in den Sortiermethoden liegt, leider stehe ich aber komplett auf dem Schlauch, worin der Fehler liegt. Bin für jede Hilfe dankbar!





		Java:In die Zwischenablage kopieren


import java.util.Arrays;

public class Functionality {

    public static void main(String[] args) {
            
        int [][] unsorted =  new int [][] { {1,2,3} , {4,5,6} , {7,8,9} };
        
        int [] ergebnis = flatternAndSortWithoutBiggest(unsorted);
        
        System.out.println(Arrays.toString(ergebnis));
        
    }

    public static int[] flatternAndSortWithoutBiggest(int[][] unsorted) {


        int[] rueckgabe;
        int[] leer = new int[0];
            
        if (unsorted.length == 0 || unsorted == null) {    
            return leer;
        } else {        
         
            
        for (int i = 0; i < unsorted.length; i++) {            
                        bubbleSort(unsorted[i]);
        }
                        
        int counter = 0;
                
        for (int i = 0; i < unsorted.length; i++) {
                    counter = counter + unsorted[i].length -1;    
        }
            
        rueckgabe = new int[counter];
                
        int temp = 0;
                
        for (int i = 0; i < unsorted.length; i++) {
            for(int j = 1; j < unsorted[i].length; j++) {
                rueckgabe[temp] = unsorted[i][j];
                temp++;
            }
        }
                
        insertionSort(rueckgabe);
                
        return rueckgabe;
                
        }
        
    }
            
        
        public static void bubbleSort(int[] array) {    
            boolean swapped;
            do {
                swapped = false;
                for (int i = 1; i < array.length; i++)
                    if (array[i - 1] < array[i]) {
                        int swap = array[i];
                        array[i] = array[i - 1];
                        array[i - 1] = swap;
                        swapped = true;
                    }
            
         } while (swapped);

        }
        
        
        public static void insertionSort(int[] array) {
            for (int i = 1; i < array.length; i++) {
                int x = array[i];
                int j = i;
                while (j > 0 && array[j-1] < x) {
                    array[j] = array[j-1];
                    j--;
                }
                array[j] = x;
            }
        }
            
}

_


----------



## jono (26. Nov 2019)

new int in eckigen klammern i wird da irgendwie nicht angezeigt


----------



## mihe7 (26. Nov 2019)

jono hat gesagt.:


> nt[] array = new int


Fast, erzeugt wird ein Array (wie auch andere Objekte) mit dem new-Operator. Für ein Array folgt der Typ, dann in eckigen Klammern die Größe. Ein int-Array mit Platz für 100 Werte erzeugst Du also mit `new int[100]`.

Dem entsprechend erzeugst Du ein leeres Array... wie?


----------



## mihe7 (26. Nov 2019)

firefighter56112 hat gesagt.:


> Der Fehler tritt auf in Zeile 27 mit dem Aufruf der bubbleSort (bubbleSort(unsorted_))_


Der Fehler tritt vermutlich hier auf: 

```
unsorted.length == 0 || unsorted == null
```
Wenn unsorted == null gilt, dann wirft unsorted.length eine NPE. Also: die beiden Ausdrücke vertauschen.


----------



## jono (26. Nov 2019)

mit new int [0] oder ?


----------



## mihe7 (26. Nov 2019)

Exakt - und das gibst Du zurück mit return, also einfach `return new int[0];`


----------



## jono (26. Nov 2019)

```
if (array == null|| array.length == 0) {
			return new int[0];
```
So?


----------



## jono (26. Nov 2019)

Test schlägt trotzdem fehl...
Ich sende nochmal die Fehlermeldung.


----------



## firefighter56112 (26. Nov 2019)

Danke für die schnelle Antwort, leider hat das vertauschen der Ausdrücke nichts gebracht, die NPE´s treten weiterhin beim Aufruf der Bubblesort auf. Ich hatte im ursprünglichen Post vergessen den zweiten auftretenden Fehler zu erwähnen, sorry. Vielleicht ist das ja die Ursache. Fehlermeldung in Zeile 60 bei:

```
for (int i = 1; i < array.length; i++)
```


----------



## jono (26. Nov 2019)

```
1) testNullElementArray(PublicTests)
java.lang.NullPointerException
	at Functionality.flatternAndSortWithoutBiggest(Functionality.java:25)
	at PublicTests.testNullElementArray(PublicTests.java:33)
```


----------



## jono (26. Nov 2019)

Zeile 25:     n += array


----------



## jono (26. Nov 2019)

if (subArray.length > 0) {-> Z.33


----------



## kneitzel (26. Nov 2019)

Du musst vorher prüfen, ob das Element von array, mit dem Du etwas machen willst, nicht null ist.

Also wenn Du wissen willst, ob Du ein Stift auf dem Tisch liegt, dann misst Du die Länge? Und wenn die Länge positiv ist, dann ist da ein Stift? Wie misst man die Länge eines nicht vorhandenen Stiftes?


----------



## mihe7 (26. Nov 2019)

@firefighter56112 zum selber Testen, ersetze Dein unsorted in main durch z. B. 

```
int [][] unsorted = new int[][]{null, {1,2,3}, null};
```


----------



## jono (26. Nov 2019)

Indem man schaut ob die Länge 0 ist, wenn die Länge 0 ist, dann ist auch kein Stift vorhanden?


----------



## firefighter56112 (26. Nov 2019)

Sobald ich null in unsorted einsetze, bekomme ich bei der Programmausführung die identischen Fehler wie beim Testen. Sorry, wenn die Frage dumm wirkt, aber wie hilft mir das bei der Fehlerfindung weiter?


----------



## jono (26. Nov 2019)

Ich weiß nicht weiter  Für mich ist es logisch zu sagen, wenn:
Stift == null ist oder ==0 , dann ist auch keiner vorhanden, das ist 
ja nichts anders als was die if Bedingung sagt. Mehr kann ich mir 
dazu echt nicht ausmalen


----------



## mihe7 (26. Nov 2019)

firefighter56112 hat gesagt.:


> Sorry, wenn die Frage dumm wirkt, aber wie hilft mir das bei der Fehlerfindung weiter?


Du kannst den Fehler lokal reproduzieren. Das hilft ungemein.

Und dann nochmal der Aufgabentext: "Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden."

Das übergeben `array` ist ein Array von Arrays. Bislang habt ihr nur überprüft, ob `array` null oder leer ist, aber noch nicht ob die darin enthaltenen Arrays null oder leer sind.


----------



## firefighter56112 (26. Nov 2019)

Danke, ich glaube ich weiß worauf du hinaus möchtest. Bitte korrigiere mich, wenn ich falsch liege, aber das bedeutet:
-die if abfrage bezüglich null/length=0 muss in eine Schleife gepackt werden, die beide Indizes (z.b. i,j) hochzählt um somit alle arrays des array durchzutesten?


----------



## jono (26. Nov 2019)

public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		for(int i = 0; i<array.length;i++) {
		if (array_ == null|| array.length == 0) {
			return new int[0];

		}
		}_


----------



## jono (26. Nov 2019)

Habe das hier, trotzdem schlägt der der sogen. ExtraTest noch fehl, der aber nicht angezeigt wird sondern erst nach abgabe deadline


----------



## jono (27. Nov 2019)

Was kann der Grund dafür sein ?


----------



## mihe7 (27. Nov 2019)

firefighter56112 hat gesagt.:


> Danke, ich glaube ich weiß worauf du hinaus möchtest. Bitte korrigiere mich, wenn ich falsch liege, aber das bedeutet:
> -die if abfrage bezüglich null/length=0 muss in eine Schleife gepackt werden, die beide Indizes (z.b. i,j) hochzählt um somit alle arrays des array durchzutesten?


Fast: 
1. die Schleife ist natürlich zusätzlich und 
2. Du brauchst nur eine Schleife. Die innere Schleife würde auf einzelne int-Werte zugreifen und das sind weder Arrays noch können sie null werden.


----------



## mihe7 (27. Nov 2019)

jono hat gesagt.:


> public static int[] flatternAndSortWithoutBiggest(int[][] array) {
> for(int i = 0; i<array.length;i++) {
> if (array_ == null|| array.length == 0) {
> return new int[0];
> ...


Kannst Du Deinen Code hier in Code-Tags reinstellen? Sonst gehen die i-Indizes verloren, weil der Editor meint, Du willst etwas kursiv schreiben.


----------



## jono (27. Nov 2019)

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		for(int i = 0; i<array.length;i++) {
		if (array[i] == null || array[i].length == 0) 
			return new int[0];
		}
```


----------



## jono (27. Nov 2019)

```
Erstellen Sie die Klasse Functionality.java und bearbeiten Sie die folgende Aufgabe:

Implementieren Sie eine statische-public-Methode mit dem Namen "flatternAndSortWithoutBiggest", welche ein zweidimensionales Integer-Array erhält und ein eindimensionales Integer-Array zurückgibt.

Die Methode soll die Werte aus den einzelnen Arrays nehmen und in ein eindimensionales Array kopieren. Dabei soll aus jedem einzelnen Array jeweils die größte Zahl weggelassen werden. Das resultierende Array soll mit Bubble-,Selection- oder Insertionsort absteigend sortiert werden.

Achten Sie darauf, dass die einzelnen Arrays unterschiedliche Größen haben können.
Sollte irgendein Array "null" sein oder leer sein, dann soll ein leeres Array der Länge 0 ( {} ) zurückgegeben werden.

Bsp.: flatternAndSortWithoutBiggest(new int[][]{{1,11,3,2},{5,-4,6,2,4,2},{8,9,7}}) gibt das Array {8, 7, 5, 4, 3, 2, 2, 2, 1, -4} zurück.
```

Diese Aufgabe soll erfüllt werden, das müsste doch jetzt erledigt sein. 
Der Public Test ist korrekt nur der andere nicht frage mich woran es liegen kann
oder kann es an dem gerade geschickten Code liegen ? Was meinst du?


----------



## mihe7 (27. Nov 2019)

Du hast jetzt den ursprünglichen Test entfernt. Was passiert denn, wenn array selbst null oder leer ist?


----------



## firefighter56112 (27. Nov 2019)

Danke für den Hinweis mit der Schleife, bei mir funktioniert es jetzt. Sobald ein leeres (Teil-) Array eingegeben wird, kommt jetzt [] zurück. Danke an alle für die Hifle!!!


----------



## jono (27. Nov 2019)

Dann wird auch return new int in klammern 0 zurückgegeben?


----------



## jono (27. Nov 2019)

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
		for(int i = 0; i<array.length;i++) {
		if (array[i] == null || array[i].length == 0) 
			return new int[0];
		}
		   if(array == null|| array.length == 0){
			   return new int[0];
		   }
```


----------



## jono (27. Nov 2019)

So?


----------



## mihe7 (27. Nov 2019)

Sag mal, womit formatierst Du Deinen Code?!? Das ist ja schrecklich.

Jetzt überleg mal, was an der Stelle passiert, wenn array == null gilt:

```
for(int i = 0; i<array.length;i++) {
```


----------



## jono (27. Nov 2019)

Ganz normal in Eclipse  Oder was meinst du haha


----------



## jono (27. Nov 2019)

dann muss die eckige Klammer ohne Inhalt hinter new int oder ?


----------



## mihe7 (27. Nov 2019)

OK, ich gebs auf:

```
if(array == null|| array.length == 0){
               return new int[0];
           }
```
muss an den Anfang der Methode, erst danach kannst Du mit Deiner Schleife weitermachen.


----------



## jono (27. Nov 2019)

Ne eckige Klammern mit i drin?


----------



## mihe7 (27. Nov 2019)

jono hat gesagt.:


> Ganz normal in Eclipse


Normal?!? Drück mal Strg+Shift+F


----------



## mihe7 (27. Nov 2019)

jono hat gesagt.:


> Ne eckige Klammern mit i drin?


Du sollst einfach die beiden Blöcke umdrehen:

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
        if(array == null|| array.length == 0){
           return new int[0];
        }
        for(int i = 0; i<array.length;i++) {
            if (array[i] == null || array[i].length == 0) 
                return new int[0];
        }
```


----------



## jono (27. Nov 2019)

Okay, jetzt klappt alles , vielen Dank und die Formatierung ist jetzt auch besser


----------



## mihe7 (27. Nov 2019)

firefighter56112 hat gesagt.:


> Danke für den Hinweis mit der Schleife, bei mir funktioniert es jetzt. Sobald ein leeres (Teil-) Array eingegeben wird, kommt jetzt [] zurück. Danke an alle für die Hifle!!!


Freut mich, dass es wenigstens bei einem funktioniert


----------



## mihe7 (27. Nov 2019)

jono hat gesagt.:


> Okay, jetzt klappt alles , vielen Dank und die Formatierung ist jetzt auch besser


Puh, da hat @JustNobody wieder mal recht gehabt: wir brauchen keine 300 Kommentare


----------



## TheP3aceguy (27. Nov 2019)

Morgen kommen dann auch schon die neuen Aufgabenstellungen raus. Lasst den Thread am besten also einfach schonmal offen


----------



## jono (27. Nov 2019)

Ja stimmt, morgen kommt die neue.


----------



## jono (27. Nov 2019)

Die letzte Frage zu dem Vorherigen: Wieso müssen die beiden Blöcke zwangsläufig umgedreht werden ? @mihe7


----------



## jono (27. Nov 2019)

So ist es richtig , aber warum weiß ich halt nicht


----------



## mihe7 (27. Nov 2019)

OK, ich erklär es gleich, dauert ein bisschen, bis das geschrieben ist.


----------



## mihe7 (27. Nov 2019)

Zuerst haben wir es mit verschiedenen Datentypen zu tun, mit denen wir hantieren können. Es gibt sogenannte primitive Datentypen wie int, char, byte, usw. und komplexe Datentypen.

Bei Instanzen eines primitiven Datentyps (int usw.) handelt es sich um einfache Werte. Deklarierst Du eine Variable z. B. vom Typ int, dann repräsentiert diese Variable eben den betreffenden Wert. 

Bei Instanzen komplexer Datentypen speichert die Variable nicht die Instanz (z. B. das String-Objekt) selbst, sondern nur dessen Adresse im Speicher. Die Variable ist also nur eine Referenz auf das jeweilige Objekt. Daher werden die in Java vorhandenen komplexen Datentypen auch als Referenztypen bezeichnet.

Im Code sieht man den Unterschied meist am new-Operator, d. h. wenn ein new-Operator verwendet wird, handelt es sich um einen Referenztypen, der Umkehrschluss ist nicht immer möglich (String-Literale sind z. B. Objekte, ohne dass man new verwenden müsste):

```
int x = 5; // primitiver Datentyp, der Wert kann sofort zugewiesen werden
int[] x = new int[5]; // new-Operator -> komplexer Datentyp int-Array.
```

Nun gibt es eine besondere Referenz `null`. Dieses null steht praktisch für "kein Objekt".

Beispiel:

```
String x = null; // x speichert aktuell die null-Referenz, also keine Referenz auf ein Objekt
```

Wenn x == null gilt und Du versuchst, auf eine Methode oder Feld von x zuzugreifen, wirst Du mit einer NullPointerException belohnt.

Bezogen auf Dein Beispiel heißt das: der Parameter array in

```
public static int[] flatternAndSortWithoutBiggest(int[][] array) {
```
ist eine Referenz auf eine Instanz des komplexen Datentyps "Array von int-Arrays" und kann `null` sein, wenn der Aufrufer eine null-Referenz übergibt. Beispiel:

```
flatternAndSortWithoutBiggest(null);
// oder auch folgendes, falls x == null gilt
flatternAndSortWithoutBiggest(x);
```

Wenn Du jetzt in der ersten Zeile

```
for(int i = 0; i<array.length;i++) {
```
auf die Länge des Arrays zugreifst, bekommst Du eben eine NullPointerException, falls zu diesem Zeitpunkt `array == null` gilt. Das ist auch logisch, denn die "Länge von keinem Array" ergibt keinen Sinn.

Daher musst Du vorher prüfen, ob array == null gilt und entsprechend reagieren.


----------



## kneitzel (27. Nov 2019)

Deine Geduld mihe7 ....

Neue Aufgabe => Neuer Thread.

Und nur als kleiner Hinweis ganz am Rande: Ihr könnt das doch alles Testen!

Ihr schreibt eine Methode und diese muss für alle Fälle getestet werden. Also könnt ihr doch in der main Methode alles erweitern:

```
public static void main(String[] args) {
            
        int [][] unsorted =  new int [][] { {1,2,3} , {4,5,6} , {7,8,9} };
        int [] ergebnis = flatternAndSortWithoutBiggest(unsorted);
        System.out.println(Arrays.toString(ergebnis));

        unsorted = null;
        ergebnis = flatternAndSortWithoutBiggest(unsorted);
        System.out.println(Arrays.toString(ergebnis));

        unsorted =  new int [][] { null , {4,5,6} , {7,8,9} };
        ergebnis = flatternAndSortWithoutBiggest(unsorted);
        System.out.println(Arrays.toString(ergebnis));
        
        // Und noch mehr Tests ... Was ist, wenn in einem Teilarray nur 1 Element ist
        // oder ganz viele an einer Stelle....
    }
```

Generell ist es so, dass bei den Tests jeder Befehl durchlaufen werden sollte. Also wenn ihr array == null Testet, dann muss der Fall getestet werden. array.length == 0 fehlt noch - den Test müsste man noch bauen. Das gleiche für ein inneres Array!

Und es sollte doch viel einfacher sein, etwas selbst zu testen, als im Forum zu fragen.


----------



## jono (27. Nov 2019)

Danke @mihe7 und @JustNobody , die Geduld und dass ihr sachlich bleibt ist wirklich motivierend. Und ja es ist eigentlich einfach das selbst zu testen, jedoch war ich mir dessen nicht wirklich bewusst, da ich das noch nicht so gemacht hatte , aber mit deinen Beispielen sollte das jetzt auch möglich sein, wenn nicht bitte ich um Geduld wenn ich im Detail etwas nicht verstanden habe


----------

