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


Kapitel 47 Programmieraufgaben


Aufgabe 1 — Summe der geraden, ungeraden und aller Elemente

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.


Aufgabe 2 — Die zwei größten Elemente

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.


Aufgabe 3 — Elemente umkehren

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.


Aufgabe 4 — Tonfilter (Smooth Operator)

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.


Aufgabe 5 — Daten-Optimierer

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