5.5.23

array fertig 
string

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<array.length;i++)
+        {
+            wendeArray[i]  = array[array.length -1 -i]; 
+        
+        }
+        
+        return wendeArray;
     }
 
     /**

Mitternachtsformelrechner.java

@@ -30,7 +30,7 @@ public class Mitternachtsformelrechner
         {
         double x1 = (-b/2*a);
         System.out.println ("x1=" + x1);
-        
+       }        
         double Zähler1 = (-b + Math.sqrt(d));
         double Zähler2 = (-b - Math.sqrt(d));
         double x1 = (-b + Math.sqrt(d)) / (2*a);
@@ -41,5 +41,5 @@ public class Mitternachtsformelrechner
         System.out.println (x2);
         
     }
-    
+   }
-}
+

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"); // "Erster Test"
+        System.out.println(s1); // "Hallo"
+
+        // 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;
+    }
+
+    
+
+    
+}

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