From 210e824032d9f465af5716c594a11a2d133bc822 Mon Sep 17 00:00:00 2001 From: dgdf <@j> Date: Fri, 5 May 2023 15:29:28 +0200 Subject: [PATCH] 5.5.23 array fertig string --- ArrayExperimente.java | 9 +- Mitternachtsformelrechner.java | 6 +- Stringuebungen.java | 277 +++++++++++++++++++++++++++++++++ StringuebungenTest.java | 103 ++++++++++++ 4 files changed, 391 insertions(+), 4 deletions(-) create mode 100644 Stringuebungen.java create mode 100644 StringuebungenTest.java diff --git a/ArrayExperimente.java b/ArrayExperimente.java index 47d0f37..5bf81cb 100644 --- a/ArrayExperimente.java +++ b/ArrayExperimente.java @@ -160,8 +160,15 @@ public class ArrayExperimente */ public static int[] arrayUmdrehen(int[] array) { + int[] wendeArray = new int[array.length]; - return null; + for (int i=0; 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)); + } +}