diff --git a/BlueJ b/BlueJ
new file mode 100644
index 0000000..46ef3a7
Binary files /dev/null and b/BlueJ differ
diff --git a/Eclipse b/Eclipse
new file mode 100644
index 0000000..b6a029c
Binary files /dev/null and b/Eclipse differ
diff --git a/Filius b/Filius
new file mode 100644
index 0000000..b058889
Binary files /dev/null and b/Filius differ
diff --git a/MikroSim b/MikroSim
new file mode 100644
index 0000000..a3c3002
Binary files /dev/null and b/MikroSim differ
diff --git a/Stringuebungen.java b/Stringuebungen.java
new file mode 100644
index 0000000..f61281a
--- /dev/null
+++ b/Stringuebungen.java
@@ -0,0 +1,277 @@
+import java.util.Scanner;
+
+/**
+ * Diese Klasse enthaelt Uebungsaufgaben fuer den Umgang mit Strings.
+ *
+ */
+public class Stringuebungen {
+
+ /**
+ * Diese Methode demonstriert grundlegend das Anlegen, Verketten
+ * und Ausgeben von Strings. Lest sie aufmerksam und durch
+ * probiert sie aus, bis ihr alles verstanden habt.
+ */
+ public static void basics_Demo() {
+ // So kann man eine String-Instanz anlegen:
+ String s1 = new String("Hallo!");
+
+ // Die folgende Kurzschreibweise ist aber allgemein ueblich:
+ String s2 = "Guten Morgen!";
+
+
+ // Erst nachdenken, dann ausprobieren: Was geben diese Zeilen aus?
+ System.out.println("Erster Test");
+ System.out.println(s1);
+
+ // Mit dem + kann man Strings ganz einfach verketten:
+ System.out.println("s1 ist " + s1);
+ System.out.println("s2 ist " + s2);
+
+
+ // String-Instanzen koennen nach der Instanziierung nie wieder
+ // veraendert werden (man sagt englisch "Strings sind immutable")
+ // -- die Referenzen allerdings schon:
+ s1 = s2; // s1 zeigt jetzt auf eine andere String-Instanz
+
+ // Man kann auch Variablen anderer Typen mit Strings verketten:
+ int x = 44;
+ System.out.println(x);
+ System.out.println("Die Variable x hat den Wert " + x);
+
+ // Dabei kann man nicht mit dem int anfangen; vor dem + muss immer
+ // ein String stehen, notfalls ein leerer:
+ System.out.println("" + x + " ist der Wert von x.");
+
+ // Von der Tastatur einzulesen ist leider recht hakelig: Ganz
+ // oben in der Datei muss "import java.util.Scanner;" stehen (s.o.),
+ // dann braucht man (einmal) eine Scanner-Instanz...:
+ Scanner tastaturleser = new Scanner(System.in);
+ // und dann erst kann man mit dem Scanner etwas von der Tastatur lesen:
+ System.out.println("Bitte gib' einen kurzen Text ein: ");
+ String s3;
+ s3 = tastaturleser.nextLine();
+
+ System.out.println("Deine Eingabe lautet \"" + s3 + "\"");
+
+ }
+
+ /**
+ * Diese Methode demonstriert die Benutzung der String-Methoden
+ * length(), indexOf(), charAt(), toUpperCase() und substring().
+ * Lest sie aufmerksam durch und probiert aus bis ihr alles
+ * verstanden habt.
+ */
+ public static void stringMethodenDemo() {
+ ///////////////////////////////////////////////////
+ ///////////// Die Methode length() ////////////////
+ // ermittelt die Laenge eines Strings:
+ String s = "Informatik";
+ System.out.println(s + " besteht aus " + s.length() + " Zeichen.");
+ System.out.println("Baden-Wuerttemberg".length());
+ System.out.println();
+
+ ///////////////////////////////////////////////////
+ ///////////// Die Methode indexOf() ////////////////
+ // ermittelt den Index der ersten Fundstelle, an
+ // der ein String innerhalb eines laengeren Strings vorkommt.
+ // Achtung: die Indizes beginnen bei 0, nicht bei 1 (wie bei Arrays)
+ String text = "Barbara mag aber Rhabarber statt Gelaber!";
+
+ // Erst ueberlegen, dann testen: Welche Fundstelle wird ausgegeben?
+ String gesucht = "bar";
+ int index = text.indexOf(gesucht);
+ System.out.println("In " + text + " steht " + gesucht
+ + " bei Index " + index);
+
+ gesucht = "ab";
+ index = text.indexOf(gesucht);
+ System.out.println("In " + text + " steht " + gesucht
+ + " bei Index " + index);
+
+ gesucht = "ber";
+ index = text.indexOf(gesucht);
+ System.out.println("In " + text + " steht " + gesucht
+ + " bei Index " + index);
+
+ // Man kann die Suche auch weiter hinten beginnen, hier bei 15:
+ gesucht = "ber";
+ index = text.indexOf(gesucht, 15);
+ System.out.println("In " + text + " steht " + gesucht
+ + " bei Index " + index);
+ System.out.println();
+
+ ///////////////////////////////////////////////////
+ ///////////// Die Methode charAt() ////////////////
+ // pickt einen einzelnen Buchstaben ("character") aus einem String.
+ // Der Java-Typ char ist dabei ein primitiver Typ (keine Klasse!).
+ text = "if-Schleifen gibt es nicht!";
+ char c = 'h';
+ char buchstabe = text.charAt(0);
+ System.out.println(buchstabe);
+
+ // Erst nachdenken, dann testen: Was wird ausgegeben?
+ System.out.println(text.charAt(3));
+
+ System.out.println(text.charAt(text.length() - 4));
+ System.out.println();
+
+ ///////////////////////////////////////////////////
+ ///////// Die Methoden toUpperCase() und toLowerCase
+ // erzeugen einen neuen String, der nur Gross- (bzw. Klein-)
+ // buchstaben enthaelt:
+ System.out.println("Aus " + text + " wird " + text.toLowerCase());
+ System.out.println("Aus " + text + " wird " + text.toUpperCase());
+ System.out.println();
+
+ ///////////////////////////////////////////////////
+ ///////// Die Methoden subString() schneidet aus einem
+ // String einen Teil heraus. Die Angabe von Startindex und
+ // dem (nicht mehr enthaltenen!) Endindex ist allerdings
+ // gewoehnungsbeduerftig:
+ System.out.print(text + "\nenthaelt ab Index 4 bis 7: ");
+ System.out.println(text.substring(4, 7));
+ }
+
+ /**
+ * Zaehlt die Vorkommen eines Buchstabens innerhalb eines Textes.
+ * @param text zu durchsuchender Text
+ * @param z Buchstabe, nach dem gesucht wird
+ * @return Zahl der Vorkommen von z in text
+ */
+ public static int anzahlVorkommen(String text, char z) {
+ /*# Geht mit einer Schleife den gesamten String durch;
+ * erhöhe den Zaehler jedesmal, wenn das Zeichen
+ * im String vorkommt; gebe dann den Wert des Zaehlers zurueck. */
+
+ int anzahl = 0;
+
+
+ return anzahl;
+ }
+
+
+ /**
+ * Dreht den uebergebenen String herum.
+ * Aus GEWINNER wird also RENNIWEG.
+ *
+ * @param text umzudrehender String
+ * @return den umgedrehten String
+ */
+ public static String rueckwaerts(String text) {
+ /*#Dies kann auf verschiedene Arten gelößt werden.
+ * Eine Möglichkeit ist, du gehst mit einer Schleife
+ * rueckwaerts durch den String
+ * das geht z.B. mit for(int i=s.length()-1; i>=0; i--) und
+ * haenge sie seine Buchstaben an den ergebnis-String an.
+ */
+
+ String ergebnis = "";
+
+
+ return ergebnis;
+ }
+
+ /**
+ * Ermittelt, ob ein Text ein Palindrom ist.
+ * Ein Text ist ein Palindrom, wenn er rueckwaerts wie vorwaerts
+ * gelesen das gleiche ergibt. Beispiele sind ANNA, OTTO, RENTNER, RELIEFPFEILER
+ * oder auch als Palindromsatz ERIKAFEUERTNURUNTREUEFAKIRE.
+ *
+ * Das Wort Bob gilt wegen der Gross-/Kleinschreibung
+ * hier NICHT als Palindrom.
+ *
+ * @param text Text, der untersucht werden soll.
+ * @return true, wenn der Text ein Palindrom ist; false sonst.
+ */
+ public static boolean istPalindrom(String text ) {
+ /*# Diese Aufgabe kann auf verschiedene Arten geloest werden.
+ * Eine nutzt auf elegante Weise anderen Code. Eine andere geht so:
+ * Durchlaufe den Text in einer Schleife und vergleiche den
+ * ersten mit dem letzten Buchstaben (im naechsten Durchlauf dann den
+ * zweiten mit dem vorletzten usw.).
+ */
+
+
+ return true;
+ }
+
+
+
+
+ /**
+ * Prueft, ob zwei Woerter Anagramme voneinander sind.
+ *
+ * Anagramme nennt man Woerter (oder Texte), die durch
+ * Umordnung ihrer Buchstaben auseinander hervorgehen.
+ * Folgende Wort- bzw. Textpaare sind beispielsweise
+ * Anagramme voneinander:<p>
+ * Leo / Oel<p>
+ * shit / hits / this<p>
+ * SAU / USA<p>
+ * ABITURE / BAU TIER<p>
+ * STAUFENS / FAN-TUSSE<p>
+ * Frodos Ehe / Sehr doofe<p>
+ *
+ * Zwei Saetze gelten auch dann als Anagramme, wenn dafür
+ * Leer- und Satzzeichen sowie Kleinschreibung ignoriert
+ * werden muessen wie bei "rauschen" / "Hase nur C".
+ *
+ * @param wort1 Der erste Text.
+ * @param wort2 Der zweite Text.
+ * @return ob die beiden Texte Anagramme voneinander sind.
+ */
+ public static boolean sindAnagramme(String wort1, String wort2 ) {
+ /*# Mache dir klar, dass es nur auf die Haeufigkeit der
+ * Buchstaben ankommt. Und dann mach dir keine
+ * unnoetige Arbeit, sondern benutze fertigen Code.
+ */
+
+ boolean ergebnis = true;
+
+
+ return ergebnis;
+ }
+
+
+ /**
+ * Für Experten: Die Caesar-Chiffre
+ * Die Funktion chiffriert einen Klartext mit der Caesar-Chiffre und
+ * dem angegebenen Schluessel.
+ * Der Klartext wird um "schluessel" Stellen im Alphabet
+ * weitergeschoben. Mit dem Schluessel 3 wird also
+ *
+ * aus "ABC" der Geheimtext DEF
+ * aus "VWXYZ" der Geheimtext YZABC
+ * aus "INFO" der Geheimtext LQIR
+ *
+ * Der Einfachheithalber dürft ihr annehmen, dass der zu verschlüsselnde
+ * Text "normalisiert" ist, d.h. nur Großbuchstaben enthält.
+ *
+ * @param klartext zu verschluesselnder Klartext
+ * @param schluessel Verschiebung im Alphabet (nach rechts)
+ * @return den verschluesselten Text (Geheimtext).
+ */
+ public static String caesarChiffrieren(String klartext, int schluessel) {
+ /*# Es gibt verschiedene Moeglichkeiten, die Verschiebung
+ * umzusetzen; eine besteht darin, alle Buchstaben einzeln in
+ * int-Werte umzurechnen. Man kann char-Werte mit einer Zuweisung wie
+ * int zahl = (int) charVariable;
+ * ganz einfach in int-Werte umwandeln. Dann rechnet man die eigentliche
+ * Caesar-Verschiebung aus und wandelt mit
+ * char c = (char) intVariable;
+ * zurueck in Buchstaben.
+ *
+ * Aber Achtung: 'A' hat nicht den Zahlenwert 0!
+ * Finde zuerst raus, welchen Zahlenwert A hat.
+ */
+
+ String geheimtext = "";
+
+
+ return geheimtext;
+ }
+
+
+
+
+}
diff --git a/StringuebungenTest.java b/StringuebungenTest.java
new file mode 100644
index 0000000..54a6343
--- /dev/null
+++ b/StringuebungenTest.java
@@ -0,0 +1,103 @@
+
+import static org.junit.Assert.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Die Test-Klasse Stringuebungen_MLTest.
+ *
+ * @author Urs Lautebach
+ * @version 2019-12
+ */
+public class StringuebungenTest {
+ /**
+ * Konstruktor fuer die Test-Klasse Stringuebungen_MLTest
+ */
+ public StringuebungenTest() {
+ }
+
+ /**
+ * Setzt das Testgerüst fuer den Test.
+ *
+ * Wird vor jeder Testfall-Methode aufgerufen.
+ */
+ @Before
+ public void setUp() {
+ }
+
+ /**
+ * Gibt das Testgerüst wieder frei.
+ *
+ * Wird nach jeder Testfall-Methode aufgerufen.
+ */
+ @After
+ public void tearDown() {
+ }
+
+ @Test
+ public void testAnzahlVorkommen() {
+ // Buchstaben, die ein- und mehrfach vorkommen:
+ assertEquals(3, Stringuebungen.anzahlVorkommen("Barbara", 'a'));
+ assertEquals(2, Stringuebungen.anzahlVorkommen("Barbara", 'r'));
+ assertEquals(1, Stringuebungen.anzahlVorkommen("Barbara", 'B'));
+
+ // kein Vorkommen:
+ assertEquals(0, Stringuebungen.anzahlVorkommen("Barbara", 'x'));
+
+ // letzten Buchstaben suchen:
+ assertEquals(1, Stringuebungen.anzahlVorkommen("Wald", 'd'));
+
+ // Im leeren String suchen (darf keinen Fehler ausloesen):
+ assertEquals(0, Stringuebungen.anzahlVorkommen("", 'a'));
+ }
+
+ @Test
+ public void testRueckwaerts() {
+ assertEquals("", Stringuebungen.rueckwaerts(""));
+ assertEquals("1", Stringuebungen.rueckwaerts("1"));
+ assertEquals("21", Stringuebungen.rueckwaerts("12"));
+ assertEquals("cba", Stringuebungen.rueckwaerts("abc"));
+ assertEquals("EISLAUF", Stringuebungen.rueckwaerts("FUALSIE"));
+ assertEquals("+3-2-1", Stringuebungen.rueckwaerts("1-2-3+"));
+ }
+
+ @Test
+ public void testIstPalindrom() {
+ assertFalse(Stringuebungen.istPalindrom("lalala"));
+ assertFalse(Stringuebungen.istPalindrom("Bob"));
+
+ assertTrue(Stringuebungen.istPalindrom("bob"));
+ assertTrue(Stringuebungen.istPalindrom("alalalalalalalala"));
+ assertTrue(Stringuebungen.istPalindrom("asDf...fDsa"));
+
+ assertTrue(Stringuebungen.istPalindrom(""));
+ assertTrue(Stringuebungen.istPalindrom("RELIEFPFEILER"));
+ assertTrue(Stringuebungen.istPalindrom("EINNEGERMITGAZELLEZAGTIMREGENNIE"));
+ }
+
+
+
+ @Test
+ public void testSindAnagramme() {
+ assertTrue(Stringuebungen.sindAnagramme("", ""));
+ assertTrue(Stringuebungen.sindAnagramme(" ", ""));
+ assertTrue(Stringuebungen.sindAnagramme("a", "a"));
+ assertTrue(Stringuebungen.sindAnagramme("abc", "bca"));
+ assertTrue(Stringuebungen.sindAnagramme("Staufens", "sauen fst"));
+ assertTrue(Stringuebungen.sindAnagramme("Baren bara", "ABarbaren"));
+ assertTrue(Stringuebungen.sindAnagramme("Frodos Ehe", "Sehr doofe"));
+
+ assertFalse(Stringuebungen.sindAnagramme("informatik", "kitamrofn"));
+ assertFalse(Stringuebungen.sindAnagramme("dudeldei", "leude"));
+ }
+
+ @Test
+ public void testCaesarChiffrieren() {
+ assertEquals("", Stringuebungen.caesarChiffrieren("", 3));
+ assertEquals("GUTENMORGEN", Stringuebungen.caesarChiffrieren("GUTEN MORGEN", 26));
+ assertEquals("KZQHEZQH", Stringuebungen.caesarChiffrieren("larifari", 25));
+ assertEquals("DEF", Stringuebungen.caesarChiffrieren("abc", 3));
+ assertEquals("FFFCCC", Stringuebungen.caesarChiffrieren("aaa xxx", 5));
+ }
+}