Zweidimensionales array kopieren und in eindimensionales überführen

J

jono

Top Contributor
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.
 
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.
 
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}
 
{{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}
 
Bzw da wir es aufsteigend sortieren sollen noch den Bubble sort verwenden aber das hat ja erstmal nichts mit meiner Frage zu tun
 
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 - >
Zum Vergrößern anklicken....
Und wenn du jetzt 4376546785 Arrays hast, die jeweils 466597657 Werte haben, dir also nicht merken kannst, welche du gestrichen hast?
 
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 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?..
Zum Vergrößern anklicken....
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.
 
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.

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:
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
 
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 😀
 
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.
 
mihe7 hat gesagt.:
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
Zum Vergrößern anklicken....

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)
 
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.
 
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.
 
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?
 
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?
 
JustNobody hat gesagt.:
Nein, das ist nicht korrekt. @mihe7 hat ja schon darauf hingewiesen, dass counter nicht um 1 zu erhöhen ist.
Zum Vergrößern anklicken....
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;
    }
 
tfausw hat gesagt.:
Java: 
int counter = 0;
        for (int a = 0;a < array.length; a++) {
        counter += array[a].length;
    }
Zum Vergrößern anklicken....

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).
 
tfausw hat gesagt.:
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 😀
Zum Vergrößern anklicken....

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!
 
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:
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.
Zum Vergrößern anklicken....
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?
 
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:
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?
Zum Vergrößern anklicken....
Danke schon mal 🙂 und nein nicht nachträglich, wenn dann steht bei den Posts ja auch bearbeitet.
 
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 😛)

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.
 
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.
 
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.
Zum Vergrößern anklicken....
Verstehe.

Hätte auf Anhieb jetzt gesagt, dass ich das dann einfach nach dem Schleifendurchlauf initialisieren lasse, aber das klappt leider nicht.
 
Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:
Java: 
public int getMaximum(int[] arr) {
}
 
mihe7 hat gesagt.:
Schreib mal eine Methode, die in einem eindimensionalen Array das Maximum liefert:
Java: 
public int getMaximum(int[] arr) {
}
Zum Vergrößern anklicken....

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.
 
Wenn nur negative Zahlen in dem Array sind, dann würde was als Maximum ausgegeben?

Was ist denn der Wertebereich von Integer?
 
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
 
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?
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Zweidimensionales Array in ein eindimensionales Array speichern
Antworten: 6
Eindimensionales Array in zweidimensionales Array speichern
Antworten: 5
Übergabe von Werten (zweidimensionales Array) aus einer Methode an zweidimensionales Array in main()
Antworten: 3
2-Dimensionales Array in Eindimensionales Array
Antworten: 1
Array Kopie zwei in eindimensionales feld
Antworten: 4

Zurück
Oben