Initial commit with cleaned history

2024-09-01 18:09:25 +02:00
commit 208004e9d0
273 changed files with 234697 additions and 0 deletions
@@ -0,0 +1,23 @@
+# Abwägen
+
+## 1.
+Wenn Sie nur jeweils eine Rolle gegen eine andere abwägen dürfen, dann ist die Methode der **binären Suche** das effizienteste Verfahren. Hier ist, wie Sie es tun könnten:
+
+Vergleichen Sie die Rollen 1 und 2. Wenn sie gleich schwer sind, gehen Sie zur Rolle 3 und so weiter. Wenn sie unterschiedlich schwer sind, haben Sie das Falschgeld gefunden.
+Wiederholen Sie diesen Vorgang, bis Sie das Falschgeld gefunden haben.
+
+Im schlimmsten Fall müssten Sie 11 Vergleiche durchführen, um das Falschgeld zu finden (wenn das Falschgeld in der letzten Rolle ist).
+
+
+
+## 2. 
+    Wenn Sie mehrere Rollen gegeneinander wägen dürfen, dann können Sie das Problem mit nur 3 Vergleichen lösen. Hier ist ein möglicher Weg:
+
+    - Vergleich 1: Nehmen Sie die ersten 4 Rollen (1-4) und wägen Sie sie gegen die nächsten 4 Rollen (5-8). Es gibt zwei Möglichkeiten:
+        - Wenn sie gleich schwer sind, liegt das Falschgeld in den Rollen 9-12. Gehen Sie zu Vergleich 2a.
+        - Wenn sie unterschiedlich schwer sind, liegt das Falschgeld in den Rollen 1-8. Gehen Sie zu Vergleich 2b.
+    - Vergleich 2a: Wägen Sie die Rollen 9 und 10 gegen die Rollen 11 und 12. Hier finden Sie heraus, welche Rolle das Falschgeld enthält und ob es leichter oder schwerer ist.
+    - Vergleich 2b: Wägen Sie drei der verdächtigen Rollen (zum Beispiel 1, 2, 3) gegen drei Rollen, von denen Sie wissen, dass sie echt sind (zum Beispiel 9, 10, 11). Es gibt zwei Möglichkeiten:
+        - Wenn sie gleich schwer sind, liegt das Falschgeld in der verbliebenen verdächtigen Rolle (4). Sie wissen auch, dass das Falschgeld schwerer ist, weil die verdächtigen Rollen bei dem ersten Vergleich schwerer waren.
+        - Wenn sie unterschiedlich schwer sind, liegt das Falschgeld in den drei verdächtigen Rollen (1, 2, 3). Gehen Sie zu Vergleich 3.
+    - Vergleich 3: Wägen Sie zwei der verdächtigen Rollen (zum Beispiel 1 und 2) gegeneinander. Hier finden Sie heraus, welche Rolle das Falschgeld enthält und ob es leichter oder schwerer ist.
@@ -0,0 +1,35 @@
+/* Informatik B - Sommersemester 2022
+Vorlesung am 21.04.2022
+Katharina Klost
+
+Beispiele zu arithmetischen Operationen
+*/
+
+#include <iostream>
+
+int main(){
+  /* Unterschiede zwische Post- und Preinkrement:
+
+  Beim Postinkrement wird der Wert *erst* ausgewertet und dann erhöht,
+  daher wird in der zweiten Zeile noch einmal 2 und erst in der dritten
+  Zeile 3 ausgegeben.
+  Bei Preinkrement wird erst erhöht und dann ausgegeben, daher wird in der
+  vierten und fünften Zeile 4 ausgegeben.
+  */
+  int n =2;
+  std::cout << "Vor Postinkrement " << n << std::endl;
+  std::cout << "Postinkrement " << n++ << std::endl;
+  std::cout << "Nach Postinkrement " << n << std::endl;
+  std::cout << "Preinkrement " << ++n << std::endl;
+  std::cout << "Nach Preinkrement " << n << std::endl;
+
+  // += als vereinfachte Schreibweise für n = n + 3;
+  n+=3;
+  std::cout << n << std::endl;
+
+  // k und k1 haben auf Grund der Bindunststärken den gleichen Wert
+  int k1 = 7*4 + ++n/4;
+  int k = (7*4)+ ((++n) / 4);
+  std::cout << "k1: "  << k1 << ", k: " <<k << std::endl;
+
+}
@@ -0,0 +1,73 @@
+/* Informatik B - Sommersemester 2022
+Vorlesung am 21.04.2022
+Katharina Klost
+
+Beispiele zu Datentypen
+*/
+
+
+#include <iostream>
+#include <climits>
+
+int main(){
+  //Auf Grund der Wertsemantik wird nur der Inhalt von num 3 verändert
+  int num2 = 20;
+  int num3 = num2;
+  std::cout << "num 2: " << num2 << std::endl;
+  std::cout << "num 3: " << num3 << std::endl;
+  num3 = num3 +1;
+  std::cout << "num 2: " << num2 << std::endl;
+  std::cout << "num 3: " << num3 << std::endl;
+
+  /*Auch wenn in einem Bool allgeine Werte gespeichert werden können
+  wird nur 0 für false und 1 für alle Werte != 0 ausgegeben*/
+  bool b1 = 12;
+  std::cout << "b1: " << b1 << std::endl;
+  std::cout << "Größe von b1: " << sizeof(b1) << std::endl;
+
+  //Da chars intern als Zahlen gespeichert werden, kann mit diesen auch
+  //gerechnet werden
+  char c1 = 'A';
+
+  std::cout << "c1: " << c1 << std::endl;
+  c1=c1+1;
+  std::cout << "c1: " << c1 << std::endl;
+
+  //Bei Integern kann es zu einem Überlauf kommen
+  int n = INT_MAX;
+  std::cout << n << std::endl;
+  n= n+1;
+  std::cout << n << std::endl;
+
+  // Bei Floats kann es wegen Rundungsfehlern zu unerwartetem Verhalten kommen
+  float x = 0;
+  for (int i = 0; i < 10; i++){
+	   x = x + 0.1;
+	    std::cout << "x"<<i <<" :"<< x << std::endl;
+    }
+
+    std::cout <<"(x==1.0) " << (x==1.0) << std::endl;
+
+  //Größen von verschiedenen Datentypen
+short s1 = 123;
+long l1 = 123;
+long long ll1 = 123;
+float f1 = 123.0;
+double d1 = 123.0;
+long double ld1 = 123.0;
+
+
+// Größen der Datentypen (auf diesem System)
+std::cout << "Größen verschiedener Datentypen in Byte" << std::endl;
+std::cout << "bool: " << sizeof(b1) << std::endl;
+std::cout << "char: " << sizeof(c1) << std::endl;
+std::cout << "short: " << sizeof(s1) << std::endl;
+std::cout << "int: " << sizeof(n) << std::endl;
+std::cout << "long: " << sizeof(l1) << std::endl;
+std::cout << "long long: " << sizeof(ll1) << std::endl;
+std::cout << "float: " << sizeof(f1) << std::endl;
+std::cout << "double: " << sizeof(d1) << std::endl;
+std::cout << "long double: " << sizeof(ld1) << std::endl;
+
+std::cout << "Größe eines Bytes in Bit: " << CHAR_BIT << std::endl;
+}
@@ -0,0 +1,13 @@
+/* Informatik B - Sommersemester 2022
+Vorlesung am 21.04.2022
+Katharina Klost
+
+Beispiele zur Ein-und Ausgabe
+*/
+#include <iostream>
+
+int main(){
+  /* Der Text "Hello World!" wird auf der Konsole ausgegeben, gefolgt von einem
+  Zeilenumbruch*/
+  std::cout << "Hello World!" << std::endl;
+}
@@ -0,0 +1,19 @@
+/* Informatik B - Sommersemester 2022
+Vorlesung am 21.04.2022
+Katharina Klost
+
+Beispiele zur Ein-und Ausgabe
+*/
+#include <iostream>
+
+int main(){
+  float a;
+  //Ohne std::endl gibt es keinen Zeilenumbruch
+  std::cout << "Gebe eine Zahl ein: ";
+  // mit std::cin wird ein Wert von der Konsole gelesen und wenn möglich
+  // in die passende Variable geschrieben
+  std::cin >> a;
+  // Das Ergebnis von Ausdrücken kann auf der Konsole ausgegeben werden
+  std::cout << "a: " << a << std::endl;
+  std::cout << "a mal zwei: " << a*2 << std::endl;
+}
@@ -0,0 +1,22 @@
+#include <iostream>
+
+bool isOdd(int num){
+	return num%2;
+}
+
+int main(){
+
+	std::cout << "Hello Günter" << std::endl;
+
+	int x = 16;
+
+	for(int i = 0; i<x; i++){
+		std::cout << "i: " << i;
+		if(isOdd(i)){
+			std::cout << " ist gerade" << std::endl;
+		}
+		else{
+			std::cout << " ist nicht gerade" << std::endl;
+		}
+	}
+}
@@ -0,0 +1,41 @@
+# Aufgabe 1: C++
+
+## 1. 
+> Betrachten Sie die Datei tut1.cpp aus dem Whiteboard und kompilieren Sie diese mit 
+
+```bash
+g++ -std=c++14 -Wall -Wextra -Werror -pedantic tut1.cpp -o tut1.
+```
+## 2.
+> Verändern Sie die erste Zeile die ausgegeben wird zu einer beliebigen anderen Nachricht. Aktuell zählt das Programm bis 9 hoch. Passen Sie es so an, dass es bis 15 zählt.
+
+tut1.cpp
+
+# Aufgabe 2: Abwägen
+> Vor Ihnen liegen 12 Rollen mit 1-Euro-Münzen, die Rollen sind durchnummeriert von 1 bis 12. Genau eine Rolle enthält Falschgeld und hat deswegen ein anderes Gewicht. Ihre Aufgabe ist es mittels einer Balkenwaage festzustellen, welche der Rollen das Falschgeld enthält und ob diese leichter oder schwerer ist als eine normale Rolle.
+
+## 1. 
+> Sie dürfen nur jeweils eine Rolle gegen eine andere abwägen. Beschreiben Sie ein Verfahren, das möglichst wenige Vergleiche verwendet. Wie viele sind das im schlechtesten Fall und warum geht es nicht besser?
+
+Nimm eine Referenzrolle und wiege alle gegen diese. 1 davon wiegt mehr oder weniger, dann weis man welche es ist. 
+
+Min: 1 Versuch
+Max 11 Versuche
+
+## 2. 
+> Sie dürfen mehrere Rollen gegeneinander wägen. Jetzt reichen 3 Vergleiche aus! Beschreiben Sie ein solches Verfahren.
+Hinweis: Beginen Sie mit vier Rollen auf jeder Seite. Der schwierige Fall tritt bei Ungleichheit ein, da Sie dann noch acht Verdächtige haben. Wählen Sie in diesem Fall aus diesen acht Verdächtigen sechs aus und verteilen Sie diese geschickt auf der Waage.
+
+4_1 zu 4_2
+
+wenn gleich{
+    4_3 aufteilen
+    2 zu 2
+    1 zu 1
+}
+
+wenn ungleich:{
+    fahre fort
+    2 zu 2
+    1 zu 1
+}
@@ -0,0 +1,44 @@
+#include <iostream>
+
+int main(){
+  int x = 2;
+  for (int i=0; i<32; i++){
+    x=x*2;
+  }
+  std::cout << x << std::endl;
+
+  int zahl = 50;
+  std::cout << (3+5*9==zahl-2) << std::endl;
+  std::cout << "Info B " << (40 * zahl + 23) << std::endl;
+  std::cout << (true && (++zahl > 50)) << std::endl;
+  std::cout << zahl << std::endl;
+  std::cout << ((zahl <= 44) + 7) << std::endl;
+
+
+  int y = 3;
+  int z = ++y + 2;
+  std::cout << "z: " << z << std::endl;
+  std::cout << "y: " << y << std::endl;
+  z = y++ + 2;
+  std::cout << "z: " << z << std::endl;
+  std::cout << "y: " << y << std::endl;
+
+
+  short a = 345;
+  std::cout << "Groesse von a " << sizeof(a) << std::endl;
+  std::cout << "Groesse von a+y " << sizeof(a+y) << std::endl;
+
+  std::cout << "Geben Sie eine Zahl ein: ";
+  std::cin >> a;
+  std::cout << "Ihre Zahl ist: " << a <<std::endl;
+
+  if(++y == 6){
+    std::cout << "Huhu" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+  if(y-- == 6){
+    std::cout << "Hallo" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+
+}
@@ -0,0 +1,203 @@
+# 1. Zahlenraten
+In dieser Aufgabe schauen wir uns ein einfaches Spiel für zwei Spieler:innen an. Nennen wir die Spieler:innen Alice und Bob. Alice denkt sich eine Zahl zwischen 0 und 1022 aus und Bob versucht die Zahl zu erraten. Bob darf eine Zahl nennen, und Alice gibt dann die Antwort kleiner, größer oder richtig, je nach dem ob die von Bob genannte Zahl kleiner, größer oder gleich der Zahl von Alice ist.
+
+## (a) 
+> Geben Sie eine Strategie an, mit der Bob mit maximal 1022 Versuchen die Zahl errät. Argumen- tieren Sie in einem Satz, warum jede Strategie, die 1023 oder mehr Versuche braucht unnötige Fragen verwendet.
+
+Eine Strategie wäre es immer die in die Mitte der Zahlenkette zu raten und dann einen Teil zu verwerfen. Da die Zahlenkette immer halbiert wird, wird die Anzahl der Versuche immer kleiner. 
+
+Eine Strategie mit mehr als 1023 Versuchen beinhaltet mehr Versuche als Zahlen in der Zahlenkette. Das heist selbst wenn man jede einzelne Zahl raten würde und die letzte die richtige Zahl ist, liegt man bei 1020 versuchen. Wenn man 1023 Versuche braucht fragt man also doppelt oder mehrmals nach Zahlen.
+
+## (b) 
+> Wie kann Bob einfach die Informationen, die er bis zu einem Zeitpunkt gesammelt hat verwenden, um sicher zu stellen, dass er keine Zahl rät, die nicht mehr die Lösung sein kann, da sie in einem Zahlenbereich liegt, der bereits ausgeschlossen wurde.
+
+Nicht mehr die Zahlen raten die größer oder kleiner der genannten Zahl ist. Das ist abhängig von Alice Antwort.
+
+## (c) 
+> Nun ist eine Strategie gesucht, mit der das Spiel schneller vorbei ist. Bob behauptet, dass er immer maximal 10 Versuche braucht. Geben Sie eine Strategie an, die immer maximal 10 Versuche braucht. Überlegen Sie dafür, wie Sie in jedem Schritt möglichst viele Zahlen ausschließen können, unabhängig davon, welche Antwort Alice gibt. Argumentieren Sie, warum die Strategie maximal 10 Versuche braucht.
+
+Mit der selben Strategie, die in (a) genannt wurde. Beweis:
+
+1020/2 = 510
+510/2 = 255
+255/2 = 127
+127/2 = 63
+63/2 = 31
+31/2 = 15
+15/2 = 7
+7/2 = 3
+3/2 = 1
+
+# 2. Lesen und Anpassen von C++ Code (0+6+2+2 Punkte)
+
+## (a) 
+> Betrachten Sie die Datei ueb1.cpp aus dem Whiteboard und kompilieren Sie diese mit 
+
+```bash
+g++ -std=c++14 -Wall -Wextra -Werror -pedantic ueb1.cpp -o ueb1
+```
+
+## (b) 
+> Führen Sie das Programm mit ./ueb1 aus und erklären Sie den Ablauf anhand des Quellcodes.
+
+```cpp
+int main(){
+```
+Die main Funktion ist die Funktion die beim starten des Programms ausgeführt wird. Sie ist die erste Funktion die aufgerufen wird.
+
+```cpp
+  int x = 2;
+  for (int i=0; i<32; i++){
+    x=x*2;
+  }
+  std::cout << x << std::endl;
+```
+
+Die Variable x wird mit dem Wert 2 initialisiert. Die for Schleife wird 32 mal ausgeführt. In jeder Iteration wird x mit 2 multipliziert. Das Ergebnis sollte 4,294,967,296 sein. Da der Datentype int aber nur 32 bit hat und da die höchste Zahl 2,147,483,647 ist, kommt es zu einem Overflow. Der Wert von x wird zurückgesetz auf 0, was ausgegeben wird. 
+
+```cpp
+  int zahl = 50;
+  std::cout << (3+5*9==zahl-2) << std::endl;
+  std::cout << "Info B " << (40 * zahl + 23) << std::endl;
+  std::cout << (true && (++zahl > 50)) << std::endl;
+  std::cout << zahl << std::endl;
+  std::cout << ((zahl <= 44) + 7) << std::endl;
+```
+
+Die Variable zahl wird mit dem Wert 50 initialisiert. Die zweite Zeile gibt 1 aus, da die Bedingung wahr ist. Die dritte Zeile berechnet den Wert 2023 und gibt diesen mit dem String "Info B" aus. Die vierte Zeile gibt 1 aus, da die Bedingung wahr ist. Die fünfte Zeile gibt 51 aus, da die Variable zahl in der vorherigen Zeile um 1 erhöht wurde. Die sechste Zeile gibt 7 aus, da die Bedingung falsch ist und 0 + 7 = 7 ist. 
+
+```cpp
+  int y = 3;
+  int z = ++y + 2;
+  std::cout << "z: " << z << std::endl;
+  std::cout << "y: " << y << std::endl;
+  z = y++ + 2;
+  std::cout << "z: " << z << std::endl;
+  std::cout << "y: " << y << std::endl;
+```
+
+Dieser Codeteil soll den Unterschied zwischen ++y und y++ zeigen. ++y erhöht y um 1 und wird dann verwendet. y++ wird zuerst verwendet und dann erhöht. 
+
+Die Variable y wird mit dem Wert 3 initialisiert. In der zweiten Zeile wird z mit dem Wert 6 initialisiert. Da y um 1 erhöhrt wird und dann mit 2 addiert wird. y hat jetzt den Wert 4 und z den Wert 6 was ausgegeben wird. In der fünften Zeile wird z mit dem Wert 6 initialisiert. Da y immernoch den Wert 4 hat und mit 2 addiert wird. Nach dem Ausdruck wird y um 1 erhöht. y hat jetzt den Wert 5 und z den Wert 6 was ausgegeben wird. 
+
+```cpp
+  int a = 345;
+  std::cout << "Groesse von a " << sizeof(a) << std::endl;
+  std::cout << "Groesse von a+y " << sizeof(a+y) << std::endl;
+```
+
+Zeigt die Größe von a und a+y in Bytes an. 
+
+```cpp
+  std::cout << "Geben Sie eine Zahl ein: ";
+  std::cin >> a;
+  std::cout << "Ihre Zahl ist: " << a <<std::endl;
+```
+
+Fragt den Benutzer nach einer Zahl und gibt diese aus.
+
+```cpp
+  if(y++ == 6){
+    std::cout << "Huhu" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+  if(--y == 6){
+    std::cout << "Hallo" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+
+}
+```
+
+Gibt "Hallo" oder "Huhu" aus, je nachdem ob die Bedingung wahr oder falsch ist. Danach wird y ausgegeben.
+
+## (c) 
+> Passen Sie das Programm so an, dass beide if-Bedingungen zu wahr auswerten, ohne dass sich der Zustand der Variablen nach den if-Bedingungen ändert.
+
+```cpp
+if(++y == 6){
+    std::cout << "Huhu" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+  if(y-- == 6){
+    std::cout << "Hallo" << std::endl;
+  }
+  std::cout << "y: " << y << std::endl;
+```
+
+## (d) 
+> Das Programm führt keine adäquate Fehlerbehandlung aus. Finden Sie Eingaben, bei denen das Programm ein unerwünschtes Verhalten zeigt.
+
+Todo!
+
+# 3. Von-Neumann-Rechner (5+5 Punkte)
+
+## (a)
+> Schreiben Sie ein Programm für den Von-Neumann-Rechner, das solange eine Variable hochzählt, bis diese den gleichen Wert wie eine gelesene Eingabe hat. Kommentieren Sie die Bedeutung der Speicherzellen.
+
+> Sie können die folgenden Befehle verwenden:
+
+| Befehl   | Beschreibung                                                               |
+|----------|----------------------------------------------------------------------------|
+| READ     | Liest eine Eingabe ein.                                                    |
+| WRITE X  | Schreibt den Inhalt des Rechenwerks in Zelle X.                            |
+| LOAD X   | Liest den Inhalt von Zelle X und schreibt diesen ins Rechenwerk.           |
+| CJUMP X  | Setzt den Befehlszähler auf X, wenn der Inhalt des Rechenwerks 0 
+ist.      |
+| GOTO X   | Setzt den Befehlszähler auf X.                                             |
+| ADD X    | Addiert den Inhalt von Zelle X auf den Inhalt des Rechenwerks.             |
+| SUB X    | Subtrahiert den Inhalt von Zelle X vom Inhalt des Rechenwerks.             |
+| OUTP X   | Gibt den Inhalt von Zelle X aus.                                           |
+| RETURN   | Beendet das Programm.                                                      |
+
+```Von-Neumann-Rechner
+1: READ
+2: WRITE 10  
+3: LOAD 11
+4: ADD 12
+5: STORE 11
+6: SUB 10
+7: CJUMP 9
+8: JUMP 11
+9: RETURN
+10: 0
+11: 0
+12: 1
+```
+
+## (b)
+> Beschreiben Sie, was das folgende Programm berechnet.
+
+```
+0: READ INP
+1: WRITE 14
+2: READ INP
+4: WRITE 15
+5: CJUMP 13
+6: READ 16
+7: ADD 14
+8: WRITE 16
+9: READ 15
+10: SUB 17
+11: WRITE 15
+12: JUMP 5
+13: OUTP 16
+14:0
+15:0
+16:0
+17:1
+```
+
+Liest zwei Zahlen ein. Die eine wird in einer Schleife verdoppelt, die andere wird um 1 reduziert. Wenn die zweite Zahl 0 erreicht, wird die mehrmals verdoppelte Zahl ausgegeben.
+
+```
+x = get()
+y = get()
+
+while y != 0:
+  z = 0 
+  z = z + x
+  y = y - 1
+
+print()
+```