added ws202425 courses

2023_Informatik_b/3/1989.cpp

@@ -0,0 +1,44 @@
+#include <iostream>
+#include <vector>
+#include <string>
+
+int main() {
+    int vector_size;
+    std::vector<int> vec;
+    
+    std::cout << "Bitte geben Sie die Größe des Vektors an: ";
+    std::cin >> vector_size;
+
+    std::cout << "Geben Sie die Werte des Vektors ein:" << std::endl;
+    for (int i = 0; i < vector_size; ++i) {
+        int input;
+        std::cin >> input;
+        vec.push_back(input);
+    }
+
+    int count_1 = 0;
+    int count_3 = 0;
+    bool found = false;
+
+    for (int i = 0; i < vector_size; ++i) {
+        if (vec[i] == 1) count_1++;
+        if (vec[i] == 3) count_3++;
+
+        if (i + 3 < vector_size) {
+            if (vec[i] == 1 && vec[i + 1] == 9 && vec[i + 2] == 8 && vec[i + 3] == 9) {
+                found = true;
+            }
+        }
+    }
+
+    std::cout << "Anzahl der 1en im Vektor: " << count_1 << std::endl;
+    std::cout << "Anzahl der 3en im Vektor: " << count_3 << std::endl;
+
+    if (found) {
+        std::cout << "Das Album \"1989\" von Taylor Swift ist ein sehr gutes Album." << std::endl;
+    } else {
+        std::cout << "\"1989\" kommt nicht vor." << std::endl;
+    }
+
+    return 0;
+}

2023_Informatik_b/3/angestellter.cpp

@@ -0,0 +1,81 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+enum Abteilung {
+    IT,
+    FINANZ,
+    MARKETING,
+    PERSONAL,
+    PRODUKTION
+};
+
+struct angestellter {
+    std::string name;
+    int personalnummer;
+    Abteilung abteilung;
+    double gehalt;
+};
+
+angestellter angestellter_eingeben();
+std::vector<angestellter> abteilung_check(std::vector<angestellter> vec, Abteilung abt);
+
+int main() {
+
+    angestellter beispielAngestellter = angestellter_eingeben();
+
+    std::cout << std::endl << "Angestellter:" << std::endl;
+    std::cout << "Name: " << beispielAngestellter.name << std::endl;
+    std::cout << "Personalnummer: " << beispielAngestellter.personalnummer << std::endl;
+    std::cout << "Abteilung: " << beispielAngestellter.abteilung << std::endl;
+    std::cout << "Gehalt: " << beispielAngestellter.gehalt << std::endl;
+
+    angestellter kollege1 = {"Hans Wurst", 678, PRODUKTION, 3550.5};
+    angestellter kollege2 = {"Scrooge McDough", 022, FINANZ, 4702};
+    angestellter kollege3 = {"Ninja Scripter", 337, IT, 2500};
+    angestellter kollege4 = {"Snake Oil", 888, MARKETING, 1800};
+    angestellter kollege5 = {"Overlord", 007, PERSONAL, 5600};
+
+    std::vector<angestellter> belegschaft = {kollege1, kollege2, kollege3, kollege4, kollege5};
+    std::vector<angestellter> filtered = abteilung_check(belegschaft, beispielAngestellter.abteilung);
+
+    // Display filtered employees or a message if no matching employees are found.
+    if (!filtered.empty()) {
+        for (const auto& ang : filtered) {
+            std::cout << "Filtered employee: " << ang.name << std::endl;
+        }
+    } else {
+        std::cout << "No matching employees found." << std::endl;
+    }
+
+    return 0;   
+}
+
+std::vector<angestellter> abteilung_check(std::vector<angestellter> vec, Abteilung abt) {
+std::vector<angestellter> division;
+    for (const auto &ang : vec) {
+        if (ang.abteilung == abt) {
+            division.push_back(ang);
+        }
+    }
+    return division;
+}
+
+angestellter angestellter_eingeben() {
+    angestellter neuerAngestellter;
+    int abteilungWahl;
+    std::cout << "Name: ";
+    std::getline(std::cin, neuerAngestellter.name);
+    std::cout << "Personalnummer: ";
+    std::cin >> neuerAngestellter.personalnummer;
+
+    std::cout << "Abteilung (0: IT, 1: FINANZ, 2: MARKETING, 3: PERSONAL, 4: PRODUKTION): ";
+    std::cin >> abteilungWahl;
+    neuerAngestellter.abteilung = static_cast<Abteilung>(abteilungWahl);
+
+    std::cout << "Gehalt: ";
+    std::cin >> neuerAngestellter.gehalt;
+    std::cin.ignore();
+
+    return neuerAngestellter;
+}

2023_Informatik_b/3/collatz.cpp

@@ -0,0 +1,62 @@
+/* Informatik B - Sommersemester 2023
+Vorlesung am 03.05.2023
+Katharina Klost
+
+Weiteres Beispiel zur Rekursion
+*/
+
+#include <iostream>
+
+/*
+Voraussetzung: n ist größer als 0
+Ergebnis: Wenn Collatz mit n/2 terminiert ist true geliefert
+Effekt: keiner
+*/
+bool c1(unsigned);
+
+
+/*
+Voraussetzung: n ist größer als 0
+Ergebnis: Wenn Collatz mit 3*n+1 terminiert ist true geliefert
+Effekt: keiner
+*/
+bool c2(unsigned);
+
+/*
+Voraussetzung: n ist größer als 0
+Ergebnis: true, wenn die Collatzfolge von n aus terminiert
+Effekt: gibt aktuellen Wert n aus
+*/
+bool collatz(unsigned);
+
+bool c1(unsigned n){
+  return collatz(n/2);
+}
+
+bool collatz(unsigned n){
+  std::cout << n << std::endl;
+  if (n==1){
+    return true;
+  }
+  // !(n%2) ist true, wenn n gerade ist. Dies kann wie folgt gesehen werden:
+  // für gerade n ist n%2 == 0. Das Anwenden von ! interpretiert die 0 dann als
+  // false, dieses wird negiert und damit wird der Ausdruck zu true ausgewertet.
+  // Etwas länger aber evtl besser zu lesen wär (n%2 == 0).
+  if (!(n%2)){
+    return c1(n);
+  }else{ // n ungerade
+    return c2(n);
+  }
+}
+
+bool c2(unsigned n){
+  return collatz(3*n+1);
+}
+
+int main(){
+  int n;
+  std::cout << "Gebe eine Zahl ein: ";
+  std::cin >> n;
+  collatz(n);
+  std::cout << "terminated" << std::endl;
+}

2023_Informatik_b/3/euklid.cpp

@@ -0,0 +1,65 @@
+/* Informatik B - Sommersemester 2023
+Vorlesung am 05.05.2023
+Katharina Klost
+
+Verschiedene Umsetzungen des euklidischen Algorithmus
+*/
+
+#include <iostream>
+
+/*
+Voraussetzung: keine
+Effekt: Es werden Informationen zum Ablauf ausgegeben
+Ergebnis: Der größte gemeinsame Teiler von a und b ist geliefert
+*/
+// Rekursive Umsetzung
+unsigned euclid_rec(unsigned a, unsigned b);
+//optimierte rekursive Umsetzung
+unsigned euclid_rec_opt(unsigned a, unsigned b);
+//iterative Umsetzung
+unsigned euclid_it(unsigned a, unsigned b);
+
+
+unsigned euclid_rec(unsigned a, unsigned b){
+  std::cout << "ggT(" << a << ", " << b << ")" << std::endl;
+  if (b>a){
+    return euclid_rec(b,a);
+  }
+  if(b==0){
+    return a;
+  }
+  return euclid_rec(a-b, b);
+}
+
+// statt immer wieder a-b zu rechnen, bis das Ergebnis kleiner als b ist,
+// kann direkt modulu verwendet werden
+unsigned euclid_rec_opt(unsigned a, unsigned b){
+    std::cout << "ggTopt(" << a<< ", " << b << ")" << std::endl;
+    if(b==0){
+      return a;
+    }
+    return euclid_rec_opt(b, a%b);
+}
+
+//iterative Umsetzung des optimierten euklidischen Algorithmus
+unsigned euclid_it(unsigned a, unsigned b){
+  unsigned newb;
+  while(b!=0){
+    newb = a%b;
+    a=b;
+    b = newb;
+  }
+  return a;
+}
+
+int main(){
+  int a= 12;
+  int b= 136;
+  std::cout << "===Rekursiv===" << std::endl;
+  int ggT= euclid_rec(a , b);
+  std::cout << "Der ggT von " << a << " und " << b << " ist " << ggT <<std::endl;
+  std::cout << "===Rekursiv Optimiert ===" << std::endl;
+  ggT= euclid_rec_opt(a , b);
+  std::cout << "Der ggT von " << a << " und " << b << " ist " << ggT <<std::endl;
+
+}

2023_Informatik_b/3/histogram.cpp

@@ -0,0 +1,70 @@
+/*
+Arbeiten mit Dateien in C++:
+- Datei öffnen
+- Datei lesen
+- Datei schließen
+Quelle: https://cplusplus.com/reference/fstream/
+
+histogram() ist eine Funktion, die ein Histogramm der Buchstaben in einem String erstellt.
+- Vorraussetzungen: str ist ein String
+- Ergebnis: hist ist ein Vektor, der die Häufigkeit der Buchstaben in str enthält
+- Seiteneffekte: keine
+*/
+
+#include <iostream>
+#include <string>
+#include <fstream> 
+#include <vector>
+
+std::vector<int> histogram(std::string str);
+
+int main() {
+    
+    std::ifstream inputFile("moby.txt");
+
+    std::string content, line;
+    
+    while (std::getline(inputFile, line)) {
+        content += line;
+    }
+
+    std::vector<int> hist = histogram(content);
+    
+    for (unsigned i = 0; i < 26; i++) {
+        if (hist[i] > 0) { 
+            std::cout << static_cast<char>('a' + i) << ": " << hist[i] << ", ";
+        }
+    }
+    
+    for (unsigned i = 26; i < hist.size(); i++) { // Loop for uppercase letters
+        if (hist[i] > 0) {
+            std::cout << static_cast<char>('A' + i - 26) << ": " << hist[i] << ", ";
+        }
+    }
+
+    std::cout << std::endl;
+
+    inputFile.close();
+
+    return 0;
+
+}
+
+std::vector<int> histogram(std::string str) {
+    
+    std::vector<int> hist(52, 0);
+    
+    for (unsigned i = 0; i < str.length(); i++) {
+        
+        if (str[i] >= 'a' && str[i] <= 'z') {
+            hist[str[i] - 'a']++;
+        } 
+
+        else if (str[i] >= 'A' && str[i] <= 'Z') {
+            hist[str[i] - 'A' + 26]++;
+        }
+
+    }
+
+    return hist;
+}

2023_Informatik_b/3/menu.cpp

@@ -0,0 +1,91 @@
+#include <iostream>
+#include <string>
+#include <vector>
+
+// Enum für die verschiedenen Menüpunkte
+enum MenuType {
+    Vorspeise,
+    Hauptgang,
+    Dessert
+};
+
+// Struct für die Details eines Menüpunkts
+struct MenuItem {
+    MenuType type;
+    std::string name;
+    std::string description;
+    double price;
+};
+
+void showMenu(const std::vector<MenuItem>& menu) {
+    for (size_t i = 0; i < menu.size(); ++i) {
+        std::string type;
+        switch (menu[i].type) {
+            case Vorspeise:
+                type = "Vorspeise";
+                break;
+            case Hauptgang:
+                type = "Hauptgang";
+                break;
+            case Dessert:
+                type = "Dessert";
+                break;
+        }
+        std::cout << type << ": " << menu[i].name << " - " << menu[i].description << " (€" << menu[i].price << ")\n";
+    }
+}
+
+MenuItem searchMenuItem(const std::vector<MenuItem>& menu, const std::string& name) {
+    for (size_t i = 0; i < menu.size(); ++i) {
+        if (menu[i].name == name) {
+            return menu[i];
+        }
+    }
+    return MenuItem{static_cast<MenuType>(-1), "", "", -1.0};
+}
+
+int main() {
+    // Erstellen des Restaurantmenüs
+    std::vector<MenuItem> menu = {
+        {Vorspeise, "Bruschetta", "Geröstetes Brot mit Tomaten, Knoblauch und Basilikum", 5.0},
+        {Hauptgang, "Spaghetti Bolognese", "Spaghetti mit würziger Hackfleisch-Tomatensauce", 10.0},
+        {Dessert, "Tiramisu", "Italienisches Dessert aus Löffelbiskuit, Mascarpone und Kaffee", 6.0}
+    };
+
+    std::cout << "Willkommen im Restaurant!\n";
+    std::cout << "Möchten Sie das Menü anzeigen oder nach einem bestimmten Menüpunkt suchen?\n";
+    std::cout << "1. Menü anzeigen\n";
+    std::cout << "2. Nach Menüpunkt suchen\n";
+    std::cout << "3. Beenden\n";
+
+    int option;
+    std::cin >> option;
+
+    while (option != 3) {
+        if (option == 1) {
+            showMenu(menu);
+        } else if (option == 2) {
+            std::string name;
+            std::cout << "Geben Sie den Namen des Menüpunkts ein, nach dem Sie suchen möchten: ";
+            std::cin.ignore();
+            std::getline(std::cin, name);
+            MenuItem item = searchMenuItem(menu, name);
+            if (item.price != -1.0) {
+                std::cout << item.name << " - " << item.description << " (€" << item.price << ")\n";
+            } else {
+                std::cout << "Menüpunkt nicht gefunden.\n";
+            }
+        } else {
+            std::cout << "Ungültige Option.\n";
+        }
+
+        std::cout << "\nMöchten Sie das Menü anzeigen oder nach einem bestimmten Menüpunkt suchen?\n";
+        std::cout << "1. Menü anzeigen\n";
+        std::cout << "2. Nach Menüpunkt suchen\n";
+        std::cout << "3. Beenden\n";
+        std::cin >> option;
+    }
+
+    std::cout << "Vielen Dank für Ihren Besuch! Auf Wiedersehen!\n";
+    return 0;
+}

2023_Informatik_b/3/rekursion_iteration.cpp

@@ -0,0 +1,45 @@
+/* Informatik B - Sommersemester 2023
+Vorlesung am 03.05.2023
+Katharina Klost
+
+Beispiele zu rekursion und iteration
+*/
+#include <iostream>
+
+/*
+Voraussetzung: keine
+Ergebnis: Die Fakultät von n ist geliefert
+Effekt: keiner
+Rekursive Implementierung
+*/
+unsigned fak_rek(unsigned n);
+
+
+/*
+Voraussetzung: keine
+Ergebnis: Die Fakultät von n ist geliefert
+Effekt: keiner
+Iterative Implementierung
+*/
+unsigned fak_iter(unsigned n);
+
+//Da hier direkte rekursion verwendet wird, gibt es keine Optimierung.
+// Bei Endrekursion und Verwendung des -O3 flags wird die Endrekursion optimiert
+unsigned fak_rek(unsigned n){
+  if (n==0){
+    return 1;
+  }
+  return(fak_rek(n-1)*n);
+}
+
+unsigned fak_iter(unsigned n){
+  unsigned res = 1;
+  for (unsigned i = 1; i<=n; i++){
+    res*=i;
+  }
+  return res;
+}
+
+int main(){
+
+}

2023_Informatik_b/3/replace.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <string>
+
+/*
+- Voraussetzungen: str ist ein String, charToReplace und replacementChar sind Zeichen
+- Ergebnis: str ist ein String, in dem alle Vorkommen von charToReplace durch replacementChar ersetzt wurden
+- Seiteneffekte: keine
+
+Der Rückgabetyp ist string, weil wir einen neuen String zurückgeben wollen, in dem alle Vorkommen von charToReplace durch replacementChar ersetzt wurden.
+Die Parameter sind char, weil wir nur ein Zeichen ersetzen wollen.
+
+*/
+std::string repl(std::string str, char charToReplace, char replacementChar);
+
+int main() {
+    
+    std::cout << "Bitte gebe einen String ein bei dem du die Zeichen ersetzen willst: ";
+    std::string s;
+    std::getline(std::cin, s);
+    
+    std::cout << "Bitte gebe das Zeichen ein, welches zu ersetzen möchtest: ";
+    char a;
+    std::cin >>  a;
+    
+    std::cout << "Bitte gebe das Zeichen ein, durch welches du ersetzen möchtest: ";
+    char b;
+    std::cin >> b;
+
+    std::cout << "Dein neuer String ist: " << repl(s, a, b) << std::endl;
+
+}
+
+std::string repl(std::string str, char charToReplace, char replacementChar) {
+    
+    for (unsigned i = 0; i < str.length(); i++) {
+        if (str[i] == charToReplace) {
+            str[i] = replacementChar;
+        }
+    }
+
+    return str;
+    
+}

2023_Informatik_b/3/reverseSortVector.cpp

@@ -0,0 +1,35 @@
+#include <iostream>
+#include <vector>
+
+std::vector<int> reverseSortVector(std::vector<int> vec);
+
+int main() {
+
+    int input = -1;
+    std::vector<int> vec;
+    std::vector<int> vecnew;
+
+    std::cout << "Geben Sie eine Zahlenfolge ein, mit 0 beenden Sie die Eingabe: " << std::endl;
+    while (input != 0) {
+        std::cin >> input;
+        if (input != 0) {
+            vec.push_back(input);
+        }
+    }
+
+    vecnew = reverseSortVector(vec);
+
+    std::cout << "Die Zahlenfolge in umgekehrter Reihenfolge: " << std::endl;
+    for (unsigned i = 0; i < vecnew.size(); i++) {
+        std::cout << vecnew[i] << std::endl;
+    }
+    
+}
+
+std::vector<int> reverseSortVector(std::vector<int> vec) {
+    std::vector<int> vecnew;
+    for (unsigned i = vec.size() - 1; i >= 0; i--) {
+        vecnew.push_back(vec[i]);
+    }
+    return vecnew;
+}

2023_Informatik_b/3/rucksack.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+/*
+Voraussetzung: keine
+Effekt: Keiner
+Ergebnis: Eine größtmögliche Auswahl von Elementen, deren Summe von Gewichten unter bound ist,
+ist geliefert.
+*/
+std::vector<unsigned> rucksack_einfach(unsigned bound, std::vector<unsigned> gewichte);
+
+/*
+Voraussetzung: Der vector hat mindestens ein Element
+Effekt: Die Elementen von vec im geschlossenen Intervall [start, end] werden ausgegeben
+Ergebnis: keins
+*/
+void gebe_aus(std::vector<unsigned>& vec, unsigned start, unsigned end);
+
+std::vector<unsigned> rucksack_einfach(unsigned bound, std::vector<unsigned> gewichte){
+  std::vector<unsigned> rucksack_inhalt ={};
+  std::sort(gewichte.begin(), gewichte.end());
+  for(unsigned i = 0; i<gewichte.size() && bound >= gewichte[i]; i++){
+    bound = bound - gewichte[i];
+    rucksack_inhalt.push_back(gewichte[i]);
+  }
+  return rucksack_inhalt;
+}
+
+void gebe_aus(std::vector<unsigned>& vec, unsigned start, unsigned end){
+  if(end>vec.size() || start >= end){
+    std::cout << vec.size() << " " << end << std::endl;
+    return;
+  }
+  std::cout << vec[start];
+  for(unsigned k=start+1; k<end; k++){
+    std::cout << ", " << vec[k];
+  }
+  std::cout << std::endl;
+}
+
+int main(){
+  std::vector<unsigned> gewichte = {3,7,4,17,5,6};
+  std::vector<unsigned> einfach_erg = rucksack_einfach(12, gewichte);
+  gebe_aus(einfach_erg, 0, einfach_erg.size());
+
+}

2023_Informatik_b/3/upper.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <string>
+
+/*
+- Voraussetzungen: str ist ein String
+- Ergebnis: str ist ein String, der nur aus Großbuchstaben besteht
+- Seiteneffekte: keine
+
+Der Rückgabetyp ist string, weil wir einen neuen String zurückgeben wollen, der nur aus Großbuchstaben besteht.
+Der Parameter ist string, weil wir einen String übergeben wollen, bei dem wir die Buchstaben in Großbuchstaben umwandeln wollen.
+
+*/
+std::string upper(std::string str);
+
+int main() {
+
+    std::cout << "Bitte gebe einen String ein der groß geschrieben werden soll: ";
+    std::string s;
+    std::getline(std::cin, s);
+    std::cout << "Hier ist dein neuer String: " << upper(s) << std::endl;
+
+}
+
+std::string upper(std::string str) {
+    for (unsigned i = 0; i < str.length(); i++) {
+        if (str[i] >= 'a' && str[i] <= 'z') {
+            str[i] = str[i] - 32;
+        }
+    }
+
+    return str;
+
+}