From dfbf2239a8b52196051a1b7174b6d724608af75b Mon Sep 17 00:00:00 2001 From: jo <@> Date: Fri, 5 May 2023 15:29:05 +0200 Subject: [PATCH] inklzsive strings --- BlueJ | Bin 0 -> 772 bytes Eclipse | Bin 0 -> 784 bytes Filius | Bin 0 -> 704 bytes MikroSim | Bin 0 -> 676 bytes Stringuebungen.java | 277 ++++++++++++++++++++++++++++++++++++++++ StringuebungenTest.java | 103 +++++++++++++++ 6 files changed, 380 insertions(+) create mode 100644 BlueJ create mode 100644 Eclipse create mode 100644 Filius create mode 100644 MikroSim create mode 100644 Stringuebungen.java create mode 100644 StringuebungenTest.java diff --git a/BlueJ b/BlueJ new file mode 100644 index 0000000000000000000000000000000000000000..46ef3a76dee403aa5e3063d2d27e69702557f7c3 GIT binary patch literal 772 zcmZ9KIZOgk5Qg7!7)>;S6xu05Tm_?4Is)QvKx-X!p2G~3lkd?drE67 zL$sqX#Ky$LMjIO~EUd(TmRS%dc{|@f@9oUIqp0iq0(MYnm_7=o(X&z1;i4~DKVI!# z+U}D>CB(OcSqQrwAHXb}gjmurYFeq#()4cMM?*$&t&tQz~`i~kDamxx@GG+q?BhH^aEIg4!OG F=3i=tS*HL1 literal 0 HcmV?d00001 diff --git a/Eclipse b/Eclipse new file mode 100644 index 0000000000000000000000000000000000000000..b6a029c5845caa9ef640bd0390a96c09a4198b20 GIT binary patch literal 784 zcmZ9KyH5f^5XR?t_=uVSCTiztj8!k7*0`$QkGRR@_OAcE43ksW%DJ&sue=IWzhh~`iMC33^L$?F_VPl7p1@F0OTey|X!4)OG%4P8US*JI+b9(lHBEEsUDxwQ zrEb=W>T1TRh3MFy#6H&cS$B<*10dJSJtiaBa5k1&3C^dNBf>8JPJwVn&txDYn8 zx)UnMLs%ufzHL^^A!Do1p6woTil^ZNXI~q0TqN$=wlVQN?g9MMYPEP78^0<4F$r4{ zdBH_tANWLg3A``tQi+x%ffsxwaUb|v*bn{^4uGG8N5SvHDp-{~VQ^F8%43&(V5gn& NPogzhKMmd#{sqWzUH1S0 literal 0 HcmV?d00001 diff --git a/Filius b/Filius new file mode 100644 index 0000000000000000000000000000000000000000..b058889cf1da43b77e1c6054c7f68cac9c90c945 GIT binary patch literal 704 zcmY+Cze~eV5XUe5AyyPpJLqN**EAt*Z0n-wFC6OsU|JPpYg23m2L%N|M;8~tO~K8j ze}U-c;NU2@I12g?X#HODo}~x(?sJ!S_wL?H-S?XW*>(2rZ&d1d)HZ9ZH@ zo}ADl>MQsPCmO{9n1oRfb2^=t*Km8D-|ouTme=z3ySkOO(&mKN7sk>%?w-gUBjUpr zpnU!~G=|#mmv^9{AFJMu_&>rA&O(iKeC?2qUySwPZ64#_(@oBxyz8y z!TJpS9SjCskA?4>U$_={L~-ziU=`dKyaK)v9MOncqCgz{CgLjiQ*aWji9OR`*<=c= hins=@2{ys6*v6u~3|R%^`2v~w4*v^w=D`Od_YVYHN~-_> literal 0 HcmV?d00001 diff --git a/MikroSim b/MikroSim new file mode 100644 index 0000000000000000000000000000000000000000..a3c30027de7f24a24e32e15c76f53e19c1af547c GIT binary patch literal 676 zcmZvZy-UMj5XLY4kO~T^9dxsZjv*mUZ0ltDWtUDmINDal(6lLSL5B`Hxwr}QgE<$m|P?_KVan(H_ClXGPgu{3MCJ-cOR=e%k^=i*{Tiuw@Dt4peuG&rS&KMClofpn`BIxmUd<7y3 z^4*ook-RVRphp>}>+l^>!!uZen~TT&>(?1*66VJ^p3Qo@5CxG%DeAvV8YkMeovkHR zRf8QW)w4K8a znJF`^FQ!vwCYbAhYv3P=(a0M2QV}&~%)QyNYrx-KnEx}bWqX2u4~N4b=Woq_(cnW^ z6ujpn$>1}=%itryp(N3oXb=Stgf4?$1joTKac2trF7yQWOK=iwh&vkiR_N06AIo6; RI?tv*{qM=i9C$<2{s49wMr;58 literal 0 HcmV?d00001 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:

+ * Leo / Oel

+ * shit / hits / this

+ * SAU / USA

+ * ABITURE / BAU TIER

+ * STAUFENS / FAN-TUSSE

+ * Frodos Ehe / Sehr doofe

+ * + * 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)); + } +}