Zweidimensionales array kopieren und in eindimensionales überführen

[tfausw]

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

 

[mihe7]

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]

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?

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]

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]

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]

Ja, Code will ich sehen 😉

 

[tfausw]

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]

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]

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?

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]

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]

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]

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]

...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]

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]

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]

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]

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?
}

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]

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

 

[mihe7]

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

 

[tfausw]

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.

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]

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

 

[tfausw]

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]

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]

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]

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]

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]

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

 

[mihe7]

Naja, mach mal 🙂

 

[tfausw]

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]

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

 

[jono]

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

 

[jono]

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]

Obwohl sry ist komplett falsch der Ansatz

 

[mihe7]

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]

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

 

[mihe7]

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:

Index	Input	Output
0	5223
1	2890
2	2194
3	5292
4	2149	-------

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]

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]

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]

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]

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

 

[mihe7]

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

Index	Input	Output
0	100	100
1	5	5
2	1	1
3	10	12
4	12

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

 

[jono]

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]

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

 

[mihe7]

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]

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

 

[jono]

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]

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:

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

Hier

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]

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]

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]

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?