From 9432ea1802e9e2af0249f94a14cfece6a802cda9 Mon Sep 17 00:00:00 2001 From: ho <@> Date: Fri, 15 May 2026 15:11:15 +0200 Subject: [PATCH] Zahlreiche Rechtschreibfehler korrigiert --- ArrayExperimente.java | 48 +++++++++---------- Stringuebungen.java | 106 +++++++++++++++++++++--------------------- 2 files changed, 77 insertions(+), 77 deletions(-) diff --git a/ArrayExperimente.java b/ArrayExperimente.java index 5d039fe..a6586ad 100644 --- a/ArrayExperimente.java +++ b/ArrayExperimente.java @@ -1,17 +1,17 @@ /** - * Uebungen mit Arrays. + * Übungen mit Arrays. * - * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchfuehren. + * Verschiedene Methoden, die einfache Operationen auf int-Arrays durchführen. * - * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch - * ueberpruefen + * Du kannst deine Lösungen mit der beigefügten Testklasse automatisch + * überprüfen * - Klicke mit der rechten Maustaste auf die ArrayExperimenteTest (grün) * -> "Alles Testen" * - Sobald du glaubst, eine Funktion fertig programmiert zu haben, - * startest du die Tests und ueberzeugst dich im Testergebnisfenster, - * dass der Test fuer diese Funktion erfolgreich durchgelaufen ist. - * - Falls er fehlschlaegt, kannst du dort auf den entsprechenden Test klicken + * startest du die Tests und überzeugst dich im Testergebnisfenster, + * dass der Test für diese Funktion erfolgreich durchgelaufen ist. + * - Falls er fehlschlägt, kannst du dort auf den entsprechenden Test klicken * und nachschauen, was genau fehlgeschlagen ist. * */ @@ -21,7 +21,7 @@ public class ArrayExperimente public static int nochnArray[]= new int[] {20,21,22,23,24,25,26}; /** - * Gibt das uebergebene Array auf der Konsole aus. + * Gibt das übergebene Array auf der Konsole aus. * @param array, das Array, das ausgegeben werden soll. */ public static void arrayAusgeben(int[] array) @@ -68,7 +68,7 @@ public class ArrayExperimente /** * Der Funktion wird ein Array übergeben. - * Die Funktion erhoeht nun jeden Eintrag um eins. + * Die Funktion erhöht nun jeden Eintrag um eins. * Es wird kein neues Array angelegt. * @param array Zu manipulierendes Array. Es darf nicht leer sein. */ @@ -81,10 +81,10 @@ public class ArrayExperimente /** - * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag". + * Die Funktion erhöht im ursprünglichen Array jeden Eintrag um einen "zuschlag". * Es wird kein neues Array angelegt. * @param array Zu manipulierendes Array. Es darf nicht leer sein. - * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert. + * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazu addiert. */ public static void addiereJeweilsD(int[] array, int zuschlag) { @@ -94,7 +94,7 @@ public class ArrayExperimente /** - * Ermittelt die Summe ueber alle Arrayelemente. + * Ermittelt die Summe über alle Arrayelemente. * @param array Array, das aufaddiert wird. * @returns Summe aller Arrayelemente. */ @@ -144,10 +144,10 @@ public class ArrayExperimente /** - * Ermittelt den Wert des groessten im Array enthaltenen Elements. + * Ermittelt den Wert des größten im Array enthaltenen Elements. * @param array Array, in dem gesucht wird. Es darf * nicht leer sein. - * @returns Den groessten vorkommenden Wert. + * @returns Den größten vorkommenden Wert. */ public static int maxWert(int[] array) { @@ -160,9 +160,9 @@ public class ArrayExperimente /** - * Ermittelt den Index des groessten im Array enthaltenen Elements. + * Ermittelt den Index des größten im Array enthaltenen Elements. * @param array Array, in dem gesucht wird. - * @returns Den Index des groessten vorkommenden Werts. + * @returns Den Index des größten vorkommenden Werts. */ public static int maxIndex(int[] array) { @@ -176,11 +176,11 @@ public class ArrayExperimente /** - * Ermittelt den Index des groessten im Array enthaltenen Elements. + * Ermittelt den Index des größten im Array enthaltenen Elements. * @param array Array, in dem gesucht wird. - * @returns Den Index des groessten vorkommenden Werts. + * @returns Den Index des größten vorkommenden Werts. */ - public static int maxIndexKuerzer(int[] aray) + public static int maxIndexKuerzer(int[] array) { // TODO: Formuliere diese Funktion als Einzeiler, indem du // Funktionen, die du oben schon geschrieben hast, geschickt aufrufst. @@ -195,13 +195,13 @@ public class ArrayExperimente /** * Erstellt ein neues Array, in dem die Elemente des * urspruenglichen Array in der umgekehrten Reihenfolge drin sind. - * @param array urspruengliches Array, darf nicht null sein + * @param array ursprüngliches Array, darf nicht null sein * @returns neues Array mit umgekehrter Reihenfolge. */ public static int[] arrayUmdrehen(int[] array) { - // fuer diese Funktion darf man ein neues Array anlegen, das - // die Eintraege von wendeArray in umgedrehter Reihenfolge enthaelt. + // für diese Funktion darf man ein neues Array anlegen, das + // die Einträge von wendeArray in umgedrehter Reihenfolge enthält. // TODO... @@ -219,8 +219,8 @@ public class ArrayExperimente */ public static void arrayUmdrehenInPlace(int[] array) { - // Diese Funktion loest die gleiche Aufgabe wie die obere, darf - // dafuer aber KEIN zusaetzliches Array benutzen, sondern muss + // Diese Funktion löst die gleiche Aufgabe wie die obere, darf + // dafür aber KEIN zusätzliches Array benutzen, sondern muss // (bis auf einzelne int-Variable) im wendeArray arbeiten. // TODO... } diff --git a/Stringuebungen.java b/Stringuebungen.java index f61281a..5ccf0a5 100644 --- a/Stringuebungen.java +++ b/Stringuebungen.java @@ -1,7 +1,7 @@ import java.util.Scanner; /** - * Diese Klasse enthaelt Uebungsaufgaben fuer den Umgang mit Strings. + * Diese Klasse enthält Übungsaufgaben für den Umgang mit Strings. * */ public class Stringuebungen { @@ -15,7 +15,7 @@ public class Stringuebungen { // So kann man eine String-Instanz anlegen: String s1 = new String("Hallo!"); - // Die folgende Kurzschreibweise ist aber allgemein ueblich: + // Die folgende Kurzschreibweise ist aber allgemein üblich: String s2 = "Guten Morgen!"; @@ -28,8 +28,8 @@ public class Stringuebungen { System.out.println("s2 ist " + s2); - // String-Instanzen koennen nach der Instanziierung nie wieder - // veraendert werden (man sagt englisch "Strings sind immutable") + // String-Instanzen können nach der Instanziierung nicht mehr + // verändert werden (man sagt englisch "Strings sind immutable") // -- die Referenzen allerdings schon: s1 = s2; // s1 zeigt jetzt auf eine andere String-Instanz @@ -42,12 +42,12 @@ public class Stringuebungen { // 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.), + // Um von Tastatur einzulesenmuss ganz + // oben in der Datei "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: "); + System.out.println("Bitte gib einen kurzen Text ein: "); String s3; s3 = tastaturleser.nextLine(); @@ -64,20 +64,20 @@ public class Stringuebungen { public static void stringMethodenDemo() { /////////////////////////////////////////////////// ///////////// Die Methode length() //////////////// - // ermittelt die Laenge eines Strings: + // ermittelt die Länge eines Strings: String s = "Informatik"; System.out.println(s + " besteht aus " + s.length() + " Zeichen."); - System.out.println("Baden-Wuerttemberg".length()); + System.out.println("Baden-Württemberg".length()); System.out.println(); /////////////////////////////////////////////////// ///////////// Die Methode indexOf() //////////////// // ermittelt den Index der ersten Fundstelle, an - // der ein String innerhalb eines laengeren Strings vorkommt. + // der ein String innerhalb eines längeren 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? + // Erst überlegen, dann testen: Welche Fundstelle wird ausgegeben? String gesucht = "bar"; int index = text.indexOf(gesucht); System.out.println("In " + text + " steht " + gesucht @@ -118,7 +118,7 @@ public class Stringuebungen { /////////////////////////////////////////////////// ///////// Die Methoden toUpperCase() und toLowerCase // erzeugen einen neuen String, der nur Gross- (bzw. Klein-) - // buchstaben enthaelt: + // buchstaben enthält: System.out.println("Aus " + text + " wird " + text.toLowerCase()); System.out.println("Aus " + text + " wird " + text.toUpperCase()); System.out.println(); @@ -127,21 +127,21 @@ public class Stringuebungen { ///////// 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: "); + // gewöhnungsbedürftig: + System.out.print(text + "\nenthält 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 + * Zählt die Vorkommen eines Buchstabens innerhalb eines Textes. + * @param text der zu durchsuchender Text + * @param z der Buchstabe, nach dem gesucht wird + * @return Zahl Anzahl, wie oft z in text vorkommt */ 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. */ + /*# Geh mit einer Schleife den gesamten String durch; + * erhöhe den Zähler jedesmal, wenn das Zeichen + * im String vorkommt; gebe dann den Wert des Zählers zurück. */ int anzahl = 0; @@ -151,18 +151,18 @@ public class Stringuebungen { /** - * Dreht den uebergebenen String herum. + * Dreht den übergebenen 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. + /*#Dies kann auf verschiedene Arten gelöst werden. * Eine Möglichkeit ist, du gehst mit einer Schleife - * rueckwaerts durch den String + * rückwärts 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. + * hänge die Buchstaben an den ergebnis-String an. */ String ergebnis = ""; @@ -173,8 +173,8 @@ public class Stringuebungen { /** * 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 + * Ein Text ist ein Palindrom, wenn er rückwärts wie vorwärts + * gelesen das Gleiche ergibt. Beispiele sind ANNA, OTTO, RENTNER, RELIEFPFEILER * oder auch als Palindromsatz ERIKAFEUERTNURUNTREUEFAKIRE. * * Das Wort Bob gilt wegen der Gross-/Kleinschreibung @@ -184,10 +184,10 @@ public class Stringuebungen { * @return true, wenn der Text ein Palindrom ist; false sonst. */ public static boolean istPalindrom(String text ) { - /*# Diese Aufgabe kann auf verschiedene Arten geloest werden. + /*# Diese Aufgabe kann auf verschiedene Arten gelöst 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 + * ersten mit dem letzten Buchstaben (im nächsten Durchlauf dann den * zweiten mit dem vorletzten usw.). */ @@ -199,31 +199,31 @@ public class Stringuebungen { /** - * Prueft, ob zwei Woerter Anagramme voneinander sind. + * Prüft, ob zwei Wörter Anagramme voneinander sind. * - * Anagramme nennt man Woerter (oder Texte), die durch + * Anagramme nennt man Wörter (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

+ * 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 + * Zwei Sätze gelten auch dann als Anagramme, wenn dafür * Leer- und Satzzeichen sowie Kleinschreibung ignoriert - * werden muessen wie bei "rauschen" / "Hase nur C". + * werden müssen 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 + /*# Mache dir klar, dass es nur auf die Häufigkeit der * Buchstaben ankommt. Und dann mach dir keine - * unnoetige Arbeit, sondern benutze fertigen Code. + * unnötige Arbeit, sondern benutze fertigen Code. */ boolean ergebnis = true; @@ -234,32 +234,32 @@ public class Stringuebungen { /** - * 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 + * Für Experten: Die Cäsar-Chiffre + * Die Funktion chiffriert einen Klartext mit der Cäsar-Chiffre und + * dem angegebenen Schlüssel. + * Der Klartext wird um "Schlüssel" Stellen im Alphabet + * weitergeschoben. Mit dem Schlüssel 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 + * Der Einfachheit halber 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 klartext zu verschlüsselnder Klartext * @param schluessel Verschiebung im Alphabet (nach rechts) - * @return den verschluesselten Text (Geheimtext). + * @return den verschlüsselten Text (Geheimtext). */ public static String caesarChiffrieren(String klartext, int schluessel) { - /*# Es gibt verschiedene Moeglichkeiten, die Verschiebung + /*# Es gibt verschiedene Möglichkeiten, 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 + * Cäsar-Verschiebung aus und wandelt mit * char c = (char) intVariable; - * zurueck in Buchstaben. + * zurück in Buchstaben. * * Aber Achtung: 'A' hat nicht den Zahlenwert 0! * Finde zuerst raus, welchen Zahlenwert A hat.