Zahlreiche Rechtschreibfehler korrigiert
ho
parent
d27d93dd68
commit
9432ea1802
|
|
@ -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...
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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:<p>
|
||||
* Leo / Oel<p>
|
||||
* shit / hits / this<p>
|
||||
* SAU / USA<p>
|
||||
* ABITURE / BAU TIER<p>
|
||||
* STAUFENS / FAN-TUSSE<p>
|
||||
* Frodos Ehe / Sehr doofe<p>
|
||||
* 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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue