improve workspace and slides for the adjacency matrix

3 files changed, 65 insertions, 15 deletions

diff --git a/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixLoesung.json b/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixLoesung.json
index 8acedff8..2acf44ba 100644
--- a/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixLoesung.json
+++ b/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixLoesung.json
@@ -1 +1,20 @@
-{"name":"Adjazenzmatrix","modules":[{"name":"Adjazenzmatrix","text":"/**\n * Darstellung eines Graphens als Adjazenzmatrix.\n * Die Gewichte der Kanten werden in einem zweidimensionalen Feld von\n * Typ int gespeichert.\n * \n */\nclass Adjazenzmatrix\n{\n\n   int[][] adjazenzmatrix;\n   int anzKnoten;\n\n    // Konstruktor\n   Adjazenzmatrix(int maxAnzKnoten) { \n      // Initialisierung des Feld-Attributs\n      adjazenzmatrix = new int[maxAnzKnoten][maxAnzKnoten];\n\n      anzKnoten = maxAnzKnoten;\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            adjazenzmatrix[i][j] = -1;\n         }\n      }\n   }\n\n    /*\n     * Die Kanten bzw. Adjazenzmatrix ausgeben.\n     */\n   void matrixAusgeben() {\n      println(\"Die Adjazenzmatrix lautet:\");\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            print(adjazenzmatrix[i][j] + \",  \");\n         }\n         println(\"\");\n      }\n   }\n\n    /****************************************************************************************************\n     * Hinzufuegen von Kanten bzw. Knoten\n     ****************************************************************************************************/\n    \n   /** \n    * Eine Kante hinzufuegen.\n    * \n    * @param start der Startknoten der Kante\n    * @param ziel der Zielknoten der Kante\n    * @param gewicht das Gewicht der Kante\n    */\n   void kanteHinzufuegen(int start, int ziel, int gewicht) {\n      adjazenzmatrix[start - 1][ziel - 1] = gewicht;\n   }\n\n   /*\n    * Eine ungerichtete Kante hinzufuegen.\n    * \n    * @param knoten1 der erste der beiden Nachbarknoten\n    * @param knoten2 der zweite der beiden Nachbarknoten\n    * @param gewicht das Gewicht der ungerichteten Kante\n    */\n   void ungerichteteKanteHinzufuegen(int knoten1, int knoten2, int gewicht) {\n      kanteHinzufuegen(knoten1, knoten2, gewicht);\n      kanteHinzufuegen(knoten2, knoten1, gewicht);\n   }\n\n   /*\n    * Die Laenge eines Pfades berechnen.\n    * \n    * @param pfad Pfad dessen Laenge berechnet werden soll\n    * @return die Laenge des Pfades, -1 falls kein gueltiger Pfad uebergeben wurde\n    */\n   int pfadLaengeGeben(int[] pfad) {\n      int laenge = 0;\n      \n      for (int i = 1; i < pfad.length; i++) {\n         int start = pfad[i - 1] ;\n         int ziel = pfad[i];\n         int gewicht = adjazenzmatrix[start - 1][ziel - 1];\n         if(gewicht != -1){\n            laenge += gewicht;\n         } else {\n            return -1;\n         }\n      }\n\n      return laenge; \n   }\n}\n\nAdjazenzmatrix matrix = new Adjazenzmatrix(4);\nmatrix.ungerichteteKanteHinzufuegen(1, 2, 1);\nmatrix.ungerichteteKanteHinzufuegen(2, 3, 1);\nmatrix.ungerichteteKanteHinzufuegen(3, 4, 1);\nmatrix.ungerichteteKanteHinzufuegen(4, 1, 1);\nmatrix.matrixAusgeben();\n\nint[] kreis = { 1, 2, 3, 4, 1};\nprintln();\nprintln(\"Die berechnete Laenge des Rundlaufs ist \" + matrix.pfadLaengeGeben(kreis) + \" (Erwartet: 4)\");","identical_to_repository_version":true,"is_copy_of_id":1424357,"repository_file_version":3}],"settings":{"libraries":[]}}
\ No newline at end of file
+{
+   "name": "Adjazenzmatrix_Loesung",
+   "id": 845311,
+   "modules": [
+      {
+         "name": "Adjazenzmatrix",
+         "text": "/**\n * Darstellung eines Graphens als Adjazenzmatrix.\n * Die Gewichte der Kanten werden in einem zweidimensionalen Feld von\n * Typ int gespeichert.\n * \n */\nclass Adjazenzmatrix\n{\n\n   int[][] kanten;\n   int anzKnoten;\n\n    // Konstruktor\n   Adjazenzmatrix(int maxAnzKnoten) { \n      // Initialisierung des Attribut kanten\n      kanten = new int[maxAnzKnoten][maxAnzKnoten];\n\n      anzKnoten = maxAnzKnoten;\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            kanten[i][j] = -1;\n         }\n      }\n   }\n\n    /*\n     * Die Kanten bzw. Adjazenzmatrix ausgeben.\n     */\n   void matrixAusgeben() {\n      println(\"Die Adjazenzmatrix lautet:\");\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            print(kanten[i][j] + \",  \");\n         }\n         println(\"\");\n      }\n   }\n\n    /****************************************************************************************************\n     * Hinzufuegen von Kanten bzw. Knoten\n     ****************************************************************************************************/\n    \n   /** \n    * Eine Kante hinzufuegen.\n    * \n    * @param start der Startknoten der Kante\n    * @param ziel der Zielknoten der Kante\n    * @param gewicht das Gewicht der Kante\n    */\n   void kanteHinzufuegen(int start, int ziel, int gewicht) {\n      kanten[start - 1][ziel - 1] = gewicht;\n   }\n\n   /*\n    * Eine ungerichtete Kante hinzufuegen.\n    * \n    * @param knoten1 der erste der beiden Nachbarknoten\n    * @param knoten2 der zweite der beiden Nachbarknoten\n    * @param gewicht das Gewicht der ungerichteten Kante\n    */\n   void ungerichteteKanteHinzufuegen(int knoten1, int knoten2, int gewicht) {\n      kanteHinzufuegen(knoten1, knoten2, gewicht);\n      kanteHinzufuegen(knoten2, knoten1, gewicht);\n   }\n\n   /*\n    * Die Laenge eines Pfades berechnen.\n    * \n    * @param pfad Pfad, dessen Laenge berechnet werden soll\n    * @return die Laenge des Pfades, -1 falls kein gueltiger Pfad uebergeben wurde\n    */\n   int pfadLaengeGeben(int[] pfad) {\n      int laenge = 0;\n      \n      for (int i = 1; i < pfad.length; i++) {\n         int start = pfad[i - 1] ;\n         int ziel = pfad[i];\n         int gewicht = kanten[start - 1][ziel - 1];\n         if(gewicht != -1){\n            laenge += gewicht;\n         } else {\n            return -1;\n         }\n      }\n\n      return laenge; \n   }\n}\n\nAdjazenzmatrix adjm1 = new Adjazenzmatrix(4);\nadjm1.ungerichteteKanteHinzufuegen(1, 2, 1);\nadjm1.ungerichteteKanteHinzufuegen(2, 3, 1);\nadjm1.ungerichteteKanteHinzufuegen(3, 4, 1);\nadjm1.ungerichteteKanteHinzufuegen(4, 1, 1);\nadjm1.matrixAusgeben();\n\nint[] kreis = { 1, 2, 3, 4, 1};\nprintln();\nprintln(\"Die berechnete Laenge des Rundlaufs ist \" + adjm1.pfadLaengeGeben(kreis) + \" (Erwartet: 4)\");",
+         "identical_to_repository_version": true,
+         "is_copy_of_id": 2431889,
+         "repository_file_version": 1,
+         "isFolder": false,
+         "parent_folder_id": null
+      }
+   ],
+   "settings": {
+      "libraries": []
+   },
+   "parent_folder_id": null,
+   "isFolder": false
+}
\ No newline at end of file
diff --git a/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixVorlage.json b/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixVorlage.json
index 96865543..df53d974 100644
--- a/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixVorlage.json
+++ b/Info/11/NTG/1/Adjazenzmatrix/AdjazenzmatrixVorlage.json
@@ -1 +1,20 @@
-{"name":"Adjazenzmatrix","modules":[{"name":"Adjazenzmatrix","text":"/**\n * Darstellung eines Graphens als Adjazenzmatrix.\n * Die Gewichte der Kanten werden in einem zweidimensionalen Feld von\n * Typ int gespeichert.\n * \n */\nclass Adjazenzmatrix\n{\n\n   int[][] adjazenzmatrix;\n   int anzKnoten;\n\n    // Konstruktor\n   Adjazenzmatrix(int maxAnzKnoten) { \n        // Initialisierung des Feld-Attributs\n        // TODO 1: Initialisiere adjazenzmatrix mit beiden Dimensionen\n        //         entsprechen dem Parameter maxAnzKnoten.\n\n        // TODO 1: Initialisiere das Attribut anzKnoten, das die maximale Anzahl\n        //         der Knoten und damit die Groesse der Adjazenzmatrix speichert.\n\n        // Die Adjazenzmatrix wird mit dem Wert -1 (\"keine Kante\") vorbelegt.\n        // TODO 2: Befuelle die Adjazenzmatrix mit den oben beschriebenen Werten.\n   }\n\n    /*\n     * Die Kanten bzw. Adjazenzmatrix ausgeben.\n     */\n   void matrixAusgeben() {\n      println(\"Die Adjazenzmatrix lautet:\");\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            print(adjazenzmatrix[i][j] + \",  \");\n         }\n         println(\"\");\n      }\n   }\n\n    /****************************************************************************************************\n     * Hinzufuegen von Kanten bzw. Knoten\n     ****************************************************************************************************/\n    \n   /** \n    * Eine Kante hinzufuegen.\n    * \n    * @param start der Startknoten der Kante\n    * @param ziel der Zielknoten der Kante\n    * @param gewicht das Gewicht der Kante\n    */\n   void kanteHinzufuegen(int start, int ziel, int gewicht) {\n        // TODO 3: Fuege die Kante von start nach ziel mit ihrem Gewicht in\n        //         die Adjazenzmatrix ein.\n        //         ACHTUNG: Start und Ziel werden als Knotennummer nicht als Index angegeben.\n   }\n\n   /*\n    * Eine ungerichtete Kante hinzufuegen.\n    * \n    * @param knoten1 der erste der beiden Nachbarknoten\n    * @param knoten2 der zweite der beiden Nachbarknoten\n    * @param gewicht das Gewicht der ungerichteten Kante\n    */\n   void ungerichteteKanteHinzufuegen(int knoten1, int knoten2, int gewicht) {\n      // TODO 4: Fuege die ungerichtete Kante in die Adjazenmatrix ein.\n      //         Tipp: Du kannst die Methode kanteHinzufuegen verwenden.\n   }\n\n   /*\n    * Die Laenge eines Pfades berechnen.\n    * \n    * @param pfad Pfad dessen Laenge berechnet werden soll\n    * @return die Laenge des Pfades, -1 falls kein gueltiger Pfad uebergeben wurde\n    */\n   int pfadLaengeGeben(int[] pfad) {\n      // TODO 5 - FUER SCHNELLE: Implementiere die Methode\n\n      return 0 /* FIXME 5 */; \n   }\n}\n\nAdjazenzmatrix matrix = new Adjazenzmatrix(4);\nmatrix.ungerichteteKanteHinzufuegen(1, 2, 1);\nmatrix.ungerichteteKanteHinzufuegen(2, 3, 1);\nmatrix.ungerichteteKanteHinzufuegen(3, 4, 1);\nmatrix.ungerichteteKanteHinzufuegen(4, 1, 1);\nmatrix.matrixAusgeben();\n\nint[] kreis = { 1, 2, 3, 4, 1 };\nprintln();\nprintln(\"Die berechnete Laenge des Rundlaufs ist \" + matrix.pfadLaengeGeben(kreis) + \" (Erwartet: 4)\");","identical_to_repository_version":true,"is_copy_of_id":1424357,"repository_file_version":2}],"settings":{"libraries":[]}}
\ No newline at end of file
+{
+   "name": "Adjazenzmatrix",
+   "id": 845312,
+   "modules": [
+      {
+         "name": "Adjazenzmatrix",
+         "text": "/**\n * Darstellung eines Graphens als Adjazenzmatrix.\n * Die Gewichte der Kanten werden in einem zweidimensionalen Feld von\n * Typ int gespeichert.\n * \n */\nclass Adjazenzmatrix\n{\n\n   int[][] kanten;\n   int anzKnoten;\n\n    // Konstruktor\n   Adjazenzmatrix(int maxAnzKnoten) { \n        // Initialisierung des Attributs kanten\n        // TODO 1: Initialisiere kanten mit beiden Dimensionen\n        //         entsprechen dem Parameter maxAnzKnoten.\n\n        // TODO 1: Initialisiere das Attribut anzKnoten, das die aktuelle Anzahl\n        //         der Knoten und damit die Groesse der Adjazenzmatrix speichert.\n\n        // Die Adjazenzmatrix wird mit dem Wert -1 (\"keine Kante\") vorbelegt.\n        // TODO 2: Befuelle die Adjazenzmatrix mit den oben beschriebenen Werten.\n   }\n\n    /*\n     * Die Kanten bzw. Adjazenzmatrix ausgeben.\n     */\n   void matrixAusgeben() {\n      println(\"Die Adjazenzmatrix lautet:\");\n\n      for (int i = 0; i < anzKnoten; i++) {\n         for (int j = 0; j < anzKnoten; j++) {\n            print(kanten[i][j] + \",  \");\n         }\n         println(\"\");\n      }\n   }\n\n    /****************************************************************************************************\n     * Hinzufuegen von Kanten bzw. Knoten\n     ****************************************************************************************************/\n    \n   /** \n    * Eine Kante hinzufuegen.\n    * \n    * @param start der Startknoten der Kante\n    * @param ziel der Zielknoten der Kante\n    * @param gewicht das Gewicht der Kante\n    */\n   void kanteHinzufuegen(int start, int ziel, int gewicht) {\n        // TODO 3: Fuege die Kante von start nach ziel mit ihrem Gewicht in\n        //         die Adjazenzmatrix ein.\n        //         ACHTUNG: Start und Ziel werden als Knotennummer nicht als Index angegeben.\n   }\n\n   /*\n    * Eine ungerichtete Kante hinzufuegen.\n    * \n    * @param knoten1 der erste der beiden Nachbarknoten\n    * @param knoten2 der zweite der beiden Nachbarknoten\n    * @param gewicht das Gewicht der ungerichteten Kante\n    */\n   void ungerichteteKanteHinzufuegen(int knoten1, int knoten2, int gewicht) {\n      // TODO 4: Fuege die ungerichtete Kante in die Adjazenmatrix ein.\n      //         Tipp: Du kannst die Methode kanteHinzufuegen verwenden.\n   }\n\n   /*\n    * Die Laenge eines Pfades berechnen.\n    * \n    * @param pfad Pfad dessen Laenge berechnet werden soll\n    * @return die Laenge des Pfades, -1 falls kein gueltiger Pfad uebergeben wurde\n    */\n   int pfadLaengeGeben(int[] pfad) {\n      // TODO 5 - FUER SCHNELLE: Implementiere die Methode\n\n      return 0 /* FIXME 5 */; \n   }\n}\n\nAdjazenzmatrix adjm1 = new Adjazenzmatrix(4);\nadjm1.ungerichteteKanteHinzufuegen(1, 2, 1);\nadjm1.ungerichteteKanteHinzufuegen(2, 3, 1);\nadjm1.ungerichteteKanteHinzufuegen(3, 4, 1);\nadjm1.ungerichteteKanteHinzufuegen(4, 1, 1);\nadjm1.matrixAusgeben();\n\nint[] kreis = { 1, 2, 3, 4, 1 };\nprintln();\nprintln(\"Die berechnete Laenge des Rundlaufs ist \" + adjm1.pfadLaengeGeben(kreis) + \" (Erwartet: 4)\");",
+         "identical_to_repository_version": true,
+         "is_copy_of_id": 2431890,
+         "repository_file_version": 1,
+         "isFolder": false,
+         "parent_folder_id": null
+      }
+   ],
+   "settings": {
+      "libraries": []
+   },
+   "parent_folder_id": null,
+   "isFolder": false
+}
\ No newline at end of file
diff --git a/Info/11/NTG/1/Adjazenzmatrix/slides.md b/Info/11/NTG/1/Adjazenzmatrix/slides.md
index 6deb5c2f..c7419f69 100644
--- a/Info/11/NTG/1/Adjazenzmatrix/slides.md
+++ b/Info/11/NTG/1/Adjazenzmatrix/slides.md
@@ -1,8 +1,5 @@
 ---
 header-includes: |
-    \makeatletter
-    \beamer@ignorenonframefalse
-    \makeatother
     \usepackage[most]{tcolorbox}
     \usetikzlibrary {decorations.markings}
 ---
@@ -21,15 +18,15 @@ und den Bildschirm ausschalten.
 ### Diskutiert folgende Aussage:
 
 \vspace{0.3cm}
-`\only<1>{`{=latex}
+`\only<1,2>{`{=latex}
 
 > Folgender \boldred{Graf} ist \boldred{gerichtet}, da die \boldred{Punkte} mit gerichteten \boldred{Connections} verbunden sind.
 
 `}`{=latex}
 
-`\only<2>{`{=latex}
+`\only<3>{`{=latex}
 
-> Folgender \boldred{Graph} ist \boldred{gerichtet}, da die \boldred{Knoten/vertices} mit gerichteten \boldred{Kanten/edges} verbunden sind.
+> Folgender \boldgreen{Graph} ist **gerichtet**, da die \boldgreen{Knoten/vertices} mit gerichteten \boldgreen{Kanten/edges} verbunden sind.
 
 `}`{=latex}
 
@@ -53,16 +50,19 @@ und den Bildschirm ausschalten.
 }
 \end{tikzpicture}
 
-::::
-:::
+\only<2>{
+\begin{tikzpicture}[overlay, remember picture]
+  \node[rotate=-30,scale=3] at (6, 3) {\large \boldred{Falsch}};
+\end{tikzpicture}
+}
 
 ## \faIcon{hands-helping} / \faIcon{chalkboard} Arbeitsauftrag: Wege durch Graphen \hfill{} 2/5
 
 ### Diskutiert folgende Aussage:
 
 \vspace{0.2cm}
-> Ein Graph heißt \only<1>{\boldred{zusammenhängend}}\only<2>{\boldred{vollständig}}, wenn jeder Knoten mit jedem anderen Knoten verbunden ist.
-> Ein derartiger Graph hat immer \only<1>{$n^2$}\only<2>{$\frac{(n^2-n)}{2}$} Kanten, wenn n die Anzahl der Knoten ist.
+> Ein Graph heißt \only<1,2>{\boldred{zusammenhängend}}\only<3>{\boldgreen{vollständig}}, wenn jeder Knoten mit jedem anderen Knoten verbunden ist.
+> Ein derartiger Graph hat immer \only<1,2>{$n^2$}\only<3>{$\frac{(n^2-n)}{2}$} Kanten, wenn n die Anzahl der Knoten ist.
 
 `\begin{center}`{=latex}
 `\only<1>{`{=latex}
@@ -103,6 +103,12 @@ graph {
 ```
 `}\end{center}`{=latex}
 
+\only<2>{
+\begin{tikzpicture}[overlay, remember picture]
+  \node[rotate=-30,scale=3] at (11.5, 3) {\large \boldred{Falsch}};
+\end{tikzpicture}
+}
+
 ## \faIcon{hands-helping} / \faIcon{chalkboard} Arbeitsauftrag: Wege durch Graphen \hfill{} 3/5
 
 ### Diskutiert folgende Aussage:
@@ -130,11 +136,11 @@ Die Länge eines Pfades in einem [gewichteten]{.underline} Graphen ist die **Sum
 
 ::: {.columns}
 :::: {.column width=50%}
-* Laenge(`A/B/D`) = 5
+* Länge(`A/B/D`) = 5
 ::::
 
 :::: {.column width=50%}
-* Laenge(`A/B/C/D`) = \boldred{4}
+* Länge(`A/B/C/D`) = \boldred{4}
 ::::
 :::
 
@@ -154,7 +160,11 @@ verwende(knoten[4]);
 > Um die Werte eines Array verwenden zu können, reicht es aus das Array zu deklarieren und dieses anschließend zu initialisieren.
 
 \pause
-Die **einzelnen** Einträge müssen ebenfalls initialisiert werden.
+\begin{tikzpicture}[overlay, remember picture]
+  \node[rotate=-30,scale=3] at (10, 3) {\large \boldred{Falsch}};
+\end{tikzpicture}
+
+Die \boldred{einzelnen} Einträge müssen ebenfalls initialisiert werden.
 
 ## \faIcon{hands-helping} / \faIcon{chalkboard} Arbeitsauftrag: Graphendarstellung \hfill{} 5/5
 
@@ -336,6 +346,8 @@ Der Eintrag \boldred{-1} symbolisiert \textit{"keine Kante"}, um das Kantengewic
 
 ## \faIcon{pencil-alt} Arbeitsauftrag - Arbeitsblatt 10min
 
+### Lückentext
+
 ### Arbeitsauftrag 1: Graph $\rightarrow$ Adjazenzmatrix
 
 ### Arbeitsauftrag 2: Adjazenzmatrix $\rightarrow$ Graph