Matrizenmultiplikation

[SRPM]

Hallo ihr Lieben!
Wir sind absolut unerfahrene Informatikerinnen und sitzen jetzt stundenlang an einer Aufgabe zur Multiplikation von Matrizen. Bitte helft uns!
Die Aufgabenstellung sagt, dass wir vom Benutzer die Anzahl von Zeilen und Spalten einlesen lassen sollen, worauf basierend die Matrizen zeilenweise eingelesen werden sollen. Anschließend folgt die Multiplikation.
Unser Ansatz bisher sieht so aus:

Vielen lieben Dank im Vorraus! Eure SRPM

 

[Robat]

Und wo genau liegt jetzt euer Problem?
Kommt ihr bei etwas bestimmten nicht weiter?
Kriegt ihr Fehler?

 

[SRPM]

Wir bekommen eine Fehlermeldung bei "return null" und lesen nichts ein, wissen aber auch nicht was mit dem eingelesenen geschehen sollen würde..

 

[kaporalix]

am besten bitte den QuellCode im ofrum einfügen. so kann man ihn schnell prüfen und vebessern

 

[kaporalix]

damit ihr die Anzahl der Zeilen bzw. Spalten vom User ablesen könnt, soll ihr Scanner benutzen: hier ein beispiel:

import java.util.Scanner;

public class Matrizen {
   
    public static void main(String[] args) {
   
        Scanner input = new Scanner(System.in);
       
        System.out.println("anzahl der Zeilen: ");
        int zeilen = input.nextInt();
       
        System.out.println("Anzahl der Spalten: ");
        int spalten = input.nextInt();
       
        int[][] matrize = new int[zeilen][spalten];
               
        //beispiel der Ausgabe
        for(int i = 0; i < matrize.length; i++){
            for(int j = 0; j < matrize[i].length; j++){
                System.out.print(matrize[i][j]);
            }
            System.out.println();
        }
    }   
}

 

[SRPM]

public class M  {
    public static void main (string [] argv) {
        int [][]matrixmultiplikation;
        int [][]a;
        int [][]b;

        if ( a [0].length != b.length) {
            return null;
        }
        int [][] ergebnis=new int[a.length]        [b[0].length];
        for (int zeile=0; zeile < a.length; zeile++) {
            for (int spalte=0; spalte <b[0].length; spalte++) {
                int zwischensumme=0;
                for (int i=0; i <b.length; i++) {
                     zwischensumme+= a [zeile][i]*b[i][spalte];
                }
                ergebnis [zeile][spalte]=zwischensumme;
         }
     }
     return ergebnis;
    }
}

 

[SRPM]

Scanner hatten wir noch nicht und dürfen es daher nicht benutzen :/ hast du noch einen anderen Vorschlag?

 

[Robat]

Also..

1. return null

Ihr befindet euch in der main-Methode die als Rückgabetyp nichts erwartet, was man am void sehen kann. D.h. return null aufzurufen bringt euch natürlich einen Fehler. Wenn ihr das Programm an der Stelle beenden wollt, empfehle ich euch System.exit(0); zu verwenden.

2. Ihr wisst nicht, was ihr mit dem eingelesenen machen sollt.

Momentan lest ihr ja noch nichts ein. Ihr erstellt 3 Matritzen (wobei die erste mMn. sinnloser Weise erstellt wird) und lasst diese komplett leer. Dann prüft ihr ob die beiden die selbe Länge haben, was quatsch ist da diese def. die selbe länge haben wenn beide leer sind. Ich fang mal ganz von vorne an und sag euch was ich machen würde.

a) Matritzen erstellen

- Fragt den User mit System.out.println(".."); wie viele Spalten und wie viele Reihen die Matrix haben soll
- Speichert die Inputs mit der Scanner Klasse und der Methode scanner.nextLine() und der Methode Integer.parseInt() [Um den Input in ints umzuwandeln] in Variablen
- Erstellt die Arrays mit den entsprechenden Reihen und Spalten
- Mittels einer for-Schleife, lest ihr nun (siehe Punkt 2) die Werte für das 1. Array ein und dann für das 2. Array
- Zusätzlich legt ihr noch eine Matritze für das Ergebnis mit der entsprechenden Länge an
- [siehe @kaporalix Post]

b) Matritzen multiplizieren
- Euer weg ist schon ganz gut, nur solltet ihr die Abbruchbedingung der 3. for-schleife auf for(int i = 0; i < a[0].length; i++)

PS: Wenn ihr Scanner noch nicht hattet gibt es noch einen BufferedReader.. wenn ihr den auch noch nicht hattet wird es schwer.

 

[SRPM]

Das ist schonmal gut, vielen Dank! bufferedreader hatten wir leider auch noch noch nicht . .Also wirds schwer - Mist

 

[JCODA]

Naja, schwer nicht.
Ihr benutzt dieses "tolle" package "IO". Manche Lehrer/Dozenten finden es total toll, nicht Standard-Java Bibliotheken zu benutzen.
Dort gibt es garantiert eine Methode, wie ihr Benutzereingaben machen könnt. Schaut mal in euren Unterlagen wie das geht, bzw. benutzt Google.

 

[SRPM]

Ja Benutzereingaben laufen unter IO.readInt ("..")
Das Problem ist eher return.

 

[JCODA]

Ja Benutzereingaben laufen unter IO.readInt ("..")
Das Problem ist eher return.

Was denkst du denn, was return tut?
Wollt ihr eigene Methoden schreiben? Dann braucht ihr return.

 

[JStein52]

Eure main könnte etwa so aussehen:

    public static void main(String[] args) {

        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);
        int k = Integer.parseInt(args[2]);

        int[][] a = new int[n][m];
        int[][] b = new int[m][k];
        int[][] c = new int[n][k];
        // Matrix a einlesen
        for (int z = 0; z < n; z++) {
            for (int s = 0; s < m; s++) {
                a[z][s] = Integer.parseInt(args[3 + (z * n + s)]);
            }
        }

        // Matrix b einlesen
        for (int z = 0; z < m; z++) {
            for (int s = 0; s < k; s++) {
                b[z][s] = Integer.parseInt(args[3 + (n * m) + (z * n + s)]);
            }
        }
        // a*b ausrechnen und gleich zeilenweise ausgeben
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < k; j++) {
                for (int l = 0; l < m; l++) {
                    c[i][j] += a[i][l] * b[l][j];
                }
                System.out.print(c[i][j]+" ");
            }
            System.out.println("");
        }
}

Da wo bei mir Integer.parseInt(...) steht müsst ihr eure IO-Funktionen verwenden. Und ihr müsst bedenken, man kann eine n*m-Matrix mit einer m*k-Matrix multiplizieren und das Ergebnis ist eine n*k-Matrix. D.h. ihr müsst die drei Werte m, n, k einlesen und anschliessend eben die Inhalte der beiden Matrizen.