# Hilfe bei nxn Matrix



## nico1996 (24. Sep 2015)

Hallo,

meine Aufgabe ist es eine nxn Matrix mit den Zahlen 1 bis n² auszugeben und die Zahlen sollen zufällige Positionen haben, das habe ich soweit geschafft. Nun der nächste Schritt wäre es, die Matrix so lange auszugeben bis ein magisches Quadrat entstanden ist. Also so lange bis jede Zeile & jede Spalte die gleiche Summe hat, bei einer Matrix mit n = 3 wäre die Summe jeder Zeile & Spalte z.B. 15. Es soll eben erst dann stoppen wenn so ein magisches Quadrat in der Ausgabe steht und da weiß ich einfach nicht weiter.

Hier mein code:

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Quadrat {

    // deklarieren was man benötigt

    static int[][] matrix;
    static int[] summeZeile;
    static int[] summeSpalte;
    static int anzahlZeilen;
    static int anzahlSpalten;

    public static void main(String args[]) {

        // Benutzereingabe des Parameters N - Dimension der Matrix

        int n = 0;

        while (true) {
            try {
                BufferedReader buffy = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("Bitte eine Zahl für n eingeben:");
                n = Integer.parseInt(buffy.readLine());
                if (n < 0) {
                    throw new NumberFormatException("negative Zahl");
                }
                break;
            } catch (IOException e) {
                System.out.println("Eine IO Exception ist aufgetreten");
                e.printStackTrace();
            } catch (NumberFormatException e) {
                System.out.println("Es wurde keine Zahl eingegeben!");
            } catch (NegativeArraySizeException e) {
                System.out.println("Es dürfen nur positive Zahlen eingegeben werden!");
            }
        }

        anzahlZeilen = n;
        anzahlSpalten = n;

        matrix = new int[anzahlZeilen][anzahlSpalten];

        List<Integer> werte = new ArrayList<Integer>();
        int anz = n * n;
        for (int i = 0; i < anz; i++) {

            werte.add(Integer.valueOf(i + 1));

        }
        Collections.shuffle(werte);
        for (int a = 0; a < matrix.length; a++) {
            for (int b = 0; b < matrix[a].length; b++) {
                matrix[a][b] = werte.get(0);
                werte.remove(0);

            }
        }
        calculateReihe();
        calculateSpalte();
        printMyArray(matrix);

    }

    // berechnen der Spaltensumme

    private static void calculateSpalte() {
        summeSpalte = new int[anzahlSpalten];
        for (int Spaltenindex = 0; Spaltenindex < matrix.length; Spaltenindex++) {
            for (int Zeile = 0; Zeile < matrix[Spaltenindex].length; Zeile++) {
                summeSpalte[Zeile] = summeSpalte[Zeile] + matrix[Spaltenindex][Zeile];
            }
        }
    }

    // berechnen der Zeilensumme

    private static void calculateReihe() {
        summeZeile = new int[anzahlZeilen];
        for (int Zeilenindex = 0; Zeilenindex < matrix.length; Zeilenindex++) {
            for (int Spalte = 0; Spalte < matrix[Zeilenindex].length; Spalte++) {
                summeZeile[Zeilenindex] = matrix[Zeilenindex][Spalte] + summeZeile[Zeilenindex];
            }
        }
    }

    private static void printMyArray(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            System.out.println(Arrays.toString(matrix[i]) + "  Summe der Zeile: " + summeZeile[i]);
        }
        for (int i = 0; i < summeSpalte.length; i++) {
            System.out.print("====");
        }
        System.out.print("\nSumme der Spalten 1 bis n: \n[");
        for (int i = 0; i < summeSpalte.length; i++) {
            if (i == summeSpalte.length - 1) {
                System.out.print(summeSpalte[i] + "]");
            } else {
                System.out.print(summeSpalte[i] + ", ");
            }
        }
    }

}
```


----------



## nico1996 (25. Sep 2015)

danke, ich habs mittlerweile


----------



## strußi (25. Sep 2015)

Dann lass uns doch bitte an deinem Erfolg teilhaben.
Viele Grüße


----------



## nico1996 (2. Okt 2015)

```
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;

public class Quadrat {

    // deklarieren was man benötigt

    static int[][] matrix;
    static int[] summeZeile;
    static int[] summeSpalte;
    static int anzahlZeilen;
    static int anzahlSpalten;

    public static void main(String args[]) {

        // Benutzereingabe des Parameters N - Dimension der Matrix

        int n = 0;

        while (true) {
            try {
                BufferedReader buffy = new BufferedReader(new InputStreamReader(System.in));
                System.out.println("Bitte eine Zahl für n eingeben:");
                n = Integer.parseInt(buffy.readLine());
                if (n < 0) {
                    throw new NumberFormatException("negative Zahl");
                }
                break;
            } catch (IOException e) {
                System.out.println("Eine IO Exception ist aufgetreten");
                e.printStackTrace();
            } catch (NumberFormatException e) {
                System.out.println("Es wurde keine Zahl eingegeben!");
            } catch (NegativeArraySizeException e) {
                System.out.println("Es dürfen nur positive Zahlen eingegeben werden!");
            }
        }

        anzahlZeilen = n;
        anzahlSpalten = n;

        matrix = new int[anzahlZeilen][anzahlSpalten];

        // die Zahlen von 1 bis n² in einem linearem 1D Array erzeugen

        int[] alleZahlen = new int[n * n];

        // Position verändert sodass nicht 0-8 sondern 1-9 rauskommt
        for (int i = 0; i < alleZahlen.length; i++) {
            alleZahlen[i] = i + 1;
        }

        System.out.println("Startwerte = " + Arrays.toString(alleZahlen));

        // Methode der Permutation implementiert für alle Permutationen
        ArrayList<int[]> allePermutationen = permutations(alleZahlen);

        // Schleife für jede einzelnde Permutation
        for (int i = 0; i < allePermutationen.size(); i++) {
            int[] aktuellePermutation = allePermutationen.get(i);

            int startIndex = 0;
            int endeIndex = 0;

            // Bei welcher Permutation man gerade ist
            System.out.println("Aktuelle permutation: " + Arrays.toString(aktuellePermutation));
            for (int zeile = 0; zeile < anzahlZeilen; zeile++) {
                startIndex = zeile * anzahlSpalten;
                endeIndex = startIndex + anzahlSpalten;

                // Hier wird unser 1D Array in ein 2 Dimensionales Array
                // umgewandelt indem
                // die ersten 3 Abschnitte in die nächste Zeile kopiert werden
                matrix[zeile] = Arrays.copyOfRange(aktuellePermutation, startIndex, endeIndex);
                System.out.println("Kopiere Ausschnitt Indices " + startIndex + " - " + endeIndex + " = "
                        + Arrays.toString(matrix[zeile]));

            }

            calculateReihe();
            calculateSpalte();
            printMyArray(matrix);

            // Überprüfung ob magisch oder nicht
            if (vergleicheReihen() == false) {
                System.out.println("\n\nKEIN magisches Quadrat\n");
                continue;
            }
            ;
            if (vergleicheSpalten() == false) {
                System.out.println("\n\nKEIN magisches Quadrat\n");
                continue;
            }
            // wenn magisch = true dann wird Ausgabe gestoppt
            if (vergleicheBeides() == true) {
                System.out.println("\n\nMAGISCHES QUADRAT\n");
                break;
            }
        }

    }

    static ArrayList<int[]> permutations(int[] arr) {
        ArrayList<int[]> resultList = new ArrayList<int[]>();

        if (arr.length == 0)
            return resultList;
        if (arr.length == 1) {
            resultList.add(arr);
            return resultList;
        }

        for (int i = 0; i < arr.length; i++) {
            int aktuellesElement = arr[i];
            int[] newArr = new int[arr.length - 1];
            int j;

            for (j = 0; j < i; j++) {
                newArr[j] = arr[j];
            }

            for (j = i + 1; j < arr.length; j++) {
                newArr[j - 1] = arr[j];
            }

            ArrayList<int[]> subPermutations = permutations(newArr);

            for (int[] Element : subPermutations) {
                int[] newPermutation = new int[arr.length];
                newPermutation[0] = aktuellesElement;
                for (j = 0; j < Element.length; j++) {
                    newPermutation[j + 1] = Element[j];
                }

                resultList.add(newPermutation);
            }
        }
        return resultList;
    }

    // berechnen der Spaltensumme

    private static void calculateSpalte() {
        summeSpalte = new int[anzahlSpalten];
        for (int Spaltenindex = 0; Spaltenindex < matrix.length; Spaltenindex++) {
            for (int Zeile = 0; Zeile < matrix[Spaltenindex].length; Zeile++) {
                summeSpalte[Zeile] = summeSpalte[Zeile] + matrix[Spaltenindex][Zeile];
            }
        }
    }
    // berechnen der Zeilensumme

    private static void calculateReihe() {
        summeZeile = new int[anzahlZeilen];
        for (int Zeilenindex = 0; Zeilenindex < matrix.length; Zeilenindex++) {
            for (int Spalte = 0; Spalte < matrix[Zeilenindex].length; Spalte++) {
                summeZeile[Zeilenindex] = matrix[Zeilenindex][Spalte] + summeZeile[Zeilenindex];
            }
        }
    }

    // Ausgabe meiner Matrix
    private static void printMyArray(int[][] matrix) {
        for (int i = 0; i < matrix.length; i++) {
            System.out.println(Arrays.toString(matrix[i]) + "  Summe der Zeile: " + summeZeile[i]);
        }
        for (int i = 0; i < summeSpalte.length; i++) {
            System.out.print("====");
        }
        System.out.print("\nSumme der Spalten 1 bis n: \n[");
        for (int i = 0; i < summeSpalte.length; i++) {
            if (i == summeSpalte.length - 1) {
                System.out.print(summeSpalte[i] + "]");
            } else {
                System.out.print(summeSpalte[i] + ", ");
            }
        }
    }

    private static boolean vergleicheReihen() {
        for (int i = 0; i < summeZeile.length; i++) {
            for (int j = 0; j < summeZeile.length; j++) {
                if (summeZeile[i] != summeZeile[j]) {
                    return false;
                }
            }
        }
        return true;
    }

    private static boolean vergleicheSpalten() {
        for (int i = 0; i < summeSpalte.length; i++) {
            for (int j = 0; j < summeSpalte.length; j++) {
                if (summeSpalte[i] != summeSpalte[j]) {
                    return false;
                }
            }
        }
        return true;
    }

    private static boolean vergleicheBeides() {
        for (int i = 0; i < summeZeile.length; i++) {
            for (int j = 0; j < summeSpalte.length; j++) {
                if (summeZeile[i] != summeSpalte[j]) {
                    return false;
                }
            }
        }
        return true;
    }
}
```


----------



## strußi (3. Okt 2015)

Vielen Dank ;-)


----------

