Zweidimensionaler Array; n x m - Matrix überprüfuen

L

luluuxs

Aktives Mitglied
Guten Abend,
ich soll eine Matrix n x m abfragen und diese dann auf mindestens doppelte Werte überprüfen und diese dann durch eine "-1" ersetzen...
Das Einlesen und Ausgeben funktioniert soweit, nur probiere ich seit mehreren Stunden meine Matrix auf doppelte Werte zu überprüfen und die Werte durch die -1 zu ersetzen, aber ich komme echt nicht mehr weiter.
Hat zufällig wer einen Tipp oder eine Lösung für mich ?
Ich bin für jede kleine Hilfe dankbar.
LG

Bisher sieht mein Code so aus:

(siehe Nachricht weiter unten)
 
Zuletzt bearbeitet:
Bitte Code in Code-Tags posten (im Editor oben links </> klicken).

Wie würdest Du mit Zettel und Stift vorgehen? Kannst Du den Algorithmus in kleinen Schritten skizzieren?
 
Gute Frage, entweder erst die doppelten Zahlen durchstreichen und dann eine -1 hinschreiben oder alles neu hinschreiben und die doppelten durch -1 ersetzen.

Java: 
public class Matrix {

    public static int[][] readIn(int[][] size, int n, int m) {
        int[][] b = new int[n][m];
        for (int i = 0; i < n; i++) {
            Out.println("Geben Sie Zeile " + i + " ein: ");
            for(int j = 0; j < m; j++) {
                b [i][j] =In.readInt();
            }
        }
        return b;
    }

    public static int[][] compareMatrices(int[][] base, int n, int m) {
        boolean compare = false;
        int[][] crossing = new int[n][m];
        for (int a = 0; a < n; a++) {
            for (int b = 0; b < m; b++) {
                for (int c = a+1; c < n; c++) {
                    for (int d = b+1; d < m; d++) {
                        if (base[a][b] == base[c][d]) {
                            compare = true;
                        } else {
                            compare = false;
                        }
                        if (!compare) {
                            crossing[a][b] = (-1);
                            crossing[c][d] = (-1);
                        } else {
                            crossing[a][b] = base[n][m];
                        }
                    }
                }
            }
        }
        return crossing;
    }

    public static void main(String[] args) {
        Out.println("Bitte geben Sie die gewünschte Zeilenanzahl n der Matrix an: ");
        int n = In.readInt();
        Out.println("Bitte geben Sie die gewünschte Spaltenanzahl m der Matrix an: ");
        int m = In.readInt();
        int[][] size = new int[n][m];
        int[][] base= readIn(size, n, m);
        int[][] output = compareMatrices(base, n , m);
        for (int z = 0; z < n; z++) {
            Out.println();
            for (int y = 0; y < m; y++) {
                Out.print(output[z][y] + " ");
            }
        }
    }
}
 
"Gute Frage, entweder erst die doppelten Zahlen durchstreichen und dann eine -1 hinschreiben oder alles neu hinschreiben und die doppelten durch -1 ersetzen."
hatte bearbeitet D:
Also ich würde im eingelesenen Array jeden Wert mit jedem vergleichen
Mindestens doppelte Werte streichen
Nur einmal verkommene Werte übernehmen und durchgestrichene durch -1 ersetzen
 
Das ist zu ungenau. Du musst etwas finden wie: ich schaue mir die erste Zahl der Matrix in Zelle (0,0) an, dort steht eine Zahl x. Dann ... dann... wenn... dann... wiederhole... usw.🙂
 
Wenn Dir das zu schwer ist, dann machen wir das auf zwei Schritte:

Ich sage Dir eine Zahl y. Formuliere einen Algorithmus, der alle y in der Matrix durch -1 ersetzt.
 
Ich schaue mir die Zelle (0,0) an, vergleiche diese mit allen anderen Zellen der Matrix auf gleiche Werte
Wenn ein Wert gleich ist, wird dieser gestrichen, alle anderen Werte werden in einen neuen Array gespeichert.
Werte die gleich waren werden im neuen Array durch eine -1 ersetzt.
Dies wiederhole ich mit allen Zellen (n, m)
 
Du könntest ja vorher die Matrix kopieren und z. B. sagen: wenn sich Zelle (x,y) in Matrix A von Zelle (x,y) in Matrix B unterscheidet, dann wurde die Zelle in Matrix A gelöscht.
 
Sorry, war ein Gedankenfehler meinersetits (premature optimization is the root of all evil...)

Löschen heißt also einfach auf -1 setzen?
 
So, jeden Wert w in der Matrix durch -1 zu ersetzen bekommst Du hin, oder?

Dann wäre die nächste Aufgabe: jeden Wert w in der Matrix ab einer bestimmten Zelle (x,y) in der Matrix durch -1 zu ersetzen.
 
mihe7 hat gesagt.:
So, jeden Wert w in der Matrix durch -1 zu ersetzen bekommst Du hin, oder?

Dann wäre die nächste Aufgabe: jeden Wert w in der Matrix ab einer bestimmten Zelle (x,y) in der Matrix durch -1 zu ersetzen.
Zum Vergrößern anklicken....
warum "ab" ? Nur für bestimmte
Ich denke, ich weiß wie ich Werte ersetze, aber irgendetwas habe ich in meinem Code ja falsch ._.
 
mihe7 hat gesagt.:
Code: 
0 0 0 0 w 0 0 0
0 0 w 0 0 0 0 w
Alle w durch -1 ab Zelle (0,6) -->
Code: 
0 0  0 0 w 0 0  0
0 0 -1 0 0 0 0 -1
Zum Vergrößern anklicken....
das macht Sinn
Leider ist bei meiner Methode compareMatrices aber ein Fehler dadurch, dass ich c = a+1 und d = b+1 gesetzt habe, aber ich weiß nicht wie ich das ändere, so das es dann funktioniert..
 
Java: 
                        if (base[a][b] == base[c][d]) {
                            compare = true;
                        } else {
                            compare = false;
                        }
                        if (!compare) {
                            crossing[a][b] = (-1);
                            crossing[c][d] = (-1);
                        } else {
                            crossing[a][b] = base[n][m];
                        }
Was soll dieses compare-Zeugs? Erstmal entfernen:
Java: 
                        if (base[a][b] == base[c][d]) {
                            crossing[a][b] = base[n][m];
                        } else {
                            crossing[a][b] = (-1);
                            crossing[c][d] = (-1);
                        }
So, warum base[n][m]?
 
mihe7 hat gesagt.:
Java: 
                        if (base[a][b] == base[c][d]) {
                            compare = true;
                        } else {
                            compare = false;
                        }
                        if (!compare) {
                            crossing[a][b] = (-1);
                            crossing[c][d] = (-1);
                        } else {
                            crossing[a][b] = base[n][m];
                        }
Was soll dieses compare-Zeugs? Erstmal entfernen:
Java: 
                        if (base[a][b] == base[c][d]) {
                            crossing[a][b] = base[n][m];
                        } else {
                            crossing[a][b] = (-1);
                            crossing[c][d] = (-1);
                        }
So, warum base[n][m]?
Zum Vergrößern anklicken....
compare Zeugs hab ich weggemacht, war unnötig ka, was da mein Plan war
ich dachte wenn der wert nicht doppelt ist, wird in dem neuen array einfach der alte wert aus base gespeichert
da muss auf jeden fall base[a] right?
 
[CODE lang="java" title="hatte das jetzt so"]public static int[][] compareMatrices(int[][] base, int n, int m) {
int[][] crossing = new int[n][m];
for (int a = 0; a < n; a++) {
for (int b = 0; b < m; b++) {
for (int c = 0; c < n; c++) {
for (int d = 0; d < m; d++) {
if (base[a] == base[c][d]) {
crossing[a] = (-1);
crossing[c][d] = (-1);
} else {
crossing[a] = base[a];
}
}
}
}
}
return crossing;
}[/CODE]
 
Ne, so geht das nicht.

Java: 
    public static int[][] kill(int[][] matrix) {
        int[][] result = new int[matrix.length][matrix[0].length];

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                result[i][j] = matrix[i][j];
            }
        }

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                for (int p = i; p < matrix.length; p++) {
                    int start = p == i ? j+1 : 0;
                    for (int q = start; q < matrix[0].length; q++) {
                        if (matrix[i][j] == matrix[p][q]) {
                            result[i][j] = -1;
                            result[p][q] = -1;
                        }
                    }
                }
            }
        }

        return result;
    }
 
mihe7 hat gesagt.:
Ne, so geht das nicht.

Java: 
    public static int[][] kill(int[][] matrix) {
        int[][] result = new int[matrix.length][matrix[0].length];

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                result[i][j] = matrix[i][j];
            }
        }

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                for (int p = i; p < matrix.length; p++) {
                    int start = p == i ? j+1 : 0;
                    for (int q = start; q < matrix[0].length; q++) {
                        if (matrix[i][j] == matrix[p][q]) {
                            result[i][j] = -1;
                            result[p][q] = -1;
                        }
                    }
                }
            }
        }

        return result;
    }
Zum Vergrößern anklicken....
danke
 
Musst Du Dir nochmal anschauen, ich hab das nur runtergerotzt und heute ist nicht mein Tag. Das Problem in Deinem Code ist, dass Du im else-Zweig Dir ja immer wieder die Werte überschreibst.
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Zweidimensionaler Array Wetterstation
Antworten: 1
Zweidimensionaler Array mit Setter Methode ändern
Antworten: 4
Zweidimensionaler Array Index
Antworten: 2
Nochmal zweidimensionaler Vector
Antworten: 10
Matrix Matrix Produkt
Antworten: 7

Zurück
Oben