Added Lectures

PR1/PR1/Lektionen

@@ -1 +0,0 @@
-Subproject commit 8f8b3cf07721bec3efc95accd464e247717fd115

PR1/PR1/lectures/Lection 2.md

@@ -0,0 +1,118 @@
+### File I/O
+---
+### I/O
+
+Computer Systems need to receive inputs, to calculate a desired output.
+
+![[IO.png]]
+
+---
+### But how?
+You already know of one way to get an Input:
+```
+Scanner sc = new Scaner(System.in);
+```
+
+---
+### Is there any other way?
+
+
+---
+
+### So THATS what 'String[] args' means!
+
+```
+public static void main(String[] args){
+	// main is a function.
+	// Within main we can use the args parameter to access the cli arguments
+	System.out.println("The amount of cli arguments is:" + args.length);
+	for (int i = 0; i < args.length; i++){
+		System.out.println("The " + i + ". Argument is: " + args[i]);
+	}
+}
+```
+
+---
+
+### Excursion: Create runnable JAR File
+
+Dear Future Greg,
+
+I hope this slide finds you well. I am currently to lazy to create a detailed step by step guide to show your dear pupils how to create a runnable JAR File. Sadly you will have to show them this live, while sweating bricks that you JRE and JDK are compatible. Unfortunately for you, you will also have to create the step by step guide in addition to your troubles.
+
+Cheers,
+Asshole you from the past
+
+---
+### Excursion: Create runnable JAR File
+1. Build your Project
+2. Right click on Project folder > Export 
+3.  Choose Runnable JAR File
+4. Choose the proper launch configuration
+5. Choose save destination
+6. Finish!
+
+You now have a runnable JAR File that you can call from the command line. 
+
+
+---
+### Now lets try that out:
+
+```
+java -jar <jarfile> <args>
+```
+
+This will allow our program to take in arguments from the command line and  use them within our Program. THIS is why we all the previous task were so heavy on String manipulation. YOU can manipulate Strings.
+
+---
+
+### Args vs. System.in
+
+- System.in allows a user to *interactivly* change the behaviour of the program at runtime. It needs a user to input the data.
+- Args allows a user or *another program* to change the behaviour of the program at the start of the program
+---
+
+### File Input
+
+A popular argument to give to a program is a file. A file can store  an (almost) arbitrary amount and kind of data. This makes Files incredibly useful. While this might seem blatantly obvious at first, the implications of File I/O will become clearer once you understand that *EVERYTHING* on your (Unix*) computer is a file.
+
+*Technically Unix Sockets are not files, but can be read from in most cases as if it were a file
+
+---
+### File Output
+
+Files allow you to persist data. This means you can save arguments or calculations from your program. But even more importantly, Writing to a file, allows you to acces the results of your program through *another* program!
+
+---
+
+### So how do I do File IO?
+
+Well lets RTFM and see what Prof. Klaus wants you to do!
+
+[File IO as the Evil Mastermind intends](https://moodle.hs-mannheim.de/pluginfile.php/125982/mod_resource/content/9/pr1.teil2.pdf)
+
+---
+
+### Lets Try that:
+
+```java
+public static void main(String[] args){
+	if (args.length == 0){
+		System.out.println("No Arguments passed!");
+		return;
+	}
+	File myFile = new File(args[0]);
+	FileReader stream = new FileReader(myfile);
+	BufferedReader input = new BufferedReader(stream);
+
+	String line = input.readLine();
+	while(line ! = null){
+		System.out.println(line);
+		line = line.readLine();
+	}
+}
+```
+
+---
+---
+

PR1/PR1/lectures/Lektion 1.md

@@ -0,0 +1,239 @@
+### Programmieren Crash Kurs 
+---
+### Die Fragen
+1. Warum jetzt ausgerechnet **Java**?
+1. Warum fangen wir so simpel an?
+
+---
+
+### Struktur eines Programmes
+
+Ein Java Programm beginnt in der main Methode
+
+```java
+class MeineKlasse{
+	public static void main(String[] args){
+		// Hier beginnt der Code
+	}
+}
+```
+
+---
+### Ablauf eines Programms
+
+Fürs erste fokusieren wir uns auf **procedurale** Programmierung. D.h. jede Arbeitasanweisung wird Schritt für Schritt abgearbeitet.
+
+```
+class MeineKlasse{
+	public static void main(String[] args){
+		int ersteZahl = 0; // 1. Befehl
+		int zweiteZahl = 1; // 2. Befehl
+		int ergebnis = ersteZahl + zweiteZahl; // 3. Befehl
+		System.out.println(ergebnis); // 4. Befehl;
+	}
+}
+```
+i.d.R Endet jede Anweisung mit einem Semicolon (;)
+
+---
+### Variablen
+
+Variablen von einfachen Datentypen speichern Aussagen(Expressions). Variablen können nur Aussagen Ihres Datentypens speichern
+
+```
+boolean my_bool = true;
+int my_integer = 14;
+double my_double = 2.4;
+char my_char = 'H';
+```
+
+---
+### Aufgabe 0
+
+Finde die Fehler
+
+```java
+class MeineKlasse{
+	int a = 0;
+	public static void main(String[] args){
+		int b = 15;
+		int c = 4.0
+		System.out.println(ergebnis);
+		int ergebnis = a + b + c;
+	}
+}
+
+```
+---
+### Deklarierung und Initialisierung
+```
+int c;
+c = 10;
+int d = 10;
+```
+```
+int result;
+// viel Code dazwischen
+result = kalkulation();
+```
+---
+### Aufgabe 1
+
+1. Deklariere die Variable 'c' mit dem Datentyp Integer
+2. Initialisiere die Variable 'c' mit dem Wert 0
+3. Weise der Variablen 'c' dem Wert 16 zu
+
+---
+### Aufgabe 2
+1. Erstelle 3 Variablen x,y und z und initialisiere Sie auf beliebige Werte
+2. Erstelle 3 Variablen d,m,y und initialisiere Sie auf deinen Geburtstag
+
+-> Was fällt dabei auf?
+---
+### Einfache Datentypen
+
+Welche einfache Datentypen kennst du?
+
+Erstelle zu jedem eine Variable und einen entsprechenden Wert!
+
+Wie unterscheiden sich diese Datentypen?
+
+---
+### Unter der Haube (MALLOC)
+
+Java reserviert Speicher für jede deklarierte Variable. Die Menge an Speicher ist abhängig von dem jeweiligen Datentypen.
+```
+int i; // Reserviert 4 byte
+long l; // Reserviert 8 byte
+short s; // Reserviert 2 byte
+char c; // Reserviert 2 byte
+```
+---
+### Operatoren
+
+Auf Datentypen können verschiedene Operationen durchgeführt werden. Den wichtigsten Operator kennst du bereits, den Zuweisungsoperator:
+```
+int i = 10;
+```
+Der Zuweisungsoperator nimmt eine **Aussage** (rechts) und weist sie einer Variablen (links) zu. Aussagen und Zuweisungen werden in der **funktionalen** Programmierung sehr wichtig.
+
+---
+### Operatoren
+
+Auf numerischen Datentypen können eine Vielzahl an mathematischen Operationen durchgeführt werden
+```
+int i = 10;
+int j = 15;
+int k = i + j; // Addition
+int l = i - j; // Subtraktion
+int m = i * j; // Multiplikation
+int n = i / j; // Division
+int o = i % j; // Modulo
+int p = i++;   // Inkrementieren
+int q = i--;   // Dekrementieren
+```
+---
+### Operatoren
+
+Auf numerischen Datentypen können eine Vielzahl an logischen Operationen durchgeführt werden.
+```
+int a = 5;
+int b = 10;
+boolean c = a > b; // größer 
+boolean d = a < b; // kleiner 
+boolean e = a >= b; // größer gleich
+boolean f = a <= b; // kleiner gleich
+boolean g = a == b; // gleich
+boolean h = a != b; // ungleich
+
+
+```
+
+---
+### Aufgabe 3
+
+Erstelle einen Algorithmus, welcher überprüft, ob eine Zahl gerade oder ungerade ist. Wenn die Zahl gerade ist, speichere das Ergebnis in einer variablen 'boolean ist_gerade' ab.
+
+---
+### Operatoren 
+
+Auf boolean Werte können logische Operatoren angewendet werden:
+```
+boolean a = true;
+boolean b = false;
+boolean c = a || b; // logisches Oder
+boolean d = a && b; // logisches Und
+boolean e = a == b; // gleichheit
+boolean f = a != b; // ungleichheit
+boolean g = a | b; // bitweise oder
+boolean h = a & b; // bitweise und
+```
+
+---
+### Kontrollstrukturen
+
+Kontrollstrukturen geben dem Programm die Möglichkeit anhand von Daten (State) unterschiedliche Entscheidungen zu treffen
+``` java
+Scanner scanner  = new Scanner(System.in);
+int alter = scanner.nextInt();
+if(alter >= 10){
+	// Programm normal fortsetzen
+} else {
+	// Normalen programmfluss unterbrachen
+}
+```
+
+---
+### Aufgabe 4
+
+Erstelle ein Programm welches eine Zahl  vom Benutzer entgegennimmt.
+Wenn die Zahl durch 3 Teilbar ist, soll der String "fizz" auf die Kommandozeile ausgegeben werden.
+Wenn die Zahl durch 5 Teilbar ist, soll der String "buzz" auf die Kommandozeile ausgegeben werden.
+Wenn die Zahl durch 3 als auch durch 5 Teilbar ist, soll "fizzbuzz" auf die Kommandozeile ausgegeben werden
+
+---
+### Kontrollstrukturen
+
+Es gibt 2 fundamentale Kontrollstrukturen: Abzweigungnen und Schleifen
+```java
+// Beispiel einer Schleife
+boolean gesunder_maschinenzustand = true; 
+do{
+	// Programmfluss
+	gesunder_maschinenzustand = pruefeZustand();
+} while(gesunder_maschinenzustand);
+```
+
+---
+### Schleifen
+In Java gibt es 3 Schleifen: for, while, do-while:
+
+```java
+	for(int i = 0; i < 10; i++){
+		System.out.println(i);
+	}
+	int j = 0;
+	while(j < 10){
+		System.out.println(j);
+		j++;
+	}
+	int k = 0;
+	do{
+		System.out.println(k);
+		k++;
+	}while(k < 10);
+	
+```
+---
+
+### Aufgabe 5
+
+1. Erstelle ein Programm, welches die Zahlen 1 - 10 ausgibt.
+2. Erstelle ein Programm welches die Zahlen 1 - 100 ausgibt.
+3. Erstelle ein Programm welches alle geraden Zahlen von 1 bis 100 ausgibt.
+4. Erstelle ein Programm, welches alle Zahlen von 1 - 1000 ausgibt, die ein vielfaches von 13 sind.
+5. Erstelle ein Programm, welches alle Primzahlen von 1 - 100 ausgibt.
+---
+### Aufgabe 6
+
+Die Fachschaft Informatik lädt jedes Semester zur Bartour ein. Dafür muss die FSI einige Vorbereitungen Treffen, wie zum Beispiel Getränke einkaufen und diese zur Barrtour mitbringen. Die FSI rechnet dabei mit einer Getränkeflasche für drei Personen. Der FSI Bollerwagen™ kann dabei bis zu 30 Getränken tragen, bis sich Greg die Schulter auskugelt. Desshalb benötigt er des Öfteren Helfer, welche mit FSI Jutebeuteln™ weitere Flaschen tragen. Jeder Jutebeutel kann bis zu 6 Flaschen tragen. Erstelle ein Programm welches die Anzahl an geschätzten Studierenden als Eingabe annimmt und bestimmt, ob Greg Helfer benötigt und wenn ja wie viele!

PR1/PR1/lectures/Lektion 3.md

@@ -0,0 +1,68 @@
+---
+tags:
+  - Arrays
+---
+### Übungsaufgaben
+
+
+---
+
+### Tile, Pair und Familiarity
+Gegeben seien die Folgenden Klassen mit den Feldern
+```java
+class Tile{
+	private String name;
+	private String description;
+	private Pair position;
+	private Familiarity;
+}
+
+class Pair{
+	private int x;
+	private int y;
+}
+
+class Familiartiy{
+	private int movement;
+	private int talk;
+	private int interact;
+	private int fight;
+}
+```
+
+---
+### Aufgabe 1
+
+Übertrage die Klassen in dein Programm. Erstelle zu der Klasse Pair als auch zur Klasse Familiarity jeweils einen Konstruktor, welche alle Felder initialisiert.
+
+---
+### Aufgabe 2
+
+Erstelle zu allen Feldern der Klassen getter und setter methoden!
+
+---
+### Player und Action Klasse
+
+Die Klasse Player hat ein Feld welches ein Array des Typs Action besitzt:
+
+```java
+class Player{
+ private Action[] actions;
+ private Tilemanger tilemanager;
+}
+
+class Action{
+ private String action;
+ private int amount;
+}
+```
+---
+### Aufgabe 3
+
+1. Erstelle einen Konstruktor für die Klasse Action!
+2. Erstelle in der Klasse Player die methode setActions(int len), welches eine leeres Action array der länge int len erstellt!
+---
+
+### Tilemanger
+
+Die Klasse Tilemanger