dgdf
parent
fb40446e3b
commit
210e824032
|
|
@ -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;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -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));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue