add Physik

src/Ramen_Physik.c

@@ -9,11 +9,18 @@ Aenderungen:
 V 1.0 11.12.2024 Erste Version
 */
 
+// Einbindung Bibliotheken
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <string.h>
+#include <unistd.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
 
+// Einbindung Dateien
+#include "Tic_Tac_Toe.h"
 
 //Definitionen
 #define max_anzahl_fehler 3
@@ -53,11 +60,14 @@ int zufaellig(int maximum){
 int einfache_fragen(int *falsche_antwort){
 
     //Variabeln
-    const int anzahl_fragen = 10;
+    const int anzahl_fragen = 8;
     int fragen[3] = {-1, -1,-1};
     int return_code = 0;
     int x = 0;
 
+    //Lösungseingabe
+    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");
+
     //abfragen der verwendeten Fragen
     for (int i = 0; i < 3; i++)
     {
@@ -79,53 +89,43 @@ int einfache_fragen(int *falsche_antwort){
         switch (x)
         {
         case 0 :
-            printf("Frage 1 \n");
+            printf("Der relative Fehler ist eine Grösse ohne Masseinheit. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 1 :
-            printf("Frage 2 \n");
+            printf("Es gilt 10^-12 nm = 1 km  \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 2 :
-            printf("Frage 3 \n");
+            printf("Die Gewichtskraft eines Objektes steigt linear mit dessen Masse. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 3 :
-            printf("Frage 4 \n");
+            printf("Ein Druck kann sowohl in Flüssigkeiten als auch in Gasen herrschen. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 4 :
-            printf("Frage 5 \n");
+            printf("Der Luftdruck auf Meereshöhe beträgt ca. 10 bar.  \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 5 :
-            printf("Frage 6 \n");
+            printf("Die barometrische Höhenformel gilt unter der Annahme, dass die Luft in der Atmosphäre überall die gleiche Temperatur hat. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 6 :
-            printf("Frage 7 \n");
+            printf("Es gilt ∆W = mg ∆h, wenn man Reibung und Luftwiderstand vernachlässigt. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 7 :
-            printf("Frage 8 \n");
+            printf("Wird eine Kugel von einer an der Wand befestigten Feder horizontal weggeschleudert wird, dann wird die elastische Energie in kinetische Energie umgewandelt.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
-            break;
-
-        case 8 :
-            printf("Frage 9 \n");
-            return_code = antwort(2, falsche_antwort);
-            break;
-
-        case 9 :
-            printf("Frage 10 \n");
-            return_code = antwort(2, falsche_antwort);
             break;
 
         default:
@@ -138,17 +138,21 @@ int einfache_fragen(int *falsche_antwort){
         }
         
     }
+    return 10;
 }
 
 //mittlere Fragen
 int mittlere_fragen(int *falsche_antwort){
 
     //Variabeln
-    const int anzahl_fragen = 10;
+    const int anzahl_fragen = 8;
     int fragen[3] = {-1, -1,-1};
     int return_code = 0;
     int x = 0;
 
+    //Lösungseingabe
+    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");
+
     //abfragen verwendeter Fragen
     for (int i = 0; i < 3; i++)
     {
@@ -170,53 +174,43 @@ int mittlere_fragen(int *falsche_antwort){
         switch (x)
         {
         case 0 :
-            printf("Frage 1 \n");
+            printf("In der Physik sind weltweit ausschliesslich SI-Einheiten in Gebrauch. \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 1 :
-            printf("Frage 2 \n");
+            printf("Das Prinzip actio et reactio ist eine Folge des Impuls-Erhaltungssatzes. \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 2 :
-            printf("Frage 3 \n");
+            printf("Befindet sich ein Körper im Stillstand, dann wirkt überhaupt keine Kraft auf ihn. \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 3 :
-            printf("Frage 4 \n");
+            printf("Verdoppelt man den Steigungswinkel einer Rampe, dann verdoppelt man auch ihre Steigung.  \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 4 :
-            printf("Frage 5 \n");
+            printf("Die Ruhepunkt-Methode basiert auf dem Newton-Aktionsprinzip.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 5 :
-            printf("Frage 6 \n");
+            printf("Mit Hilfe der Ruhepunkt-Methode erkennt man, ob die berechneten Kräfte eine Belastung auf Zug oder Druck bedeuten.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 6 :
-            printf("Frage 7 \n");
+            printf("Für jede Bewegung ist die geleistete Arbeit gleich der Fläche im s-F-Diagramm zwischen dem Graphen von F(s) und der s-Achse \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 7 :
-            printf("Frage 8 \n");
+            printf("Die Leistung quantifiziert den Energiestrom, d.h. die übertragene Energie pro Zeiteinheit auf ein Objekt.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
-            break;
-
-        case 8 :
-            printf("Frage 9 \n");
-            return_code = antwort(2, falsche_antwort);
-            break;
-
-        case 9 :
-            printf("Frage 10 \n");
-            return_code = antwort(2, falsche_antwort);
             break;
 
         default:
@@ -229,17 +223,21 @@ int mittlere_fragen(int *falsche_antwort){
         }
         
     }
+    return 10;
 }
 
 //schwere Fragen
 int schwere_fragen(int *falsche_antwort){
 
     //Variabeln
-    const int anzahl_fragen = 10;
+    const int anzahl_fragen = 8;
     int fragen[3] = {-1, -1,-1};
     int return_code = 0;
     int x = 0;
 
+    //Lösungseingabe
+    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");
+
     //abfragen verwendeter Fragen
     for (int i = 0; i < 3; i++)
     {
@@ -261,52 +259,42 @@ int schwere_fragen(int *falsche_antwort){
         switch (x)
         {
         case 0 :
-            printf("Frage 1 \n");
+            printf("Die 7 SI-Basis-Einheiten orientieren sich an den Grössenordnungen der Menschen.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 1 :
-            printf("Frage 2 \n");
+            printf("Die Ursache des Impuls-Erhaltungssatzes ist die Zeitunabhängigkeit der physikalischen Gesetze.  \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 2 :
-            printf("Frage 3 \n");
+            printf("Der Begriff Kraft quantifiziert den Impulsstrom, d.h. den Impulsübertrag pro Zeiteinheit auf ein Objekt.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 3 :
-            printf("Frage 4 \n");
+            printf("Wirkt auf ein fahrendes Auto nur der turbulente Strömungswiderstand, dann wird es gleichförmig abgebremst. \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 4 :
-            printf("Frage 5 \n");
+            printf("Die Leistung eines Blitzschlages kann die Leistung eines Grosskraftwerkes weit übertreffen.  \n");
-            return_code = antwort(2, falsche_antwort);
+            return_code = antwort(1, falsche_antwort);
             break;
 
         case 5 :
-            printf("Frage 6 \n");
+            printf("Wird ein Körper von der Geschwindigkeit v0 < 0 mit konstanter Leistung P auf eine Geschwindigkeit vE < v0 beschleunigt, dann gilt P < 0. \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 6 :
-            printf("Frage 7 \n");
+            printf("Ist die Beschleunigungsfunktion eines Objektes strikt negativ, d.h. gilt a(t) < 0 zu jeder Zeit t ≥ t0, dann bewegt sich das Objekt zu jeder Zeit t ≥ t0 in Rückwärtsrichtung (negative Bewegungsrichtung). \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
         case 7 :
-            printf("Frage 8 \n");
+            printf("Es seien ∆t = tE - t0, ∆s = sE - s0 und ∆v = vE - v0. Dann gilt für jede Bewegung v(t) = ∆s/∆t und a(t) = ∆v/∆t. \n");
-            return_code = antwort(2, falsche_antwort);
-            break;
-
-        case 8 :
-            printf("Frage 9 \n");
-            return_code = antwort(2, falsche_antwort);
-            break;
-
-        case 9 :
-            printf("Frage 10 \n");
             return_code = antwort(2, falsche_antwort);
             break;
 
@@ -320,6 +308,7 @@ int schwere_fragen(int *falsche_antwort){
         }
         
     }
+    return 10;
 }
 
 
@@ -366,9 +355,23 @@ int Ramen_Physik(){
                 return_code = schwere_fragen(&falsche_antwort);
                 break;
             }
+            case '4':{
+                Tic_Tac_Toe();
+                break;
+            }
 
             case 'q':{
                 printf("\nProgramm beendet \n");
+
+                fflush(stdout);
+                //Sleep
+                #ifdef __linux__
+                    sleep(2);
+                #elif _WIN32
+                // Sleep ist in Milisekunden
+                    Sleep(2 * 1000);
+                #endif
+
                 return 10;
                 break;
             }
@@ -379,12 +382,37 @@ int Ramen_Physik(){
             }
             default: {
                 printf("Zu viele ungültige Eingaben. Programm beendet.\n");
+
+                fflush(stdout);
+                //Sleep
+                #ifdef __linux__
+                    sleep(2);
+                #elif _WIN32
+                    // Sleep ist in Milisekunden
+                    Sleep(2 * 1000);
+                #endif
+
                 return 20;
             }
         }
 
-        if (return_code == 20){
+        switch (return_code){
-            return 20;
+          case 10: { 
+            Tic_Tac_Toe(); 
+
+            fflush(stdout);
+            //Sleep
+            #ifdef __linux__
+                sleep(2);
+            #elif _WIN32
+                // Sleep ist in Milisekunden
+                Sleep(2 * 1000);
+            #endif
+
+            return_code = 0; 
+            break;
+          }
+          case 20: return 20; break; 
         }
     }
     return 0;

src/Ramen_Physik.h

@@ -1,21 +1,18 @@
-/* Physikhelper_Physik.h
+/* Ramen_Physik.h
 Hier werden Physikaufgaben gelöst mit einem Spiel als Pause
 
-Autor: Jana Nieblas, Debora Semmler
+Autor: Jana Nieblas
 Firma: FHGR
 Version 1.0
-Datum 09.12.2024
+Datum 15.12.2024
 Aenderungen:
-V 1.0 09.12.2024 Erste Version
+V 1.0 15.12.2024 Erste Version
 */
 
 #ifndef _FILE_NAME_H_ 
 #define _FILE_NAME_H_ 
 
-
+   //extern Phxsik mit Spiel; 
-
-   //extern float var1,var2; 
    extern int Ramen_Physik();
    
-
 #endif

src/Tic_Tac_Toe.c

@@ -0,0 +1,186 @@
+/* Tic Tac Toe
+Ein einfaches Tic Tac Toe programm
+
+Autor: Debora Semmler
+Firma: FHGR
+Version: 1.0
+Datum: 13.12.2024
+Aenderungen:
+V 1.0 13.12.2024 Erste Version
+*/
+
+// Einbinden von Headerdateien der Programmbibliothek.
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <time.h>
+
+//Definition von Spielfeld und Symbolen
+char board[3][3];
+const char PLAYER = 'O';
+const char COMPUTER = 'X';
+
+
+//Funktionsprototypen
+void resetBoard();
+void printBoard();
+int checkFreeSpaces();
+void playerMoves();
+void computerMoves();
+char checkWinner();
+void printWinner(char);
+
+//Das Hauptprogramm
+int Tic_Tac_Toe() 
+{
+
+	char winner = ' ';
+	
+	resetBoard();
+
+	while(winner == ' ' && checkFreeSpaces() != 0)
+	{
+		printBoard();
+
+		playerMoves();
+		winner = checkWinner();
+		if(winner != ' ' || checkFreeSpaces() == 0){
+			break;
+		}
+
+		computerMoves();
+		winner = checkWinner();
+		if(winner != ' ' || checkFreeSpaces() == 0){
+			break;
+		}
+	}
+
+	printBoard();
+	printWinner(winner);
+	
+	// Rückgabewert, dass das Programm erfolgreich beendet wurde.
+	return 0;
+    
+}
+
+
+void resetBoard(){
+	for(int i = 0; i<3; i++)
+	{
+		for(int j = 0; j<3; j++)
+		{
+			board[i][j]	= ' ';
+		}	
+	}
+	
+}
+
+//Gibt das Spielfeld aus
+void printBoard(){
+	printf("[ %c ][ %c ][ %c ]\n", board[0][0], board[0][1], board[0][2]);
+	printf("[ %c ][ %c ][ %c ]\n", board[1][0], board[1][1], board[1][2]);
+	printf("[ %c ][ %c ][ %c ]\n", board[2][0], board[2][1], board[2][2]);
+}
+
+//Zählt die freien Felder auf dem Spielfeld
+int checkFreeSpaces(){
+	int freeSpaces = 9;	
+
+	for(int i = 0; i<3; i++)
+	{
+		for(int j = 0; j<3; j++)
+		{
+			if(board[i][j] != ' ')
+			{
+				freeSpaces--;
+			}
+		}
+	}
+	return freeSpaces;
+}
+
+//Ernöglicht dem Spieler einen Zug zu machen
+void playerMoves(){
+	int x;
+	int y;
+
+	do
+	{
+		printf("Gibt die Horizontale ein (1-3): ");
+		scanf("%d", &x);
+		x--;
+		printf("Gib die Vertikale ein (1-3): ");
+		scanf("%d", &y);
+		y--;
+
+		if(board[x][y] != ' ')
+		{
+			printf("Ungültig!\n");
+		}
+		else{
+			board[x][y] = PLAYER;
+			break;
+		}
+
+	} while (board[x][y] != ' ');
+	
+}
+
+//Der Computer macht einen Zufallszug
+void computerMoves(){
+	//Seed für Zufallszahlen
+	srand(time(0));
+	int x;
+	int y;
+
+	if(checkFreeSpaces() > 0){
+		do
+		{
+			x = rand() % 3;
+			y = rand() % 3;
+		} while (board[x][y] != ' ');
+
+		board[x][y] = COMPUTER;	
+	}
+	else{
+		printWinner(' ');
+	}
+}
+
+//Überprüft die Gewinn bedingungen
+char checkWinner(){
+	//Prüft nach horizontalen Gewinnbedingungen
+	for(int i = 0; i < 3; i ++){
+		if(board[i][0] == board[i][1] && board[i][0] == board[i][2]){
+			return board[i][0]; 
+		}
+	}
+	//Prüft nach vertikalen Gewinnbedingungen
+	for(int i = 0; i < 3; i ++){
+		if(board[0][i] == board[1][i] && board[0][i] == board[2][i]){
+			return board[0][i]; 
+		}
+	}
+	//Prüft nach diagonalen Gewinnbedingungen
+	if(board[0][0] == board[1][1] && board[0][0] == board[2][2]){
+		return board[0][0]; 
+	}	
+	if(board[0][2] == board[1][1] && board[0][2] == board[2][0]){
+		return board[0][2]; 
+	}
+
+	return ' ';
+}
+
+//Gibt das Ergebnis des Spieldurchgangs aus
+void printWinner(char winner){
+	if(winner == PLAYER){
+		printf("DU HAST GEWONNEN!");
+	}
+	else if(winner == COMPUTER){
+		printf("DU HAST VERLOREN!");
+	}
+	else{
+		printf("ES IST EIN UNENTSCHIEDEN!");
+	}
+}

src/Tic_Tac_Toe.h

@@ -0,0 +1,18 @@
+/* Ramen_Physik.h
+Hier wir das Spiel als Pause verknüpft
+
+Autor: Jana Nieblas
+Firma: FHGR
+Version 1.0
+Datum 15.12.2024
+Aenderungen:
+V 1.0 15.12.2024 Erste Version
+*/
+
+#ifndef _FILE_NAME_H_ 
+#define _FILE_NAME_H_ 
+
+   //extern Spiel; 
+   extern int Tic_Tac_Toe();
+   
+#endif