Ein Algorithmus erfüllt zwingend die folgenden Eigenschaften:
Allgemeinheit
Ein Algorithmus ist allgemeingültig, d. h. er löst eine Vielzahl von Problemen (der gleichen Art). Die Auswahl eines einzelnen konkreten Problems erfolgt über Eingabedaten oder Parameter. Ein Algorithmus zum Lösen quadratischer Gleichungen löst alle quadratische Gleichungen.
Eindeutigkeit
An jeder Stelle des Algorithmus muss eindeutig festgelegt sein, was zu tun ist und welcher Schritt der nächste ist. Dafür muss jede Anweisung unmissverständlich formuliert sein. Beim Wechseln der Reifen eines Autos sollten die Einzelschritte in der vorgeschriebenen Folge abgearbeitet werden.
Ausführbarkeit
Jede einzelne Anweisung eines Algorithmus muss vom Computer (vom Mensch) ausführbar sein. Aus mathematischer Sicht dürfte der Algorithmus z. B. keine Division durch 0 enthalten.
Endlichkeit (Finitheit)
Die Beschreibung eines Algorithmus besitzt eine endliche Länge, d. h. er besteht aus einer begrenzten Anzahl von Anweisungen mit begrenzter Länge. Zudem darf ein Algorithmus zu jedem Zeitpunkt für seine Daten nur endlich viel Platz belegen. (Wichtig für diese Eigenschaft ist die Abgrenzung zur Laufzeitlänge. Der Algorithmus des Heron-Verfahrens zum Berechnen einer Quadratwurzel ist sehr wohl endlich, kann jedoch für bestimmte Werte eine unendlich lange Laufzeit haben.
Schön wären für die Praxis noch die Eigenschaften:
Determiniertheit
Wird ein Algorithmus mit den gleichen Eingabewerten und Startbedingungen wiederholt, so liefert er stets das gleiche Ergebnis.
Terminierung
Der Algorithmus ist nach endlich vielen Schritten beendet, d. h. er liefert ein Ergebnis oder hält an.
Die obige intuitive Definition für den Begriff des Algorithmus ist zwar verständlich, aber mathematisch ungenau. In der kürzeren Geschichte der Mathematik und der theoretischen Informatik (zu Beginn des 20. Jahrhunderts) wurden eine Reihe von Ansätzen entwickelt, die zu einer genauen Definition führen sollten. Die gefundenen Methoden waren letztlich alle gleich leistungsfähig. So kann man z. B. mit Hilfe der Turing-Maschine (Church-Turing-These) den Begriff des Algorithmus wesentlich präziser formulieren.
]]>Um diese Parameter zu verwalten wird eine Zählvariable verwendet, meist i oder j. Die Zählvariable in der Zählschleife muss für diese extra initialisiert werden. Diese gilt dann nur innerhalb dieser Zählschleife. Eine solche Variable, die nur innerhalb eines bestimmten Anweisungsblockes gilt heißt lokale Variable. Im Gegensatz dazu nennt man Variable, die im gesamten Programm gelten, globale Variable.
Anfangsgeprüfte Schleife | Endgeprüfte Schleife | Zählschleife |
---|---|---|
Pseudocode | ||
i = start | i = start | für i von start bis end mit step |
Java-Quellcode | ||
i = start; | i = start; | for (int i=start;i<=end;i=i+step) { |
Struktogramm | ||
Beispiel (Ausgabe der Quadratzahlen bis 25) | ||
i = 1; | i = 1; | for (int i=1; i<=25; i++) { |
In einem Java-Programm soll eine Oberstufenklausur ausgewertet werden. Dafür sollen nach Eingabe der Anzahl der einzelnen Notenpunkte das Minimum, das Maximum, der Mittelwert und der Anteil negativer Noten angegeben werden. Zudem soll die Notenverteilung in einem (Sternchen-)Streifendiagramm ausgegeben werden.
Möchten wir für jede mögliche Note die Anzahl der zugehörigen Klausuren erfassen, benötigen wir 16 Variablen vom Datentyp int … note0, note1, …, note15. Nun ist sowohl die Eingabe als auch die Verarbeitung einer solchen Menge an Variablen sehr aufwändig … ganz abgesehen davon lassen sich Aufgaben finden, die eine wesentlich größere Anzahl an Variablen benötigen. Man könnte ja auch 100000 Messwerte erfassen – dafür bräuchte man dann 100000 Variablen und müsste z.B. alle diese 100000 Variablen addieren um später den Mittelwert zu berechnen … das dürfte extrem unkomfortabel sein.
Die Lösung für dieses Problem ist der Datentyp array. Ein array ist eine Reihe von Elementen (gleichen) Datentyps. Die einzelnen Elemente können über einen Index angesprochen werden. In Feldern kann man eine begrenzte Anzahl gleichartiger Daten speichern. Im Gegensatz zu einfachen Datentypen wie int, double, char oder boolean ist ein Feld ein strukturierter Datentyp.
Die Struktur eines Feldes mit n Elementen wird im Bild beispielhaft deutlich. Jedes Element kann einen Wert vom Datentyp int speichern.
Jede Zahl befindet sich in einer Zelle des Feldes. Alle Zellen sind gleich groß und können genau eine Zahl aufnehmen. Nicht alle Zellen des Feldes sind belegt, es können noch weitere Zahlen im Feld gespeichert werden. Das erste Feldelement hat den Wert 17 und den Index 0 (Merke: Computer zählen ab Null, Menschen normalerweise ab Eins), das zweite Element hat den Wert 64 und kann über den Index 1 angesprochen werden usw.. Ein Feld könnte man sich demzufolge als eine Vielzahl an Variablen vorstellen, die alle den gleichen Namen haben, sich nur durch ihren Index unterscheiden. Wir kennen so etwas ähnliches auch aus der Mathematik: Nullstellen einer Polynomfunktion werden alle mit x bezeichnet, erhalten von uns jedoch einen Index … also x_0, x_1, ...
Deklariert werden Arrays durch Kennzeichnung der Feldvariablen mit dem Klammernpaar [] hinter dem Datentyp.
int[] noten;
Zum Anlegen eines Arrays benötigt man die new-Methode. Ein Array ist der einzige Datentyp, der auf diese Art initialisiert werden muss, da Arrays in Java Objekte sind (im Gegensatz zu anderen Programmiersprachen). Im Beispiel wird das Array zur Aufnahme von maximal 16 Elementen initialisiert.
noten = new int[16];
Weiß man zu Beginn schon, wie groß das Array werden soll, kann Deklaration und Initialisierung in einem Schritt erfolgen:
int[] noten = new int[16];
Auf ein einzelnes Feldelement greift man nun über den Index zu. Im folgenden Beispiel wird dem Feldelement mit dem Index 7 die Zahl 5 zugewiesen, danach werden allen Zellen mit den Indizes 0 bis 6 Zufallszahlen von 0 … 4 zugewiesen und ausgegeben.
noten[7] = 5;
for (int i = 0; i < 7; i++) {
noten[i] = (int) (Math.random()*5);
System.out.println(noten[i]);
}
Zählschleifen sind für die Arbeit mit Arrays ein wichtiges Element, da sehr häufig das Feld durchlaufen werden muss (z. B. zum Einlesen oder Ausgeben der Elemente, zum Aufaddieren oder zur Suche nach dem Minimum, … ). Die Länge des Arrays (entspricht Anzahl der Elemente) kann mit array.length ausgelesen werden. Hier ein Beispiel für eine Anwendung:
public class BspArray {
static int[] werte = new int[10];
public static void gibWerteAus() {
System.out.print("Werte des Feldes:");
for (int i = 0; i < werte.length; i++) {
if (i % 5 == 0) {
System.out.println();
}
System.out.printf( "%6d", werte[i]);
}
}
public static int sucheMin() {
int m = werte[0];
for (int i = 1; i < werte.length; i++) {
if (werte[i] < m) {
m = werte[i];
}
}
return m;
}
public static void main(String[] args) {
for (int i = 0; i < werte.length; i++) {
werte[i] = (int) (Math.random()*1000);
}
gibWerteAus();
System.out.println("\nDer kleinste Wert ist " + sucheMin());
}
}
Sind die Werte (alle Werte) bei der Initialisierung des Arrays schon bekannt, kann man diese bei der Initialisierung als Liste in geschweiften Klammern angeben:
int[] primzahlen20 = {2, 3, 5, 7, 11, 13, 17, 19};
Zum Durchlaufen von Arrays kann man neben der for-Schleife auch eine foreach-Schleife nutzen. Diese Art der Schleife würde z.B. für die oben verwendete Methode sucheMin wie folgt aussehen:
public static int sucheMin() {
int m = werte[0];
for (int einWert : werte) {
if (einWert < m) {
m = einWert;
}
}
return m;
}
Vorteile der foreach-Schleife:
Nachteile der foreach-Schleife:
Als Zusammenfasung und Ergänzung …
]]>Der Datentyp char speichert genau ein einzelnes Zeichen. Dabei wird jedoch intern gar kein (Text-)Zeichen gespeichert sondern ein Zahlwert von 0 bis 65535. Dieser wird durch die Deklarierung als char dann jedoch als Zeichen des UTF-16-Zeichensatzes interpretiert.
Um zu wissen, welches Zeichen sich hinter welcher Zahl verbirgt, hilft uns z. B. die ASCII-Tabelle, die jedem Wert von 0 bis 255 ein Zeichen zuordnet:
Diese Codetabelle ist jedoch schon lange nicht mehr ausreichend, da dort nur die grundlegenden Zeichen enthalten sind. Einen Überblick über alle möglichen Zeichen des UTF-16-Zeichensatzes kann man hier einsehen: https://www.fileformat.info/info/charset/UTF-16/list.htm
Ein Zeichen vom Datentyp char wird in einfache Hochkomma gesetzt. Durch Casting mit (int) bzw. (char) können die einzelnen Werte in char-Zeichen bzw. char-Zeichen in die entsprechenden Werte umgewandelt werden.
public static void main(String[] args) {
System.out.println('A');
System.out.println(+'A'); // Umwandlung char -> int
System.out.println((int) 'A'); // Umwandlung char -> int
System.out.println((char) 70); // Umwandlung int -> char
}
Die Ausgabe würde hier so aussehen (65 ist der ASCII-Zahlwert des Zeichens ‚A‘):
A
65
65
F
Wichtig ist, klar zwischen einem Wert und einem Zeichen zu unterteilen:
public static void main(String[] args) {
System.out.println('1'); // Ausgabe: 1
System.out.println((int) '1'); // Ausgabe: 49 (ASCII-Wert des Zeichens 1)
}
Da char-Zeichen intern als Zahlen verarbeitet werden, kann man damit auch rechnen:
public static void main(String[] args) {
System.out.println( 'A' + 10 ); // Ausgabe: 75
System.out.println( 'A' + 'C' ); // Ausgabe: 132
System.out.println( "A" + "A" ); // Ausgabe: AA
System.out.println( 2 * 'A' ); // Ausgabe: 130
}
Der Datentyp String ist im Gegensatz zu den Datentypen int, double oder char kein einfacher Datentyp, sondern eine Klasse. Strings können u. a. als Feld von char-Zeichen aufgefasst werden. Für die Abfrage der einzelnen Werte an gewünschten Stellen des String können wir jedoch nicht den Feldoperator [] verwenden, sondern greifen auf die Funktion charAt(int index) der Klasse String zurück, welche das Zeichen an der Stelle index liefert:
public static void main(String[] args) {
String s = "Dies ist ein Beispieltext.";
char c = s.charAt(0);
System.out.println(c + " " + s.charAt(2)); // Ausgabe: "D e"
}
Da man so auf jedes einzelne Zeichen eines Strings zugreifen kann, sind verschiedene Aufgaben lösbar, wie z. B. das Zählen von gewünschten Buchstaben, das Ersetzen von Buchstaben oder auch das Manipulieren bzw. Entfremden von Texten.
Wie oben schon erwähnt, sind Strings Objekte, die von einer Klasse String abgeleitet werden. Über Objekte und Klassen informieren wir uns an anderer Stelle, jedoch müssen wir uns auf einige Besonderheiten einstellen.
Variablen konnten wir bisher sehr gut mit einander vergleichen, bei Strings ist dies etwas anders:
public static void main(String[] args) {
String person1 = new String ("Toni Stark");
String person2 = new String ("Toni Stark");
if (person1 == person2) {
System.out.println("Die Personen sind gleich!");
} else {
System.out.println("Die Personen sind verschieden!");
}
}
Dieser Vergleich erzeugt die Ausgabe Die Personen sind verschieden!. Woran liegt das?
Die beiden String-Objekte haben zwar den gleichen Wert, sind aber selbst nicht gleich. Für person1 und person2 wird jeweils ein Speicherplatz reserviert, in dem der Wert gespeichert wird. Die Namen person1 und person2 dienen jeweils als Zeiger auf den Speicherplatz, in dem das String-Objekt gespeichert wird. Wir möchten eigentlich den Wert vergleichen, testen oben jedoch, ob die Objekte die gleichen sind (genauer, ob die Zeiger auf den gleichen Platz im Speicher zeigen). Zum Vergleich der Werte müssen wir daher wieder auf eine Methode der String-Klasse zurückgreifen (equals). Die korrekte Bedingung müsste also so lauten:
public static void main(String[] args) {
String person1 = new String ("Toni Stark");
String person2 = new String ("Toni Stark");
if (person1.equals(person2)) {
System.out.println("Die Personen sind gleich!");
} else {
System.out.println("Die Personen sind verschieden!");
}
}
In den oberen Beispielen haben wir die Strings mit new erzeugt – das haben wir jedoch bisher nie gebraucht, weshalb also hier im Beispiel? Probieren wir es ohne das new:
public static void main(String[] args) {
String person1 = "Toni Stark";
String person2 = "Toni Stark";
if (person1.equals(person2)) {
System.out.println("Die Personen sind gleich!");
} else {
System.out.println("Die Personen sind verschieden!");
}
}
Hier bekommen wir (obwohl wir von verschiedenen Objekten ausgehen) die Ausgabe Die Personen sind gleich!. Das widerspricht offensichtlich unseren Überlegungen …
Die Lösung liefert der Literal Pool, ein in der Klasse String angelegter Speicher, in dem zur Laufzeit je ein Exemplar bereits erzeugter, lexikalisch identischer Strings vorgehalten wird, um Speicher und Performance zu sparen. Er ist zunächst leer. Wird ein String neu erzeugt, so wird zunächst in diesem Pool nachgesehen, ob ein identischer String dort bereits eingetragen ist. Ist dies der Fall, wird lediglich eine Referenz auf den dort registrierten erzeugt (und KEIN eigenes Objekt), ansonsten wird er dem Pool neu hinzugefügt. Im Beispiel zeigen somit person1 und person2 auf dasselbe Objekt, von dem im Literal Pool eine Referenz gespeichert ist.
Werden jedoch, wie beiden beiden Variablen person1 und person2 String-Objekte mit new erzeugt, so geschieht dies unabhängig vom Pool. Beide Objekte sind somit eigenständige Instanzen mit individuellen Speicherorten, deren Vergleich mit dem Vergleichsoperator false ergeben muss. Man erkennt hier, dass, wenn möglich, neue Strings somit ohne Verwendung des new-Operators erzeugt werden sollten.
Ein weiteres Problem gibt es bei Zuweisungen von Strings. Die Codezeilen …
public static void main(String[] args) {
String person1 = "Toni Stark";
String person2 = "Iron Man";
System.out.println(person1 + " " + person2);
person1 = person2;
System.out.println(person1 + " " + person2);
}
… führen zu der Ausgabe …
Toni Stark Iron Man
Iron Man Iron Man
Was ist passiert? Mit der Anweisung person1 = person2 wird (der Zeiger auf) das Objekt person1 durch (den Zeiger auf) das Objekt person2 überschrieben. Beide verweisen nun auf den gleichen Speicherplatz, nämlich auf den von person2. Noch wichtiger … die Werte von person1 sind verloren.
Zum Kopieren des Inhaltes eines Strings in einen anderen verwenden wir daher die Methode valueOf (es gibt aber auch andere Möglichkeiten):
person1 = String.valueOf(person2);
Da Strings Objekte der Klasse String sind, verfügen alle Strings über eine Vielzahl von Methoden, von denen die wichtigsten im Folgenden vorgestellt werden sollen.
… gibt die Länge eines Strings an.
String text = "Informatik ist toll";
int l = text.length(); // l = 19
… liefert das Zeichen als Charakter an der Stelle index.
String text = "Informatik ist toll";
char c = text.charAt(5); // c = 'm'
… kopiert aus einem String einen Teilstring heraus. i bezeichnet den Index des ersten Zeichens, j-1 des Index des letzten Zeichens.
String text = "Informatik ist toll";
String s1 = text.substring(3,7); // s1 = "orma"
… vergleicht den Inhalt zweier Strings.
String text1 = "Informatik ist toll";
String text2 = "Informatik ist TOLL";
boolean gleich = text1.equals(text2); // gleich = false
… wandelt alle Zeichen des Strings in Großbuchstaben / Kleinbuchstaben um.
String text1 = "Informatik ist toll";
text1 = text1.toUpperCase(); // text1 = "INFORMATIK IST TOLL"
… stellt eine alphabetische Reihenfolge in Bezug auf s fest.
String n1 = "Anton";
String n2 = "Berta";
i = n1.compareTo(n2); // i = -1 (n1 vor n2)
i = n2.compareTo(n1); // i = 1 (n2 nach n1)
i = n1.compareTo(n1); // i = 0 (n1 gleich mit n1)
compareTo() gibt es auch in der Variante compareToIgnoreCase(), bei der die Groß- und Kleinschreibung ignoriert wird.
Die Methode indexOf sucht das erste Vorkommen der Zeichenkette s innerhalb des String-Objekts. Wird s gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens zurück, andernfalls wird -1 zurückgegeben. Die Methode gibt es auch in einer Version, die einen Parameter vom Typ char akzeptiert. In diesem Fall sucht sie nach dem ersten Auftreten des angegebenen Zeichens.
Die zweite Variante von indexOf arbeitet wie die erste, beginnt mit der Suche aber erst ab Position fromIndex. Wird s beginnend ab dieser Position gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens, andernfalls -1. Auch diese Methode gibt es in einer Variante, die anstelle eines String-Parameters ein Argument des Typs char erwartet. Ihr Verhalten ist analog zur vorherigen.
Die Methode lastIndexOf sucht nach dem letzten Vorkommen des Teilstrings s im aktuellen String-Objekt. Wird s gefunden, liefert die Methode den Index des ersten übereinstimmenden Zeichens, andernfalls -1. Wie die beiden vorherigen Methoden gibt es auch lastIndexOf wahlweise mit einem Parameter vom Typ char und mit einem zweiten Parameter, der die Startposition der Suche bestimmt.
String text = "Informatik ist toll";
int i1 = text.indexOf("ist"); // i1 = 11
int i2 = text.indexOf('o',10); // i2 = 16
int i3 = text.lastIndexOf("t"); // i3 = 15
Mit Hilfe von replace wird eine zeichenweise Konvertierung des aktuellen String-Objekts durchgeführt. Dabei wird jedes Auftreten des Zeichens oldchar durch das Zeichen newchar ersetzt.
String text = "Informatik ist toll";
text = text.replace('o','@'); // text = "Inf@rmatik ist t@ll"
Implementieren Sie ein Java-Programm, welches aus den einzugebenden Werten für die Kanten die Summe der Kantenlängen, die Oberfläche und das Volumen des Quaders berechnet.
Nach Eingabe der notwendigen Daten soll der Flächeninhalt eines Kreisrings berechnet werden.
Von einem geraden Kegel sind der Radius r und die Höhe h bekannt. Daraus sind die Seitenlinie s, die Oberfläche O und das Volumen V zu berechnen.
Eine Firma bietet folgenden Handytarif an:
Implementieren Sie ein Java-Programm welches die monatlichen Kosten berechnen kann.
Eine Maklerfirma verkauft Grundstücke. Schreibe ein Programm, das für ein rechteckiges Grundstück die Längen der Seiten (in Meter) und den Quadratmeterpreis einliest. Gib dazu eine Rechnung auf dem Bildschirm aus, die die eingegebenen Daten, den Grundstückspreis, die Maklergebühr von 3%, die Mehrwertsteuer, sowie den Gesamtbetrag enthält.
Alle Programme – auch die einfachen – sollen möglichst benutzerfreundlich gestaltet werden …
Implementieren Sie ein Programm, das den Namen, das aktuelle Jahr und das Geburtsjahr des Benutzers einließt. Dann soll das das Alter des Benutzers ausgegeben werden. Dazu muss noch in Erfahrung gebracht werden, ob der Benutzer in diesem Jahr schon Geburtstag hatte. Der Dialog, der bei der Ausführung des Programms entsteht, könnte zum Beispiel so aussehen:
Hallo, wie heißt du?
Mia
Welches Jahr haben wir, Mia?
Jahr: 2005
In welchem Jahr bist du geboren?
Jahr: 2001
Hattest du dieses Jahr schon Geburtstag?
Für ja gebe 0 für nein 1 ein: 0
Mia, du bist 4 Jahre alt.
Geschäftsführer A. Bzocker benötigt ein Programm zur Wochenlohnberechnung. Als Eingaben sind die Anzahl der Arbeitsstunden, die Anzahl der Überstunden (die aus Sicht des Geschäftsführers nicht bezahlt werden sollten … aber müssen!!!) und der Stundenlohn. Für Überstunden muss zudem ein Zuschlag von 20% auf den Stundenlohn gewährt werden.
Beauftragte der ÜWAG lesen einmal im Jahr den Zählerstand des Stromzählers ab. Davon ausgehend wird der Verbrauch des letzten Jahres berechnet. Mit dem derzeitigen kWh-Preis können die Kosten berechnet werden. Da im letzten Jahr ein monatlicher Abschlag gezahlt wurde muss nun die Differenz beglichen werden. Auf der Basis der Kosten für das letzte Jahr wird nun der Abschlag für das nächste Jahr berechnet.
1. Geben Sie mit Hilfe von Java das folgende ASCII-Bildchen aus:
_____________
< Java rocks! >
-------------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||
2. Ändern Sie das Programm so ab, dass der Text vorher eingelesen wird.
3. Erstellen Sie eigene Piktogramme.
Erstellen Sie einen Kassenbon. Geben Sie dazu 4 verschiedene Waren ein, dazu die Anzahl und den Einzelpreis. Danach sollte die Summe ausgegeben werden und der User entscheidet, wie viel Geld er gibt. Danach wird der Kassenbon mit dem Restgeldbetrag ausgegeben, z. B.:
Wurst 1 x 4.20 EUR
4.20 EUR
Käse 1 x 2.30 EUR
2.30 EUR
Brot 1 x 2.10 EUR
2.10 EUR
DVD 2 x 12.00 EUR
24.00 EUR
----------------------------------
Gesamt 32.60 EUR
Gegeben 50.00 EUR
Zurück 17.40 EUR
In einem Baumarkt werden folgende Preise verlang:
• 5 Cent pro Schraube
• 3 Cent pro Mutter
• 1 Cent pro Unterlegscheibe
Implementieren Sie ein Programm, welches den Anwender nach der Anzahl der Schrauben, Muttern und Unterlegscheiben fragt und dann den Gesamtbetrag berechnet und ausgibt.
Zusätzlich überprüft das Programm die Bestellung. Es dürfen nicht mehr Schrauben als Muttern bestellt werden. In diesem Fall gibt das Programm die Meldung aus „Kontrollieren Sie Ihre Bestellung!“, andernfalls gibt
das Programm aus „Die Bestellung ist okay.“ aus. In jedem Fall wird der Gesamtbetrag ausgegeben.
Geben Sie an, welchen Wert der gegebene logische Ausdruck (für a = 4 und b = 1) hat.
Implementiere ein Programm, welches eine integer-Zahl einliest und danach ausgibt, ob diese positiv, negativ oder 0 ist. Modellieren Sie das Struktogramm mit dem Struktogrammeditor.
Zusatz: Gib aus, ob diese Zahl gerade oder ungerade ist. (Informationen findest du hierfür im Internet)
Beim Online-Kaufhaus iKauf zahlt man bei einem Auftragswert unter 100 € eine Versandkostenpauschale von 3,50 €. Ab 100 € entfällt die Pauschale. Zudem erhält man ab 200 € Auftragswert einen Rabatt von 2 %. Nach Eingabe des Auftragswertes soll der Rechnungsendbetrag ermittelt werden.
Von einem Dreieck wird die Länge der drei Seiten angegeben. Von einem Programm sind die folgenden Entscheidungen zu treffen:
Implementieren Sie ein geeignetes (oder drei kleine) Java-Programm, welches diese Aufgabe löst.
Ein Kunde, der sich gerade am Bankautomat mit seiner PIN legitimiert hat, hat ein Guthaben von 136.34 €. Das Konto kann nicht überzogen werden. Schreibe ein Programm, das einließt, wie viel Geld dieser Kunde abheben möchte, und nur dann Geld ausgibt, wenn dieser Betrag das Guthaben nicht übersteigt.
Modellieren Sie auch das Struktogramm mit dem Struktogrammeditor.
Beispiele:
Ihr Guthaben beträgt 136.34 Euro.
Wieviel Geld wollen Sie abheben? 200
Keine Auszahlung! Dieser Betrag übersteigt Ihr Guthaben.
Ihr Guthaben beträgt 136.34 Euro.
Wieviel Geld wollen Sie abheben? 100
Es werden 100 Euro ausgezahlt.
In ein Java-Programm sollen drei Werte einer Person eingelesen werden: das Alter, der Namen und das Geschlecht. Überlegt euch, von welchem Datentyp die drei Variablen sein müssen.
Fügt eurem Programm dann eine Fallunterscheidung hinzu, die eine Begrüßung für die genannte Person ausgibt. Der Begrüßungstext unterscheidet sich für Personen, die männlich oder weiblich sind und unterscheidet zwischen Erwachsenen und Kindern. Folgende Begrüßungen sollen ausgegeben werden:
Guten Tag Herr <name>! ... für erwachsene Männer
Guten Tag Frau <name>! ... für erwachsene Frauen
Hallo <name>! ... für Mädchen und Jungen unter 18 Jahren
Implementiert ein Java-Programm, welches mit einer Wahrscheinlichkeit von 39% „GEWONNEN!!!“ und sonst „VERLOREN“ ausgibt.
Hinweis: Eine Zufallszahl zufall zwischen mit 0 \leq zufall < 1 kann wie folgt erzeugt werden:
double zufall = Math.random();
Eine Erweiterung der Aufgabe 7 …
Zwei Spieler wählen jeweils einen Wert zwischen 1 und 100. Dann wird eine zufällige weitere Zahl zwischen 1 und 100 ermittelt. Der Spieler, dessen Nummer am nächsten an der zufälligen Zahl liegt, hat gewonnen. Liegen beide Spieler gleich weit entfernt, dann gibt es ein Unentschieden.
Hinweis: Eine ganzzahlige Zufallszahl zufall zwischen mit 1 \leq zufall < 100 kann wie folgt erzeugt werden:
int zufall = (int) (Math.random()*100 + 1);
Das Ergebnis könnte wie folgt aussehen:
Tipp Spieler 1: 34
Tipp Spieler 2: 76
Zufallszahl: 33
Spieler 1 hat gewonnen.
Gegeben ist eine lineare Gleichung der Form y = ax + b. Nach Eingabe der Parameter a und b und des Funktionswertes y soll der Wert für die Variable x berechnet werden.
Gegeben ist eine quadratische Gleichung in der Form y = ax² + bx + c. Gesucht ist ein Java-Programm, welches nach Eingabe der Parameter a, b und c die Lösungen bzw. geeignete Bemerkungen ausgibt.
Gegeben ist das folgende (fehlerhafte Java-Programm):
public class Beispiel01 {
public static void main(String[] args) {
int kundennummer, anzahl;
double preis, gesamtpreis;
System.out.print("Geben Sie Ihre Kundennummer ein: ");
Input.readInt(kundennummer);
System.out.print("Geben Sie die Anzahl ein: ");
System.out.print("Geben Sie den Stückpreis ein: ");
Input.readDouble(preis);
preis * anzahl = gesamtPreis;
if (kundennummer < 100) {
gesamtPreis = gesamtPreis * 0.95
}
if (anzahl < 20) {
gesamtPreis = gesamtPreis + 15;
} else
if (anzahl < 50) {
gesamtPreis = gesamtPreis + 5;
}
}
}
In einem Werkzeugladen werden folgende Preise verlangt
Implementieren Sie ein Java-Programm, das den Anwender nach der Anzahl der Schrauben, Muttern und Unterlegscheiben fragt und dann den Gesamtbetrag berechnet und ausgibt.
Zusätzlich überprüft das Programm die Bestellung. Es ist normalerweise ein Fehler, wenn mehr Schrauben als Muttern bestellt werden. In diesem Fall gibt das Programm die Meldung aus „Kontrollieren Sie Ihre Bestellung!“. Andernfalls gibt das Programm aus „Die Bestellung ist okay.“ In jedem Fall wird der Gesamtbetrag ausgegeben.
Ein Versandgeschäft berechnet bei Aufträgen bis zu 100 € einen Verpackungszuschlag von 3 € und einen Portoanteil von 2 €. Bei Rechnungsbeträgen von 100 € bis zu 200 € liefert es zwar portofrei, berechnet jedoch einen Verpackungszuschlag von 2 €. Kauft der Kunde für 200 € und mehr, so entstehen ihm keine zusätzlichen Kosten.
Ein Schaltjahr findet alle 4 Jahre statt … leider falsch. Für die genaue Regelung gibt es einige Verfeinerungen. Das abgebildete Struktogramm stellt die genaue Schaltjahrregelung dar.
Implementieren Sie mithilfe des gegebenen Struktogramms ein Java-Programm, welches für ein eingegebenes Jahr angibt, ob es ein Schaltjahr ist.
Hinweis: 4 \mid \text{jahreszahl} bedeutet „4 teilt die jahreszahl“, d. h. man müsste testen, ob die Jahreszahl durch 4 ohne Rest teilbar ist. (Kleine Tipps und Tricks)
Ein Programm soll helfen, zu entscheiden, ob eine Person über-, unter- oder normalgewichtig ist. Als Eingabedaten werden Geschlecht, Alter, Gewicht und Größe verlangt.
Als normalgewichtig bezeichnet man Personen, deren Gewicht in Kilogramm gleich der Körpergröße über 100 cm ist. Entsprechend ergeben sich die Unter- bzw. Übergewichtigen.
Als Toleranzgrenzen sind bei Frauen +4% bis -7% und bei Männern +5% bis -5% Abweichung von den Sollwerten zugelassen.
Alle Aussagen treffen erst für Personen zu, deren Wachstum beendet ist, d. h. die älter als 17 Jahre und größer als 1,20 m sind. Bei anderen Personen können keine Angaben gemacht werden.
Implementieren Sie ein Java-Programm für das gegebene Problem.
In einem Konsolenprogramm sollen drei Zahlen eingegeben werden. Das Programm soll die größte der drei Zahlen ausgeben.
Erweitern Sie die Ausgabe in der Form, dass die Zahlen der Größe nach geordnet ausgegeben werden.
Implementieren Sie als Erweiterung auch ein GUI-Programm zu dieser Problemstellung.
Implementiere ein Java-Programm, welches für einen eingegebenen Wert x den entsprechenden Funktionswert ausgibt.
Zwei Geraden g und h werden durch die Gleichungen {g(x) = y= ax + b} und {h(x) = y= cx + d} beschrieben.
Implementieren Sie ein Java-Programm, welches mit Hilfe der eingegebenen Koeffizienten a, b, c und d den Schnittpunkt der beiden Geraden berechnen kann. Dabei sollen möglichst alle Lagebeziehungen zweier Geraden zueinander berücksichtigt
werden. Erstellen Sie vorher ein Struktogramm.
Implementieren Sie ein Programm, welches zu einem vorgegebenen Geldwert ausrechnet, mit welchen Geldscheinen man ihn auszahlen kann. Zur Auszahlung stehen Scheine im Wert von 500, 200, 100, 50, 20, 10
und 5 Euro zur Verfügung.
Hinweis: Für integer-Variablen gibt es zwei mathematische Operationen für die Division, da wir ja auf Kommazahlen verzichten müssen:
Die Programmausgabe könnte so aussehen:
Wie groß ist der Geldbetrag: 2215
500er-Scheine: 4
200er-Scheine: 1
100er-Scheine: 0
50er-Scheine: 0
20er-Scheine: 0
10er-Scheine:1
5er-Scheine: 1
Mithilfe der verschiedenen Schleifenarten sollen folgende Zahlenreihen ausgegeben werden (innerhalb der Schleife darf nur eine Ausgabeanweisung stehen!):
In einem Programm soll (zwingend) eine Zahl eingegeben werden, die …
Implementieren Sie jeweils ein Java-Programm, welches den Nutzer zwingt eine entsprechende Zahl einzugeben und bei Erfolg die Anzahl der Versuche ausgibt.
In einem Programm soll ein User so lange Zahlen eingeben, bis er eine negative Zahl eingibt. Nach jeder Eingabe soll das Programm jeweils die derzeitige Summe und Anzahl aller Zahlen ausgeben.
Ermitteln Sie mit Papier und Bleistift (TRACE-Tabelle) was das folgende Programm ausgibt:
public static void main(String[] args) {
int y;
int x = 1;
int total = 0;
do {
y = x * x;
System.out.println(y);
total = total + y;
x = x + 1;
} while (x <= 5);
System.out.println("Total ist: " + total);
}
Implementieren Sie das Programm neu, sodass eine anfangsgeprüfte Schleife bzw. eine Zählschleife verwendet werden.
Ein Spieler soll eine (zufällig gewählte) Zahl zwischen 1 und 100 erraten. Das Programm soll jeweils die Meldungen „Die Zahl ist zu groß“, „Die Zahl ist zu klein“ bzw. „Treffer“ ausgeben.
In diesem Programm muss eine zufällige Zahl (zwischen 1 und 100) bestimmt werden. Dafür steht in Java folgende Funktion zur Verfügung:
int zufallszahl;
zufallszahl = (int) ((Math.random() * 100)) + 1;
System.out.println(zufallszahl);
Math.random() ermittelt eine Zufallszahl vom Datentyp double zwischen 0 und <1. Mit 100 multipliziert entstehen somit Zufallszahlen zwischen 0 und <100. Addiert man 1 und wandelt die Zahl mit (int) in eine Integer-Zahl um, erhält man nunmehr Zufallszahlen von 1..100.
Erweitern Sie das Programm so, dass auch die Anzahl der Versuche ausgegeben wird.
Ein Würfel soll 10x gewürfelt werden. Implementieren Sie ein Programm, welches die Summe der Augenzahlen angibt.
Ein Java-Programm soll das mehrfache Würfeln mit einem Würfel simulieren.
Ein Programm soll dem Anwender die Möglichkeit geben, eine beliebige vom Anwender einzugebende Anzahl vierstelliger Zufallszahlen…
Implementieren Sie ein Java-Programm, welches diese Aufgabe bearbeitet.
Heron von Alexandria (genannt Mechanicus) war ein Mathematiker und Ingenieur, der vermutlich im 1. Jahrhundert lebte. Bekannt sind vor allem seine Ausführungen zu automatischen, teilweise sogar schon programmierbaren Geräten und der Ausnutzung von Wasser, Luft und Hitze als treibende Kraft. Hier sind insbesondere die Erfindung der Aeolipile, auch Heronsball genannt, und der Heronsbrunnen zu nennen (wikipedia).
Außerdem entwickelte er einen Algorithmus, mit dem man für eine beliebige Zahl die Quadratwurzel auf eine beliebige Genauigkeit berechnen kann … das Heron-Verfahren:
Die Grundidee für dieses Verfahren basiert auf der Frage, wie ein Rechteck in ein flächengleiches Quadrat umgewandelt werden kann … dafür wird die Seitenlänge des Quadrats benötigt.
Das Nim-Spiel ist ein Spiel für zwei Personen.
Gegeben ist ein Haufen von 13 Streichhölzern. Abwechselnd nehmen zwei Personen 1, 2 oder 3 Streichhölzer. Derjenige, der den Haufen leerräumt, hat gewonnen.
Erstellen Sie einen Algorithmus für das oben beschriebene Einstiegsproblem (Struktogramm). Es kann helfen, wenn man das Spiel selbst einmal durchspielt.
Implementieren Sie diesen Algorithmus in einem Java-Programm so, das zwei Spieler gegeneinander spielen können,
Mögliche Erweiterungen:
Ein Polynom 3. Grades hat die allgemeine Form f(x) = y = ax³ + bx² + cx + d.
Implementieren Sie ein Java-Programm, welches für die eingegebenen Parameter a, b, c und d eine Wertetabelle für dieses Polynom ausgibt. Dafür müsste der User natürlich noch den Startwert, den Endwert und die Schrittweite eingeben.
Das Ergebnis soll dann tabellarisch ausgegeben werden. Hier könnten formatierte Strings helfen: HIER gibt es Hilfe.
Ein Java-Programm zeichnet nach Eingabe zweier Parameter a und b verschiedene Figuren aus Sternchen. Im unten gegebenen Quellcode ist (bisher) nur die erste Figur implementiert. In den Grafiken sind alle vier zu realisierenden Figuren (für zwei verschiedene Programmdurchläufe) zu sehen.
Ergänzen Sie den gegebenen Quellcode, so dass alle vier Figuren ausgegeben werden.
public class Sternchen {
public static void main(String[] args) {
System.out.print("1. Zahl: ");
int a = Input.readInt();
System.out.print("2. Zahl: ");
int b = Input.readInt();
System.out.println();
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
System.out.print("*");
}
System.out.println();
}
...
}
}
Entwickeln Sie ein Programm, welches die Primfaktoren einer Zahl berechnet. Die Primfaktoren sollen dabei aufsteigend und mit ihrer Häufigkeit ausgegeben werden. Die Ausgabe soll in dem in den Beispielen angegebenen Format erfolgen (d.h. mit „*“ und „^“).
Beispiele:
20 = 2^2 * 5
256 = 2^8
6534 = 2 * 3^3 * 11^2
13332 = 2^2 * 3 * 11 * 101
Hinweis: Primfaktoren kann man ermitteln, indem nacheinander versucht wird, durch mögliche Primfaktoren zu dividieren (ohne dass ein Rest bleibt). Um die Primfaktoren nicht ermitteln zu müssen (kompliziert!), werden alle Zahlen durchprobiert (aufsteigend bei 2 beginnend). Hat man nämlich alle kleineren Zahlen schon durchprobiert, so bleiben nur die Primfaktoren für eine Division übrig.
… noch ein Hinweis: Manchmal ist es sinnvoll, Schleifen zu schachteln …
]]>Implementieren Sie ein Java (Konsolenprogramm), welches zwei Werte a und b einliest und danach:
dieser Zahlen bestimmt und ausgibt.
Implementieren Sie das Programm einmal, indem Sie Methoden ohne Rückgabewert nutzen und einmal, indem Sie Methoden mit Rückgabewert verwenden. Im ersten Fall sollen die Ergebnisse also innerhalb der Methoden ausgegeben werden, im zweiten in der Hauptmethode main.
Implementieren Sie jeweils ein Java-Programm, welches für eine eingegebene Zahl die Quersumme, die Anzahl der Ziffern der Zahl und die Fakultät der Zahl bestimmt.
Verwenden Sie für die Bestimmung der Werte Methoden mit Rückgabewert, d.h. die Ergebnisse sollen in der main-Methode ausgegeben werden.
Analysieren Sie die gegebenen Quelltexte.
public class Print {
public static void main(String[] arguments) {
print(1, "Martin");
print(2, "Arthur");
print(3, "Florian");
print(4, "Robert");
}
public static void print(int zahl, String name) {
System.out.println(zahl + ": " + name);
}
}
public class ReturnDouble {
public static void main(String[] arguments) {
System.out.println(gibMirNeZahl());
}
public static double gibMirNeZahl() {
return 15.3;
}
}
public class ReturnBoolean {
public static void main(String[] arguments) {
System.out.println(mathematik(1, 2));
System.out.println(mathematik(1, 5));
System.out.println(mathematik(3, 4));
}
public static boolean mathematik(int argument1, int argument2) {
return (argument1 + 5) < (argument2 * 2);
}
}
public class ReturnInt {
public static void main(String[] arguments) {
System.out.println("2 + 7 = " + add(2, 7));
System.out.println("0 + 8 = " + add(0, 8));
System.out.println("-7 + 7 = " + add(-7, 7));
}
public static int add(int int1, int int2) {
return int1 + int2;
}
}
Implementieren Sie ein Java-Konsolenprogramm, welches für eingegebene Werte für drei Kanten eines Quaders
berechnet.
Verwenden Sie in Ihrem Java-Programm für das Berechnen der Werte jeweils Methoden mit Rückgabewerten.
Ein kleines Programm für das 1×1 ist gesucht. Es soll also das kleine 1×1 in der Form ausgegeben werden:
1 x 1 = 1
2 x 1 = 2
...
10 x 9 = 90
10 x 10 = 100
Implementieren Sie ein Programm mit der Methode aufzinsen(…). Als Argumente sollen das Grundkapital, der Zinssatz und die Anzahl der Jahre angegeben werden. Die Methode gibt das Kapital (Grundkapital+Zinsen) nach den angegebenen Jahren zurück. Testen Sie die Methode mit einer geeigneten main-Methode.
Potenzieren können Sie in Java (hier) mit der vorhandene Methode
double c = Math.pow(double a, double b)
public class Zins {
public static void berechneZins(int jahre, double kapital) {
double zins;
for (int i = 1; i < jahre; i--)
zins = kapital * 0.05
kapital = kapital + zins;
System.out.println("Das Kapital beträgt " + kapital + "€");
}
public static void main(String[] args) {
double kapital;
int jahre;
Scanner sc = new Scanner(System.in);
System.out.println("Geben Sie das Startkapital ein (in €): ");
kapital = sc.nextInt();
berechneZins(kapital);
}
}
Wir rechnen für gewöhnlich im Dezimalsystem, also einem System mit 10 Zahlzeichen 0,…,9. Ab der Zahl 10 werden dann alle höheren Zahlen als Kombination mehrerer dieser Zahlzeichen geschrieben. Natürlich ist dies nur eine Vereinbarung, und man könnte genausogut mit jeder anderen Anzahl von Ziffern rechnen. Hat man zum Beispiel nur zwei Ziffern 0 und 1 zur Verfügung, so kann man mit diesen auch sämtliche Zahlen darstellen. Allerdings müßte man die „2“ aus unserem Zehnersystem dann als „10“ darstellen, da sie die erste Zahl ist, die nicht mehr nur durch eine einzelne Ziffer dargestellt werden kann … diese Darstellung kennen wir schon als Dualsystem.
Dafür gibt es verschiedene Algorithmen – einer soll im Folgenden beschrieben werden.
In jedem Stellenwertsystem hat eine Ziffer an einer bestimmten Stelle einen entsprechenden Wert. Zum Beispiel hat im Zehnersystem eine „1“ an der zweiten Stelle von rechts immer den Wert 10; in anderen Zahlensystemen kann sie aber einen völlig anderen Wert haben.
Die Werte an den Stellen ermittelt man im System mit n Ziffern folgendermaßen: Die Stelle rechts hat immer den Wert 1*Ziffer, die dort steht. Die zweite Stelle von rechts hat immer den Wert n*Ziffer, die dort steht. Die dritte Stelle von rechts hat den Wert n*n*Ziffer, die vierte den Wert n*n*n*Ziffer etc.
Den Wert der Zahl erhält man dann einfach durch Aufsummieren der so erhaltenen Werte.
Um dies verständlicher zu machen, hier ein Beispiel:
Man möchte „1011“ aus dem Dualsystem in das Zehnersystem umrechnen. Ganz rechts steht eine 1, also hat man dort den Wert 1*1=1. Links daneben steht ebenfalls eine 1, also hat man dort den Wert 2*1=2. Noch weiter links steht eine 0, diese entspricht 2*2*0=0. Ganz links steht eine 1, die 2*2*2*1=8 entspricht.
Also erhält man als Wert im Zehnersystem 8+0+2+1=11.
Implementieren Sie ein Java-Programm, welches Dualzahlen in Dezimalzahlen umwandelt.
Das Programm soll folgende Grundstruktur haben:
import java.util.Scanner;
public class BinDec {
public static int wandleBinInDec(int b) {
...
}
public static void main(String[] args) {
int binaer, dezimal;
Scanner sc = new Scanner(System.in);
System.out.print("Geben Sie eine Binärzahl ein: ");
binaer = sc.nextInt();
dezimal = wandleBinInDec(binaer);
System.out.println("Deziamlzahl: " + dezimal);
}
}
Auch das ist nicht schwer: Man nimmt sich die Zahl, die man umrechnen will, und teilt sie durch die Anzahl Ziffern im Zahlensystem, in diesem Fall 2. Den Divisionsrest notiert man sich als Ziffer und das Divisionsergebnis teilt man erneut. Die einzelnen Ziffern notiert man sich dann von rechts nach links. Dies setzt man so lange fort, bis man am Ende als Divisionsergebnis die 0 erhält.
Auch hier wieder ein Beispiel: Wir wollen 147 in das Dualsystem umrechnen.
147 : 2 = 73 Rest 1, also 1 ist Ziffer ganz rechts.
73 : 2 = 36 Rest 1, also 1 ist nächste Ziffer von rechts.
36 : 2 = 18 Rest 0, also ist die 0 nächste Ziffer.
18 : 2 = 9 Rest 0, also ist die nächste Ziffer wieder eine 0.
9 : 2 = 4 Rest 1, also kommt als nächstes eine 1.
4 : 2 = 2 Rest 0; 2 : 2 = 1 Rest 0 und 1 : 1 = 1 Rest 1
147 hat also im Dualsystem die Darstellung 10010011.
Analalog zum ersten Programm soll nun ein Programm DecBin implementiert werden, welches eine eingegebene Dezimalzahl in eine Binärzahl umwandelt. Ach dies sollwieder in einer extra Methode mit Rückgabewert geschehen.
Aus der Aufgabe 8 heraus soll nun ein Javaprogramm implementiert werden, welches jedes beliebige Zahlensystem in jedes andere umwandeln kann.
Dazu sind das Ausgangszahkensystem, das Zielzahlensystem und die umzuwandelnde Zahl einzugeben.
Das Ganze geht natürlich auch direkt, aber wir können auch die beiden Methoden aus Aufgabe 8 nutzen … man wandelt die gegebene Zahl erstmal in Dezimalsystem und dann von dort in das gewünschte Zielsystem um.
Da wir noch nicht mit Strings arbeiten können, können wir nur mit Zahlensystemen bis 10 arbeiten.
]]>Implementieren Sie ist ein Java-Programm, welches aus 10 einzugebenden Zahlen folgende Werte ermittelt:
Ermitteln Sie die einzelnen Ergebnisse jeweils in einer Methode mit Rückgabewert. Die Eingabe der 10 Einzelwerte und die Ausgabe der Ergebnisse soll in der main-Methode erfolgen.
In einer Tüte Gummibärchen sind (lt. Hersteller) 12 Gummibärchen enthalten. L. Ecker Maul kann dies gar nicht glauben, da die Tütchen viel zu schnell leer sind. Daher beschließt er einen Test zu machen. Er kauft sich eine genügende Anzahl dieser kleinen Tütchen und führt eine Gummibärchenvolkszählung durch …
Implementieren Sie ein Java-Programm, welches für eine gewünschte Anzahl von Tütchen diesen Test durchführt. Die Anzahl der Tütchen soll zu Beginn abgefragt werden. Am Ende soll natürlich die Anzahl der korrekten Tütchen angegeben werden. Weitere Daten für die Auswertung (Wie viele Tütchen hatten zu wenige, wie viel zu viele? …) können Sie eigenständig ergänzen.
Bei einem elektrophysikalischen Versuch wird die Augenblicksspannung eines Wechselspannungsvorgangs gemessen. Die Spitzenspannung beträgt 12V. Das Messinstrument gibt 1000 digitale Messwerte in (ganzzahligen) Stufen von 1 Volt bis 12V über einen längeren Zeitraum aus.
Bei der Auswertung ist nun festzustellen, wie häufig die gemessenen Augenblicksspannungen aufgetreten sind. (Da wir „keine Lust“ haben, 1000 Messwerte per Hand einzugeben, müssen diese auf andere Weise erzeugt werden …)
Implementieren Sie ein geeignetes Java-Programm, welches zuerst die 1000 Messwerte erzeigt und danach die Häufigkeit der einzelnen Augenblicksspannungen ermittelt (Hinweis: Man bräuchte zwei Arrays …)
Implementieren Sie ein Java-Programm, welches die Einstiegsaufgabe zum Thema Arrays realisiert.
Implementieren Sie ein Java-Programm, welches drei Arrays der Länge 20 füllt … nach folgenden Kriterien:
Die drei Felder sollten jeweils erzeugt und ausgegeben werden.
In einem Feld soll nach einem bestimmten Wert gesucht werden. Ist der Wert vorhanden, wird der Index geliefert, in dem der Wert steht. Überlegen Sie, welcher Wert zurückgegeben werden könnte, falls der Wert nicht im Feld enthalten ist.
Implementieren Sie ein geeignetes Java-Programm, welches in einem zu Beginn (im Programm) angegebenen Feld mit einer Methode int searchIndex(int[] a, int value) testet, ob value in a enthalten ist und nach den oben vereinbarten Regeln einen Wert zurück gibt.
Implementieren Sie eine Methode swap(int[] a, int i, int j), die zwei Werte in einem Integer-Array tauscht. Die Methode wird mit dem Feld a und den beiden Indizes der zu tauschenden Parametern aufgerufen werden. Das Ergebnisfeld soll zurückgegeben werden.
Das zu sortierende Feld ist in der main-Methode zu vereinbaren und auszugeben, ebenso ist das geänderte Feld auszugeben. Die Ausgabe hat nach dem Aufruf wie folgt auszusehen:
Feld: 4 2 10 3 -5 0 17
Parameter 1: 3
Parameter 2: 5
neues Feld: 4 2 10 0 -5 3 17
Implementieren Sie eine Methode delElement(int[] a, int w), welche einen Wert w aus dem Array a löscht. Die eventuell entstehende leere Stelle soll durch „Aufrutschen“ beseitigt werden. Die Methode gibt das neue Feld zurück.
Beachte die Möglichkeit, dass das Element nicht vorhanden ist.
Beispiel: Der Funktion wird das Array a = [3,4,1,9,-5,4] übergeben und folgendermaßen modifiziert:
Feld: 3 4 1 9 -5 4
zu löschendes Element: 9
neues Feld: 3 4 1 -5 4
Das Ergebnis soll an die main-Methode zurückgegeben werden.
Implementieren Sie eine Methode sumUp(int[] a), der ein Array vom Typ int übergeben wird.
An Index i \in \{0,...,a.length-1\} soll nun der neue Wert a[0] + ... + a[n] geschrieben werden. Dabei bezeichnen a[0] usw. die Werte in a, die in die Methode übergeben wurden.
Beispiel: Der Funktion wird das Array a = [3,4,1,9,-5,4] übergeben und folgendermaßen modifiziert:
-> [3, 3+4, 3+4+1, 3+4+1+9, 3+4+1+9+(-5), 3+4+1+9+(-5)+4]
-> [3, 7, 8, 17, 12, 16]
Das Ergebnis soll an die main-Methode zurückgegeben werden. Als Maske können Sie folgenden Quelltext verwenden:
public class Aufsummieren {
public static int[] sumUp(int[] a) {
}
public static void main(String[] args) {
int[] zahlen = {4,3,1,9,-5,4};
...
sumUp(zahlen);
...
}
}