erstellt 31.05.03; überarbeitet 07.07.07, 09.11.12, 15.7.18 übersetzt 22.06.03; überarbeitet 01.02.05, 20.03.24
Wir vervollständigen das folgende Programm,
so dass es die Summe aller Elemente des Arrays,
die Summe der geraden Elemente und die
Summe der ungeraden Elemente errechnet.
Wir setzen voraus, dass alle Zahlen 0 oder positiv sind.
Gerade Integer sind solche, für die N % 2 == 0 ist.
class DreiSummen
{
public static void main ( String[] args )
{
int[] data = {3, 2, 5, 7, 9, 12, 97, 24, 54};
// drei Variablen fuer die Summen deklarieren und initialisieren
// Summen berechnen
for ( int index = 0; index < data.length; index++ )
{
}
// Summen ausgeben
System.out.println( );
}
}
Zurück zum Inhaltsverzeichnis.
Wir vervollständigen das folgende Programm, so dass es die zwei größten Elemente des Arrays berechnet und ausgibt.
class DieZweiGroessten
{
public static void main ( String[] args )
{
int[] data = {3, 1, 5, 7, 4, 12, -3, 8, -2};
// Variablen fuer die zwei groessten Elemente deklarieren und initialisieren
// die zwei groessten Elemente berechnen
for ( int index= ; index < data.length; index++)
{
}
// die zwei groessten Elemente ausgeben
System.out.println( );
}
}
Zurück zum Inhaltsverzeichnis.
Wir vervollständigen das folgende Programm, so dass es
die Reihenfolge der Werte in data umkehrt
und sie ausgibt.
In der ersten Version des Programms gibt es nur B und seine Werte werden durch eine etwas trickreiche Programmierung umgekehrt.
class ArrayUmkehren1
{
public static void main ( String[] args )
{
int[] data = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
// Daten umkehren
for ( int j = 0; j < seid vorsichtig hier ; j++)
{
}
// neuen Daten ausgeben
for ( int j = 0; j < data.length; j++)
{
}
}
}
Wir schreiben jetzt ein weiteres Programm, das zwei Arrays verwendet.
Das erste Array data wird nicht geändert.
Das zweite Array zielData bekommt die Elemente
von data in umgekehrter Reihenfolge.
class ArrayUmkehren2
{
public static void main ( String[] args )
{
int[] data = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
int[] zielData =
// die Daten von data in umgekehrter Reihenfolge nach zielData kopieren
for ( int j = 0; j < seid vorsichtig hier ; j++)
{
}
// Ergebnis ausgeben
for ( int j = 0; j < zielArray.length; j++)
{
}
}
}
Zurück zum Inhaltsverzeichnis.
Ein Tonsignal wird manchmal als Liste von int-Werten gespeichert.
Die Werte repräsentieren die Intensität des Signals
in aufeinanderfolgenden Zeitintervallen.
Natürlich wird in einem Programm das Signal
durch ein Array repräsentiert.
Oft ist in dem Signal ein kleiner Anteil von Störgeräuschen enthalten. Störgeräusche sind üblicherweise kleine, momentane Änderungen der Tonhöhe. Ein Beispiel ist das "Geräusch", das zusätzlich zum Ton eines AM Radios zu hören ist.
Das Glätten des Tons entfernt das Störgeräusch und verbessert die Wahrnehmung der Tonqualität. Unsere Aufgabe besteht darin, die Werte eines Integer Arrays zu glätten.
Angenommen, dass die ursprünglichen Werte in dem Array signal sind.
Wir berechnen das geglättete Array, in dem wir folgendes tun:
Jeder Wert von smooth[N] (mit Ausnahme des ersten und letzten Elements) ist der Durchschnitt von
drei Werten: signal[N-1],
signal[N] und signal[N+1].
Wir berechnen für das erste Element von smooth
den Durchschnitt der ersten zwei Elemente von signal.
Für das letzte Element von smooth
berechnen wir den Durchschnitt der letzten zwei Elemente von signal.
Wir verwenden dafür Integer Arithmetik,
so dass die Werte in smooth
Integer sind.
class Smooth
{
public static void main ( String[] args )
{
int[] signal = {5, 5, 4, 5, 6, 6, 7, 6, 5, 4, 1, 4};
int[] smooth
// wir berechnen den geglaetteten Wert fuer jedes Element
// des Arrays smooth
smooth[0] =
smooth[ signal.length-1 ] =
for ( )
{
}
// Geben den Input aus
for ( int j = 0; j < smooth.length; j++)
{
}
// Geben das Ergebnis aus
for ( int j = 0; j < smooth.length; j++)
{
}
}
}
Denkt daran, wenn Ihr die Ergebnisse interpretiert, dass eine Integer Division den Rest verwirft. Es wird kein gerundeter Wert berechnet. Hier ist, was das Programm ausgibt.
C:\data\JavaNotes>java Glaetten signal: 1 5 4 5 7 6 8 6 5 4 5 4 smooth: 3 3 4 5 6 7 6 6 5 4 4 4 C:\data\JavaNotes>
Zurück zum Inhaltsverzeichnis.
Angenommen, dass wir an der Berechnung des durchschnittlichen Säuregehalts von Kaffee interessiert sind, wie er in den Cafés serviert wird. Wir besuchen eine Reihe von Cafés und tauchen das pH-Messgerät in die Kaffeeproben. Wir schreiben das Ergebnis in eine Textdatei wie der folgenden. Die erste Zeile zeigt die Anzahl der Werte an, die folgen werden.
13 5.6 6.2 6.0 5.5 5.7 6.1 7.4 5.5 5.5 6.3 6.4 4.0 6.9
Unglücklicherweise liefert das pH-Messgerät manchmal falsche Ergebnisse. Also entschließen wir uns den Messwert, der am weitesten vom Durchschnitt entfernt ist, nicht zu berücksichtigen.
Wir erzeugen eine Textdatei wie die oben stehende oder eine mit ähnlichen Daten. Dann schreiben wir ein Programm, dass die Daten in ein Array einliest (wir verwenden Input-Umlenkung). Wir berechnen den Durchschnitt aller Daten.
Durchsuchen jetzt das Array, um den Wert zu finden, der am weitesten (in jeder Richtung) vom Durchschnitt entfernt ist. Diesen Wert setzen wir auf -1, um anzuzeigen, dass der Wert nicht aufgenommen wird. Dann geben wir den neuen Durchschnitt aus.
Hier ist ein Ablauf des Programms:
C:\>java KaffeeDurchschnitt < KaffeeDaten.txt data[ 0 ] = 5.6 data[ 1 ] = 6.2 data[ 2 ] = 6.0 data[ 3 ] = 5.5 data[ 4 ] = 5.7 data[ 5 ] = 6.1 data[ 6 ] = 7.4 data[ 7 ] = 5.5 data[ 8 ] = 5.5 data[ 9 ] = 6.3 data[ 10 ] = 6.4 data[ 11 ] = 4.0 data[ 12 ] = 6.9 Durchschnitt: 5.930769230769231 entferntester Wert: 4.0 neuer Durchschnitt: 6.091666666666668
Hinweis: das ist eine schwierigere Aufgabe als Ihr denken mögt. Ich stelle sie manchmal in den Prüfungen Mitte des Semesters und manche Studenten können sie nicht lösen.
Zurück zum Inhaltsverzeichnis.
Ende der Aufgaben