Operatoren Parameter nicht auf null geprüft?

[PeterMller]

Hallo liebe Community,

ich habe ein Problem und ich hoffe ihr könnt mir helfen.
Die Aufgabe besteht daraus, dass ich eine übergebene Matrix transponieren und diese auf verschiedene Bedingungen prüfen soll. Ich soll feststellen, ob es eine "Rechteckige" Matrix d.h. alle Zeilen sind gleich lang. Dann soll ich den Parameter noch auf null prüfen, was ich meiner Meinung getan habe. Ich muss die Quell-Dateien auf ein online-Tool hochladen, welches den Code prüft.

Der gibt mir lediglich den Fehler aus, dass ich es nicht auf "null" geprüft haben soll. Meiner Meinung habe ich das Array an sich geprüft und auch die einzelnen Stellen des Arrays, also Array in einer Schleife.

public static int[][] TransposedMatrix(int[][] matrix) 
    {
        if(matrix == null)
        {
            return null;
        }
        else
        {
           
            int[][] trans = new int[matrix[0].length][matrix.length];
       
            for(int i = 0; i < matrix[0].length; i++)
            {
                if(matrix[i] == null || trans[i] == null)
                {
                    return null;
                }
                else
                {
                    if(trans[0].length == trans[i].length)
                    {
                        for(int j = 0; j < m.length; j++)
                        {
                            trans[i][j] = m[j][i];
                       
                            //System.out.print(trans[i][j] + " ");
                        }
                        //System.out.println("");
                    }
                    else
                    {
                        return null;
                    }
                }
            }
        return trans;
        }
    }

Vielen Dank für eure Hilfe
Peter

 

[Thallius]

Vielleicht sollst du auch noch testen ob die Länge der Matrix 0 ist?

Denn in dem Fall würde dein matrix[0].length ziemlich knallen.

Nur so als Idee.

Gruß

Claus

 

[mrBrown]

Was soll denn bei null als Argument passieren?

 

[PeterMller]

Was soll denn bei null als Argument passieren?

Es soll null zurückgegeben und somit die Methode beendet werden.

 

[InfectedBytes]

int[][] trans = new int[matrix[0].length][matrix.length];

Du musst vorher prüfen ob matrix[0] == null ist

 

[PeterMller]

Ok, habe die Lösungsversuche mal implementiert. Nur habe ich den Fehler mit null leider immer noch.

 

[mrBrown]

Rücksprache mit dem Betreuer halten (und den für die Fehlermeldung und's null-Zurückgeben schelten)

 

[VfL_Freak]

Moin,

another idea

for( int j = 0; j < m.length; j++ )
{
trans[j] = m[j];
// ...

was genau ist das 'm' (WIE und WO deklariert und initialisiert) ??
Ist das vlt. in der Schleifensignatur null ???

Gruß Klaus

 

[PeterMller]

Moin,

another idea

was genau ist das 'm' (WIE und WO deklariert und initialisiert) ??
Ist das vlt. in der Schleifensignatur null ???

Gruß Klaus

Hallo Klaus,

das ist natürlich jetzt blöd gelaufen. Ich wollte es eigentlich für euch erkenntlicher machen und hatte den Wert "m" durch "matrix" ersetzt. Habe ich wohl dort übersehen

 

[PeterMller]

Aber ich hätte da noch eine Frage und wollte keinen neuen Thread öffnen dafür. Was wäre, wenn ich ein int Array = new int[][]{{1,2,3},{4,2},{5}}; deklariere. Wenn ich das transponieren will kann man das ja mit nullen auffüllen. Wie kann ich sowas realisieren? Ansonsten schmeißt er mir eine ArrayOutofBoundsExeption an den Kopf

 

[VfL_Freak]

Moin,

int Array = new int[][]{{1,2,3},{4,2},{5}};

Du kannst kein zweidimensionales Array mit drei Werten ('{1,2,3}') füllen !!

Gruß Klaus

 

[PeterMller]

Moin,

Du kannst kein zweidimensionales Array mit drei Werten ('{1,2,3}') füllen !!

Gruß Klaus

So wie ich das sehe, wird dort theoretisch ein 3 x 3 Array deklariert und dann kann ich doch die erste Dimension mit 3 füllen und dann eine der 3 2. Dimensionen mit 1, 2, 3. Oder nicht?
Ich habe mich nicht dazu entschieden, diese Werte zu nehmen. Die werden von dem Überprüfungstool übergeben

 

[VfL_Freak]

Moin,

ja, ist wohl noch zu früh für mich .....

Hier mal ein Link zu Initialisierung von Arrays
https://www.dpunkt.de/java/Die_Sprache_Java/Die_Sprachelemente_von_Java/45.html

Gruß Klaus

 

[mrBrown]

Du musst das größte innere Array suchen, und die transponierte Matrix dann groß genug machen.


3-Dimensional nennt man das nicht, das ist 2-dimensional, da int[][]. Die inneren Arrays sind dabei auch alle unabhängig voneinander

 

[PeterMller]

Das mit dem größen inneren Array habe ich mir auch gedacht. Nur wie bekomme ich den Rest mit 0 befüllt, oder wird dies von Java automatisch gemacht?

 

[mrBrown]

Nein, es gibt in *keine* Stelle, an der eine 0 fehlt.

Die Nullen fehlen erst durch deine Interpretation als Matrix, bisher sind die inneren Arrays halt einfach nur kurz.


Oder meinst du das transponierte? Wenn du es mit new und der Größe erstellst, wird es mit Nullen gefüllt

 

[PeterMller]

Und was ist wenn ich die transponierte mit der normalen Matrix vergleichen will um die Symmetrie zu prüfen?

Hier mal mein Ansatz dazu

public static boolean isSymmetric(int[][] m) //unvollständig
    {
        int laenge = 0;
        boolean sym = false;
      
        if(m == null)
        {
            sym = false;
        }
        else
        {
            int[][] trans = new int[m[0].length][m.length];
            for(int l = 0; l < m.length; l++)
            {
                if(laenge < m[l].length)
                {
                    laenge = m[l].length;
                }
            }
            for(int i = 0; i < m.length; i++)
            {
                if(m[i] == null)
                {
                    sym = false;
                }
                else
                {
                    if(m.length == m[i].length)
                    {
                       
                  
                        for(int k = 0; k < m[0].length; k++)
                        {
                            for(int j = 0; j < m.length; j++)
                            {
                                trans[k][j] = m[j][k];
                              
                                    if(trans[k][j] == m[j][k])
                                    {
                                    sym = true;
                                    }
                                    else
                                    {
                                        sym = false;
                                    }
                            }
                        }
                    }
                    else
                    {
                        sym = false;
                    }
                }
            }
        }
        return sym;
    }