Äquivalenz < Java < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 11:43 Sa 06.11.2004 | | Autor: | mausi |
Hallo ich brauch mal Hilfe bei diesem Programm
Implementieren Sie die Prozeduren reflexiv ,symmetrisch und transitiv ,so dass durch den
Aufruf dieser entschieden werden kann,ob eine Relation diese Eigenschaft erfüllt.Zur Eingabe der
Relation in ein zweidimensionales Array ist die Prozedur readRel aus den Vorgaben zu nutzen.
Geben sie die vier beschriebenen Eigenschaften einer eingelesenen Relation mit Hilfe der von Ihnen
implementierten Prozeduren auf der Konsole aus.
die vorgabe ist:
| 1: |
| | 2: | /**
| | 3: | * Das Programm erwartet als Eingabe die Größe einer quadratischen Matrix zur
| | 4: | * Speicherung einer Relation. Anschliessend wird die Relation als geordnetes
| | 5: | * Paar von positiven ganzen Zahlen eingelesen. Das Programm gibt aus, ob die
| | 6: | * Relation reflexiv, symmetrisch oder transitiv ist und ob es sich um eine
| | 7: | * Äquivalenzrelation handelt.
| | 8: | */
| | 9: |
| | 10: | public class Aequivalenz {
| | 11: |
| | 12: | /**
| | 13: | * Die Funktion "readRel" ist Parameterlos. Sie liest die Grösse des
| | 14: | * zweidimensionalen Arrays in der die Relation gespeichert werden soll. Dann
| | 15: | * werden solange geordnete Paare der Relation eingelesen, bis eine Eingabe
| | 16: | * nicht mehr im gültigen Bereich liegt (eingabe <0 oder eingabe >= size der
| | 17: | * quadratischen Matrix)
| | 18: | *
| | 19: | * @return zweidimensionales Array in dem die Relation gespeichert ist
| | 20: | */
| | 21: | static boolean[][] readRel() {
| | 22: | boolean[][] relation = null;
| | 23: | int size = 0, x = 0, y = 0; // Eingabevariable
| | 24: | int i = 0, j = 0; //Laufvariablen
| | 25: | stdin eingabe = new stdin();// Tastatureingabe
| | 26: |
| | 27: | // Schleife fuer Tastatureingabe, Absicherung und Fehlermeldung
| | 28: | do {
| | 29: | if ((size < 0) || (size > 20)) {
| | 30: | System.out.println("\nZahl zu gross oder zu klein.");
| | 31: | } // end if
| | 32: |
| | 33: | size = eingabe.getInt("Grösse der Matrix: ");
| | 34: | } //end do while
| | 35: | while ((size < 0) || (size > 20));
| | 36: |
| | 37: | relation = new boolean[size][size];
| | 38: |
| | 39: | if (size == 0) {
| | 40: | return relation;
| | 41: | }// end if
| | 42: | //Eingabe der Grössen in die Reihung
| | 43: | for (i = 0; i < relation.length; i++) {
| | 44: | for (j = 0; j < relation[i].length; j++) {
| | 45: | relation[i][j] = false;
| | 46: | } // end for
| | 47: | } //end for
| | 48: |
| | 49: | do {
| | 50: | x = eingabe.getInt("Geben Sie ein X ein: ");
| | 51: | y = eingabe.getInt("Geben Sie ein Y ein, dass zu X in Relation steht: ");
| | 52: | if ((x < 0) || (y < 0) || (x >= size) || (y >= size)) {
| | 53: | System.out
| | 54: | .println("Ende der Eingabe(aufgrund von Eingabewerten ausserhalb des gueltigen Bereichs:) ");
| | 55: | } else {
| | 56: | relation[x][y] = true;
| | 57: | } //end if
| | 58: | } //end do while
| | 59: | while ((x >= 0) && (y >= 0) && (x < size) && (y < size));
| | 60: |
| | 61: | return relation;
| | 62: | } //end readRel
| | 63: |
| | 64: |
| | 65: | /**
| | 66: | * Die Funktion "main" ruft die Funktion readRel und anschliessend die
| | 67: | * Funktionen reflexiv, symmetrisch, transitiv und speichert deren Ergebnis,
| | 68: | * an Hand dessen dann entschieden wird, ob es sich um eine
| | 69: | * Äquivalenzrelation handelt.
| | 70: | *
| | 71: | * @param argv wird ignoriert
| | 72: | */
| | 73: | public static void main(String argv[]) {
| | 74: | boolean ref = false;
| | 75: | boolean symm = false;
| | 76: | boolean trans = false;
| | 77: | boolean[][] relation = null;
| | 78: | relation = readRel();
| | 79: |
| | 80: | /*Hier müssen die Funktionsaufrufe und die Ausgabe ergänzt werden */
| | 81: |
| | 82: |
| | 83: | } //end main
| | 84: |
| | 85: | } //end class
|
wär echt nett wenn jemand helfen könnte
|
|
| |
|
Hallo Mausi,
eine Relation R ist bekanntermaßen reflexiv, wenn xRx wahr ist für alle in Frage kommenden x.
Also musst du testen, ob dein Array auf der Diagonalen nur TRUE enthält. Wenn ja, dann ist die Relation symmetrisch, ansonsten nicht.
Aus der Definition von symmetrisch und transitiv folgt auch, wie du dein Array auf diese Eigenschaften prüfen kannst.
Schreib doch bitte, wie du das machen würdest. Aber bitte nicht in Sourcecode, sondern kurz mit Worten, damit es alle verstehen können.
Hugo
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 19:21 Sa 06.11.2004 | | Autor: | mausi |
alles klar die definitionen sind:
reflexiv,wenn gilt:für alle x Element M :(x ,x)Element R
symmetrisch,wenn gilt: für alle x ,y Element M :(x ,y) Element R und (y ,x) Element R
transitiv,wenn gilt:für alle x ,y ,z Element M :(x ,y)Element R und (y ,z) Element R folgt (x ,z) Element R
so und nu ich weiss nicht wie ich das implementieren soll hab gar keine ahnung,bitte hilfe
|
|
|
| |
|
Hallo Mausi,
die Symmetrie überprüfst du, indem du testest, ob dein Array symmetrisch zur Diagonalen ist.
Die Transitivität musst du dir selbst überlegen, denn das hängt von der genauen Struktur deines Arrays ab.
Und wie gesamt muss bei einer reflexiven Relation die Diagonale des Arrays aus WAHR bestehen.
Hugo
|
|
|
|
