Zweidimensionales array kopieren und in eindimensionales überführen

K

kneitzel

Gast
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

Aktives Mitglied
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

Top Contributor
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.
 
K

kneitzel

Gast
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

Aktives Mitglied
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.

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;
            }
Zum Verständnis liege ich hiermit zumindest auf dem richtigen Weg die Arrays in eines zu kopieren? Also abgesehen von dem a[count] -max1.
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?
 
K

kneitzel

Gast
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

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

mihe7

Top Contributor
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

Aktives Mitglied
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

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

Top Contributor
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

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

mihe7

Top Contributor
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

Top Contributor
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.
 

mihe7

Top Contributor
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.

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.

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

Top Contributor
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

Top Contributor
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

Top Contributor
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

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

Top Contributor
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.
 

jono

Top Contributor
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

Top Contributor
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.
 

mihe7

Top Contributor
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:
Java:
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:
Code:
[9, 8, 7, 6, 5, 4, 3, 2, 1]
 

jono

Top Contributor
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

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

tfausw

Aktives Mitglied
Ich habe das jetzt alles mal so ein wenig umgedacht.

Java:
        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
Code:
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.
 
Zuletzt bearbeitet:

tfausw

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

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

Snaer

Aktives Mitglied
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.
 

Snaer

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

Aktives Mitglied
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:
Code:
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.
Ich muss mich entschuldigen, vor lauter Seiten habe ich übersehen, dass das Problem bereits in #28 erläutert wurde. :rolleyes:
 
K

kneitzel

Gast
Und das Problem hast du doch auch schon gelöst:
Java:
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

Aktives Mitglied
Und das Problem hast du doch auch schon gelöst:
Java:
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.
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.
 

Snaer

Aktives Mitglied
Mir fällt jedoch keine geschickte Lösung zum tauschen ein mit unbekannten Längen :/
Code:
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?
 
K

kneitzel

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

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

kneitzel

Gast
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!
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Ü Zweidimensionales Array in der ersten Zeile deklarieren Java Basics - Anfänger-Themen 13
S Prüfen ob ein zweidimensionales Array rechteckig ist Java Basics - Anfänger-Themen 4
sserio Iterierung über ein zweidimensionales Array Java Basics - Anfänger-Themen 16
sserio Zweidimensionales Array [][] wird untereinander ausgegeben Java Basics - Anfänger-Themen 14
G zweidimensionales int Array sortieren Java Basics - Anfänger-Themen 57
P Zweidimensionales Array als Tabelle mit befüllten Zahlen Java Basics - Anfänger-Themen 10
Yasemin bahar zweidimensionales Array Java Basics - Anfänger-Themen 5
O zweidimensionales array in eine csv-Datei Java Basics - Anfänger-Themen 1
K Übergabe von Werten (zweidimensionales Array) aus einer Methode an zweidimensionales Array in main() Java Basics - Anfänger-Themen 3
I Java zweidimensionales array befüllen mit for-schleife Java Basics - Anfänger-Themen 2
J zweidimensionales Array Java Basics - Anfänger-Themen 1
S Zweidimensionales Array in ein eindimensionales Array speichern Java Basics - Anfänger-Themen 6
X Java zweidimensionales Array Java Basics - Anfänger-Themen 5
J Zweidimensionales Array in CSV File exportieren Java Basics - Anfänger-Themen 3
U Methoden Zweidimensionales Array mit Arrays.sort sortieren? Java Basics - Anfänger-Themen 22
F Erste Schritte zweidimensionales array Java Basics - Anfänger-Themen 2
J Erste Schritte zweidimensionales Array Muster befüllen. Java Basics - Anfänger-Themen 4
K drei eindimensionale Arrays in ein zweidimensionales Array Java Basics - Anfänger-Themen 10
K Zweidimensionales Array erstellen und zufällig mit 0 und 1 füllen Java Basics - Anfänger-Themen 11
P zweidimensionales Array anlegen und mit DB-Daten füllen Java Basics - Anfänger-Themen 14
W Erste Schritte Zweidimensionales Array - Gerade Zahlen anzeigen lassen Java Basics - Anfänger-Themen 3
L zweidimensionales char array reihenfolge ändern ? Java Basics - Anfänger-Themen 2
C ZweiDimensionales Array erstellen und Spiegeln Java Basics - Anfänger-Themen 1
H zweidimensionales array füllen Java Basics - Anfänger-Themen 6
D Zweidimensionales Array ( Java Basics - Anfänger-Themen 2
D Zweidimensionales Array (Länge) Java Basics - Anfänger-Themen 2
M Zweidimensionales Array aus Textdatei gewinnen Java Basics - Anfänger-Themen 6
M Zweidimensionales Array um 1 addieren Java Basics - Anfänger-Themen 3
B Zweidimensionales Array Elemente jeder Spalte zählen Java Basics - Anfänger-Themen 9
C Methoden Diagonalen am best. Punkt im zweidimensionales array finden Java Basics - Anfänger-Themen 3
S Zweidimensionales Array mit Diagonalen Java Basics - Anfänger-Themen 9
M Zugriffsproblem auf (zweidimensionales) Array in einer ArrayList Java Basics - Anfänger-Themen 15
C Datentypen Zweidimensionales Array mit String und int Java Basics - Anfänger-Themen 3
W Datentypen Zweidimensionales Boolean Array Java Basics - Anfänger-Themen 13
A Zweidimensionales Array Java Basics - Anfänger-Themen 3
M Zweidimensionales Array durchlaufen Java Basics - Anfänger-Themen 4
C zweidimensionales Array sortieren Java Basics - Anfänger-Themen 6
B Zweidimensionales Array durchsuchen und ändern Java Basics - Anfänger-Themen 8
J Zweidimensionales Array durch ToString ausgeben lassen Java Basics - Anfänger-Themen 21
B Zweidimensionales Array mit boolean Werten Java Basics - Anfänger-Themen 3
M Zweidimensionales Array befüllen Java Basics - Anfänger-Themen 4
C Zweidimensionales String Array initialisieren Java Basics - Anfänger-Themen 2
S Zweidimensionales Array mit Schleife summieren Java Basics - Anfänger-Themen 2
N zweidimensionales array größe bestimmen Java Basics - Anfänger-Themen 1
F Datentypen Zweidimensionales Array füllen Java Basics - Anfänger-Themen 6
S zweidimensionales ARRAY Java Basics - Anfänger-Themen 2
S zweidimensionales Array Java Basics - Anfänger-Themen 6
berti99 Zweidimensionales Array befüllen Java Basics - Anfänger-Themen 5
U Zweidimensionales Array mit Eindimensionalem Array Java Basics - Anfänger-Themen 7
J zweidimensionales Array einselen und ausgeben Java Basics - Anfänger-Themen 15
G Zweidimensionales Array - dynamisch Java Basics - Anfänger-Themen 4
M Zweidimensionales Array Java Basics - Anfänger-Themen 3
G zweidimensionales Array vergrößern Java Basics - Anfänger-Themen 3
M Zweidimensionales dynamisches Array füllen Java Basics - Anfänger-Themen 2
J zweidimensionales Array Java Basics - Anfänger-Themen 3
M Zweidimensionales String-Array initialisieren Java Basics - Anfänger-Themen 6
P zweidimensionales Array erstellen Java Basics - Anfänger-Themen 9
D erste spalte eines zweidimensionales Array sortieren ??!! Java Basics - Anfänger-Themen 2
N zweidimensionales 10x10 Feld erstellen Java Basics - Anfänger-Themen 3
D aus 2 arrays ein zweidimensionales formen Java Basics - Anfänger-Themen 9
R dynamisches zweidimensionales Feld erzeugen Java Basics - Anfänger-Themen 8
V Zweidimensionales Ganzzahlfeld Java Basics - Anfänger-Themen 7
T Array verkleinern Java Basics - Anfänger-Themen 2
J Array aus Numberfield Eingaben Java Basics - Anfänger-Themen 7
D Array List mit Objekten sortieren Java Basics - Anfänger-Themen 2
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
Ü Java Array - Buchstaben als Zahlen ausgeben Java Basics - Anfänger-Themen 22
Thomas Uppe 2D Array Reihenfolge vermischen Java Basics - Anfänger-Themen 4
T array auslesen Java Basics - Anfänger-Themen 2
Nitrogames Variablen Variable aus JOptionPane Abfrage in Array einfügen Java Basics - Anfänger-Themen 4
moini Auf Array aus Superklasse zugreifen? Java Basics - Anfänger-Themen 2
J ArrayList in 2D-Array konvertieren. Java Basics - Anfänger-Themen 48
M NullPointerException: Cannot read the array length because "this.Kinder" is null Java Basics - Anfänger-Themen 1
P Wieso kann ich als Index für einen Array einen Char angeben? Java Basics - Anfänger-Themen 3
Finn_lol Fehlermeldung bei Schleife mit Array Java Basics - Anfänger-Themen 4
Proxy Chars vor array übergabe toLowerUpcase Java Basics - Anfänger-Themen 14
iAmFaiinez Primzahlen Tester ohne Array Java Basics - Anfänger-Themen 4
S array 2 dimensional treppe Java Basics - Anfänger-Themen 3
S Array 2x2 Blöcke mit 0 und 1 Java Basics - Anfänger-Themen 10
C Array von Klassen Java Basics - Anfänger-Themen 2
julian0507 2Dim-Array Spaltensummen Java Basics - Anfänger-Themen 1
XWing Doppelte Zahlen im Array Java Basics - Anfänger-Themen 8
melisax Java 2D-Array Tabelle Java Basics - Anfänger-Themen 4
melisax Java Array Wert an bestimmtem Index angeben Java Basics - Anfänger-Themen 14
W Items löschen aus String Array vom Custom Base Adapter Java Basics - Anfänger-Themen 2
Proxy Stack erweitern mit neuem Array falls der alte voll ist!? Java Basics - Anfänger-Themen 5
E Array, nächste Zahl zur 5 ausgeben, wie? Java Basics - Anfänger-Themen 42
J Array.list vergleichen Java Basics - Anfänger-Themen 1
W Java-Code mit Array Java Basics - Anfänger-Themen 14
D Reflections & Generisches Array Java Basics - Anfänger-Themen 4
T Array Java Basics - Anfänger-Themen 2
T Array Java Basics - Anfänger-Themen 15
T Wörteranzahl im Array zählen Java Basics - Anfänger-Themen 9
Ostkreuz Zweidimensionaler Array Index Java Basics - Anfänger-Themen 2
S String Array Buchstaben um einen gewissen Wert verschieben Java Basics - Anfänger-Themen 4
R Images aus einem Array ausgeben Java Basics - Anfänger-Themen 3
R 2d Array individuell machen Java Basics - Anfänger-Themen 4
D 2D Char Array into String Java Basics - Anfänger-Themen 2
J Array Median bestimmen Java Basics - Anfänger-Themen 6
S Array Maximum bestimmen mit for und foreach Java Basics - Anfänger-Themen 7

Ähnliche Java Themen

Neue Themen


Oben