2D Array, Symmetrische Matrix

[Honky]

Erzeugen Sie ein nxn
Array vom Typ boolean und befüllen Sie es mit zufälligen Werten. Beachten Sie
dabei aber folgende Einschränkungen:
• Die durch das Array dargestellte quadratische Matrix soll symmetrisch sein.
• Die Werte auf der Hauptdiagonalen sollen immer false sein.
• 3 <= n <= 9 Geben Sie den Inhalt des Arrays in folgendem Format am Bildschirm aus (im Beispiel mit n=5):


Meine Frage:
Versteht irgendjmd. die Aufgabe ?

Ich hab den Anfang mal gemacht, aber ich versteh den letzten Punkt der Aufgabe nicht.
quadratische Matrix erstellen no prob. Befüllen auch no prob.

Das mit der Symmetrie hab ich so gelöst, das schon beim Erstellen immer auf Symmetrie geachtet wird, sonst wird das Array einfach wieder überschrieben, solange bis Symmetrie vorhanden ist. (Bedingung für Symmetrie: matrix[a] = matrix[a] )

So ich weiß nun nicht wie ich diese Bedingung in die DoWhile schleife quetsche, dafür bräuchte ich ja zwei for schleifen. Und will nicht alle möglichen Kombinationen abprüfen.

public class Symmetrie {
    public static void main(String[] args) {
        int n = 5;
        boolean[][] matrix = new boolean[n][n];     //nxn Matrix

        // Matrix befüllen
        do {
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length; j++) {
                    matrix[i][j] = Math.random() < 0.5;                 //Zufälliger boolean Wert
                    System.out.print(matrix[i][j] + " ");
                }
                System.out.println();
            }
        }while(matrix[0][1] != matrix[1][0] == true && matrix[0][2] != matrix[2][0] == true &&matrix[0][3] != matrix[3][0] == true && matrix[0][4] != matrix[4][0] == true);
    }
}

 

[httpdigest]

Kleiner Tipp: Du weißt doch, dass die Matrix symmetrisch sein soll. In dem Fall brauchst du ja gar nicht alle nxn Felder mit zufälligen Werten solange zu befüllen bis sie zufällig symmetrisch sind... was man daraus jetzt aber folgen kann, darauf musst du selber kommen.

 

[Honky]

Ja ich könnte sie einfach perhand befüllen und Symmetrisch machen, will aber lieber eine allgemeine Lösung, weil dann kann ich das auch noch für andere Aufgaben verwenden.

 

[httpdigest]

Ja ich könnte sie einfach perhand befüllen und Symmetrisch machen[...]

Per Hand befüllen? Was meinst du damit? Du sollst schon einen allgemeinen Algorithmus entwickeln, der dir (in angemessen schneller Zeit) eine symmetrische nxn Matrix mit zufälligen Werten generieren kann. Und weiterer kleiner Tipp: Du kannst den Algorithmus so effizient gestalten, dass du sogar 1000x1000 Matrizen in wenigen Millisekunden generieren kannst.

 

[MoxxiManagarm]

Ein boolean ist default false. d.h. beim Intialisieren ist die Hauptdiagonale bereits richtig.

Im Fall 5x5 brauchst du dann noch (und die spiegelverkehrten)
0/1 0/2 0/3 0/4
1/2 1/3 1/4
2/3 2/4
3/4

also brauchst du nur soeine Schachtelung zum Befüllen:

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

Die Ausgabe würde ich hinterher machen und nicht während des Befüllens

 

[httpdigest]

also brauchst du nur soeine Schachtelung zum Befüllen:

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

Auch diesen Algorithmus kann man noch optimieren.

boolean[] matrix = new boolean[n * n];
Random rnd = new Random();
for (int r = 0; r < n; r++) {
    for (int c = 0; c < r; c++) {
        matrix[n * r + c] = matrix[n * c + r] = rnd.nextBoolean();
    }
}

 

[MoxxiManagarm]

Mag ja sein, dass diese Variante noch etwas effizienter ist, aber die Aufgabe sieht aus meiner Sicht klar ein 2D-Array vor und vermutlich ist die 2D Variante für einen Anfänger auch verständlicher.

randomBoolean() war bei mir übrigens nur ein Platzhalter. Random.nextBoolean() hätte auch ich gewählt - gute Wahl ;-)

 

[MoxxiManagarm]

Also ich kann auf jeden Fall bestätigen, dass die 1-dimensionale Variante schneller ist.
bei n=20000 liefen die beiden Varianten bei mir:
2D: 4366ms
1D: 4056ms

Im Vergleich dazu kommt die 1D-Variante beim Index schneller an seine Grenzen. Zwar erst bei n=46341 aber hey x)

 

[Honky]

Warum geht das bei mir nicht, selbst wenn ich

for (int i = 0; i < matrix.length - 1; i++) {
    for (int j = i+1; j < matrix[i].length; j++) {
        matrix[i][j] = matrix[j][i] = Math.random < 0.5;
    }
}

verwende, kommt irgendeine unsymmetrische Matrix raus. Wenn sie symmetrisch ist, sollte die Hauptdiagonale doch immer stimmen.

 

[MoxxiManagarm]

An dem Code ist nichts verkehrt. Wie sieht deine Ausgabe aus.

 

[Honky]

public static void main(String[] args) {
    int n = 5;
    boolean[][] matrix = new boolean[n][n];     //nxn Matrix

    // Matrix befüllen

        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = matrix[j][i] = Math.random() < 0.5;                 //Zufälliger boolean Wert
                if(matrix[i][j] == true)
                    System.out.print("* ");                              //True wird durch das Sternchen ersetzt
                else{System.out.print(" ");}                        //False durch ein Leerzeichen
            }
            System.out.println();
        }

}

 

[MoxxiManagarm]

Deine Schleifen durchlaufen das komplette Array vergleiche sie nochmal mit meinen. Nochmal der dringende Hinweis: mach die Ausgabe nach dem Befüllen nicht währenddessen

 

[Honky]

Danke, ich denke ich habs nun.

public static void main(String[] args) {
    int n = 5;
    boolean[][] matrix = new boolean[n][n];     //nxn Matrix

    // Matrix befüllen

    for (int i = 0; i < matrix.length; i++) {
        for (int j = i; j < matrix[i].length; j++) {
            if(i==j)
                matrix[i][j]=false;
            else
            matrix[i][j] = matrix[j][i] = Math.random() < 0.5;                 //Zufälliger boolean Wert
                                  //False durch ein Leerzeichen
        }


    }

    for(int i =0; i<matrix.length; i++){
        for (int j = 0; j < matrix[i].length; j++) {
            System.out.print(matrix[i][j] + ",");
        }
        System.out.println();
    }

}