Zweidimensionales array kopieren und in eindimensionales überführen

Diskutiere Zweidimensionales array kopieren und in eindimensionales überführen im Java Basics - Anfänger-Themen Bereich.
J

jono

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

jono

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

mrBrown

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"? :D

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

jono

{{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}
 
J

jono

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

mrBrown

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

jono

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?..
 
mihe7

mihe7

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
Code:
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.
 
T

tfausw

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 [[email protected] aus, mit System.out.println(Arrays.toString(neu)); ist eben {3,6} die Ausgabe.

Java:
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}}));
    }
}
 
Zuletzt bearbeitet:
mihe7

mihe7

Code:
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
 
mihe7

mihe7

Mach
Java:
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.
 
T

tfausw

Code:
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
wenn ich den Algorithmus nun richtig verstanden habe, sollte folgendes umgesetzt werden:

Java:
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

mihe7

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

tfausw

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 ;).
 
T

tfausw

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

mihe7

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

tfausw

Dann hätten wir quasi also folgendes:

Java:
int counter = 0;
        for (int a = 0; 0 <= a && a < array.length; a++) {
        counter++;
    }
Nun wäre aber

Java:
int[] neu = new int [array[counter].length];
.
.
.
.
.
nicht das richtige, oder muss ich das dann auch im weiteren Code noch anpassen?
 
J

JustNobody

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

tfausw

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:

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

JustNobody

Java:
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).
 
J

JustNobody

Ich würde theoretisch bei folgendem:

Java:
int[] neu = new int [array[counter].length];
nun ein counter nach dem anderen nehmen .. praktisch ist das wieder so ein Ding :D
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

Code:
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!
 
T

tfausw

Wir hatten ja bei 2 Arrays folgendes:
Java:
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?
 
Zuletzt bearbeitet:
mihe7

mihe7

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:
Java:
// 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?
 
T

tfausw

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:
Java:
// 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?
Danke schon mal :) und nein nicht nachträglich, wenn dann steht bei den Posts ja auch bearbeitet.
 
T

tfausw

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:
Java:
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 :p)

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

mihe7

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

tfausw

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

mihe7

Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:
Java:
public int getMaximum(int[] arr) {
}
 
T

tfausw

Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:
Java:
public int getMaximum(int[] arr) {
}
Java:
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.
 
T

tfausw

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

JustNobody

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

Was ist denn der Wertebereich von Integer?
 
T

tfausw

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
 
J

JustNobody

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

mihe7

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

mihe7

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

tfausw

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

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:
Java:
    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?
 
T

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:
Java:
    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:

Java:
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 :(
 
Zuletzt bearbeitet:
mihe7

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

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

tfausw

Ja, Code will ich sehen ;)
Vermute, dass meine Initialisierung falsch ist, wüsste aber keine andere.

Java:
    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

mihe7

Wir schreiben aneinander vorbei, es geht darum, die oben, für den eindimensionalen Fall entwickelte Methode getMaximum zu verwenden:
Java:
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?
 
T

tfausw

Wir schreiben aneinander vorbei, es geht darum, die oben, für den eindimensionalen Fall entwickelte Methode getMaximum zu verwenden:
Java:
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.

Java:
        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

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):
Java:
       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:
Java:
       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);
       }
 
T

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:
Java:
max = max*0;
wird eben die 0 gespeichert.
 
mihe7

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).
 
T

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

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

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

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:
Code:
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?
}
 
T

tfausw

Das ist schon mal der grobe Plan, wenn Du das aber genauer formulierst, wirst Du auf Probleme stoßen:
Code:
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?
}
Java:
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

mihe7

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

mihe7

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

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 :D 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

mihe7

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

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?


Code:
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

mihe7

Geh doch mal Deinen Algorithmus für 3 Arrays Schritt für Schritt durch, dann erhältst Du am Ende etwa folgendes:
Code:
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?
 
J

jono

Java:
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;
   }
 
 }
 
J

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

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:
Code:
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
Java:
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?
Code:
i := 0
So lange i < array.length, wiederhole {
    array[i] := array[i] ohne dessen Maximum
    i++
}
In Code:
Java:
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.
 
T

tfausw

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

tfausw

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

Code:
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

mihe7

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

jono

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

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
 
mihe7

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:
Java:
// 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;
}
 
J

jono

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

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:

IndexInputOutput
05223
12890
22194
35292
42149-------

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

tfausw

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

Java:
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

mihe7

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

mihe7

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

IndexInputOutput
0100100
155
211
310 12
412

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

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

jono

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

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

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

Snaer

Zur Bestimmung des Maximums habe ich nun folgenden Code verwendet :
Code:
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
Code:
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?
 
J

JustNobody

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

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?
 
Thema: 

Zweidimensionales array kopieren und in eindimensionales überführen

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben