5. Felder, Funktionen, Strukturen, Zeiger, Dateiarbeit
Werbung
Institut für Informatik
LV "Grundlagen der Informatik"
Übungsaufgaben zu
Programmierung in C (Teil 2)
Aufgabenkomplex: Programmieren in C (Teil 2 von 2)
(Strukturierte Datentypen: Felder, Strukturen, Zeiger;
Funktionen mit Parameterübergabe; Dateiarbeit)
--------------------------------------------------------------------------------------------------------------------Hinweis: Alle mit * gekennzeichneten Aufgaben sind zum zusätzlichen Üben gedacht.
---------------------------------------------------------------------------------------------------------------------
1.
Eindimensionale Felder
1.1
Summe von n reellen Messwerte
Schreiben Sie ein C-Programm zur Bestimmung der Summe von n reellen Messwerten (n
bekannt). Die Eingabe der Messwerte soll in ein eindimensionales Feld erfolgen. Geben Sie das
Resultat aus.
--------------------------------------------------------------------------------------------------------------------1.2
Eindimensionales Feld aus Zufallszahlen
Schreiben Sie ein C-Programm zur Lösung folgender Aufgabe: Legen Sie ein eindimensionales
Feld an, das aus 100 ganzen Zahlen bestehen soll. Füllen Sie das Feld mit Zufallszahlen zwischen
0 und 99. Zeigen Sie die Feldinhalte auf dem Bildschirm an.
Hinweis: Die Funktion rand( )
(Header <stdlib.h> einbinden) liefert Zufallszahlen
zwischen 0 und 32767. Zufallszahlen von 0 bis 99 erhalten Sie, indem Sie den Divisionsrest der
ganzzahligen Division durch 100 bestimmen:
rand( )%100
--------------------------------------------------------------------------------------------------------------------*1.3 Maximum, Minimum, Mittelwert und Streuung
Schreiben Sie ein C-Programm, mit dem von den Zufallszahlen aus Aufgabe 1.2) ein Maximum,
ein Minimum, den Mittelwert und die Streuung. Bestimmt werden (vgl. Aufgabenkomplex
Struktogramme, Aufg. 16)
Hinweise:
- Mittelwert: in der Statistik als bezeichnet; in der Informatik besser z.B. als mw :
1 n
mw = ∑ x[i ]
n i =1
- Streuung (oder auch: Varianz): in der Statistik als s2 bezeichnet; hier besser z.B. als var :
n
2
2
1
1
var =
=
(
− n * mw * mw)
−
(
x
[
i
]
mw
)
(
x
[
i
])
∑
∑
n −1
n − 1 1=1
Bemerkung: Die zweite Formel für var ist rechentechnisch günstiger. Bei der algorithmischen Berechnung
von mw wird man zuerst die enthaltene Summe berechnen, dieses „Zwischenresultat“ auch in mw
speichern und schließlich durch n dividieren. Entsprechend geht man bei der Berechnung von var vor:
zunächst wird die enthaltene Summe berechnet, dieses „Zwischenresultat“ auch in var gespeichert und
anschließend n*mw*mw abgezogen und alles durch (n-1) dividiert.
--------------------------------------------------------------------------------------------------------------------1.4
Verschachtelte Zählschleifen (vgl. Aufgabenkomplex Struktogramme, Aufg. 17)
Schreiben Sie ein C-Programm zur Berechnung des Wertes der Doppelsumme
n
i
doppsum = ∑∑ (i + j ) 2
i = 2 j =1
wobei zuvor die ganze Zahl n einzulesen ist.
---------------------------------------------------------------------------------------------------------------------
1
Institut für Informatik
LV "Grundlagen der Informatik"
Übungsaufgaben zu
Programmierung in C (Teil 2)
1.5 Ausgabe eines Musters aus Sternen (vgl. Aufgabenkomplex Struktogramme, Aufg. 20)
Schreiben Sie ein C-Programm, das folgendes Muster in 20 Zeilen auf den Bildschirm ausgibt:
*
**
***
...
********************
(1.Zeile:
(2.Zeile:
(3.Zeile:
(usw.)
(20.Zeile:
1 Stern)
2 Sterne)
3 Sterne)
20 Sterne)
--------------------------------------------------------------------------------------------------------------------*1.6 Einfaches Ratespiel („1 aus 90“) (vgl. Aufgabenkomplex Struktogramme, Aufg. 22*)
Schreiben Sie ein C-Programm, in dem folgendes einfache Ratespiel umgesetzt wird:
Spielschritt 1: Mit einem Zufallszahlengenerator ist zunächst eine zu erratende ganze Zahl a aus
dem Bereich 1<=a<=90 zu bestimmen.
(Hinweis: Da Zufallszahlengeneratoren programmiersprachspezifisch sind, schreiben Sie hierfür
einfach als Aktion a = Zzahl aus [1,90]
ins Struktogramm.)
Spielschritt 2: - Der Spieler muss a nun durch Eingabe einer ganzen Zahl b zu erraten versuchen.
- Solange er falsch rät (a != b): Hinweis durch Ausgabe, ob b zu groß oder zu klein ist. Danach
muss der Spieler erneut raten.
- Wenn richtig geraten (b = =a):
-- Anzahl n der benötigten Rateversuche ausgeben
-- Außerdem verbale Leistungseinschätzung in Abhängigkeit von n ausgeben und zwar:
--- n= 1 oder 2:
Super
--- n = 3 oder 4:
Sehr gut
--- n = 5:
Gute Leistung
--- n = 6, 7 oder 8
Mittelmäßige Leistung
--- n > 8
Schwache Leistung
- Fragen, ob Spieler noch einmal spielen will.
Wenn ja, dann Fortsetzung bei Spielschritt 1, sonst Spielende.
---------------------------------------------------------------------------------------------------------------------
2.
Funktionen (mit Parameterübergabe)
Hinweis: In den Aufgaben des Teiles 2. ist nicht mit globalen Variablen, sondern nur mit
lokalen Variablen zu arbeiten.
2.1.a) Volumen und der Oberfläche einer Kugel in gesonderten Funktion
In einem C-Programm ist die Berechnung des Volumen und der Oberfläche einer Kugel (vgl.
Aufgabenkomplex Struktogramme, Aufg. 2) ) wie folgt zu programmieren:
- Eingabe des Radius und Ausgabe der Resultate in der main-Funktion.
- Berechnung des Volumen und der Oberfläche jeweils in einer gesonderten Funktion (ohne
Funktions-Prototypen).
2.1.b) wie 2.1.a), aber jetzt mit Funktions-Prototypen
--------------------------------------------------------------------------------------------------------------------2.2
Summe von Fakultäten in gesonderter Function (mehrfacher Aufruf)
In einem C-Programm ist die Summe von Fakultäten z = a! + b! + c! (a, b, c ... natürliche
Zahlen) mit einem nichtrekursiven Algorithmus zu berechnen (vgl. Aufgabenkomplex
Struktogramme, Aufg. 13).
- Die Eingabe von a, b und c sowie die Ausgabe des Resultats z sollen in der main-Funktion
erfolgen.
- Die Berechnung der Fakultät ist in einer gesonderten Funktion vorzunehmen.
--------------------------------------------------------------------------------------------------------------------2
Institut für Informatik
LV "Grundlagen der Informatik"
Übungsaufgaben zu
Programmierung in C (Teil 2)
*2.3 Summe von Fakultäten in gesonderter Function (jetzt rekursiver Algorithmus)
Zu berechnen ist wiederum z=a!+b!+c!. Verwenden Sie jetzt zur Berechnung der Fakultät eine
rekursive Funktion.
--------------------------------------------------------------------------------------------------------------------2.4
Übergabe von Feldern (Einlesen bei unbekanntem n; Endeerkennung)
Bestimmen Sie (als Vorbereitung von 2.5) die Summe von n reellen Messwerte. Dabei sei die
Anzahl n der Messwerte dem Nutzer nicht bekannt (d.h. n kann nicht eingelesen werden). Ein
Wert für die Endeerkennung ist vor der Eingabe einzulesen. Die Eingabe der Messwerte (in ein
Feld) und die Ausgabe der Summe sollen in der main-Function erfolgen. Die Summe ist in einer
gesonderten Funktion zu berechnen.
--------------------------------------------------------------------------------------------------------------------2.5
Maximum, Minimum, Mittelwert und Streuung von n reellen Messwerten
Bestimmen Sie Maximum, Minimum, Mittelwert und Streuung (Varianz) von n reellen
Messwerten (vgl. Aufgabenkomplex Struktogramme, Aufg. 16). Dabei sei die Anzahl n der
Messwerte nicht bekannt (d.h. kann nicht eingelesen werden).
- Die Eingabe der Messwerte soll in einer gesonderten Funktion erfolgen (also nicht in der mainFunction). Da die Anzahl n unbekannt ist, soll die Anzahl n der Messwerte beim Einlesen
ermittelt und als Ergebnis an die main-Funktion übergeben werden. Ein Wert für die
Endeerkennung ist vor der Eingabe einzulesen.
- Die eingelesenen Messwerte sollen zur Kontrolle in einer gesonderten Funktion ausgegeben
werden.
- Ein Maximum und ein Minimum der Messwerte sind in je einer weiteren Funktion zu
berechnen.
- In einer gesonderten Funktion ist die Berechnung der Summe der Messwerte vorzunehmen.
Diese Funktion ist bei der Berechnung des Mittelwertes und der Streuung (Varianz) zu
verwenden.
- *Ergänzen Sie Aufgabe 2.5 durch eine weitere Funktion zum Sortieren der Messwerte (vgl.
Aufgabenkomplex Struktogramme, Aufg. 21).
---------------------------------------------------------------------------------------------------------------------
3.
Struktur-Typ
3.1
Struktur für eine Bestellung
In einer Vorstufe für ein einfaches Bestellsystem sind in einem C-Programm zunächst für eine
Bestellung das Datum der Bestellung, die Artikelnummer, die Stückzahl und der Preis pro Stück
zu erfassen. Speichern Sie diese Daten in eine Variable vom Strukturtyp, und geben Sie die Daten
zur Kontrolle wieder aus.
--------------------------------------------------------------------------------------------------------------------3.2
Erweiterung: Feld von Strukturen (maximal 10 Bestellungen)
- Schreiben Sie in Erweiterung von 3.1 ein C-Programm zur Erfassung von maximal
10 Bestellungen gemäß dem in 3.1 beschriebenen Bestellsystem.
- Geben Sie danach alle Bestellungen zur Kontrolle zeilenweise aus.
--------------------------------------------------------------------------------------------------------------------3.3
Erweiterung durch Berechnung des Gesamtpreises
Erweitern Sie das Programm aus 3.2 um die Berechnung des Gesamtpreises aller Bestellungen
und geben Sie diesen aus.
--------------------------------------------------------------------------------------------------------------------3.4* Weitere Erweiterung
Erweitern Sie Ihr Programm aus Aufgabe 3.2. so, dass wahlweise alle Bestellungen oder nur die
Bestellung ab einem eingebbaren Mindestbetrag ausgegeben werden.
---------------------------------------------------------------------------------------------------------------------
3
Institut für Informatik
LV "Grundlagen der Informatik"
4.
Übungsaufgaben zu
Programmierung in C (Teil 2)
Mehrdimensionale Felder
4.1
Matrixberechnungen
Vereinbaren Sie in einem C-Programm eine Matrix mit max. 5 Zeilen und max. 8 Spalten mit
ganzzahligen Elementen (vereinbarte, maximal mögliche Dimension der Matrix). Lesen Sie dann
die wirkliche Dimension der Matrix ein. Füllen Sie diese Matrix mit Zufallszahlen zwischen 0
und 99 (siehe Hinweis in 1.2). Geben Sie die Inhalte auf dem Bildschirm an.
- Bestimmen Sie ein maximales und ein minimales Element dieser Matrix. Geben Sie die
Resultate aus.
*- Bestimmen Sie zusätzlich ein maximales Element jeder Zeile der Matrix, und speichern Sie
diese Zeilenmaxima in eine Feldvariable. Geben Sie die Resultate aus.
--------------------------------------------------------------------------------------------------------------------*4.2 Matrizenmultiplikation (vgl. Aufgabenkomplex Struktogramme, Aufg. 19*).
In einem C-Programm sind die reellen Matrizen Am,n (m Zeilen; n Spalten) und Bn,k (n Zeilen; k
Spalten) einzulesen (max. mögliche Dimension: 20 Zeilen, 20 Spalten). Die Dimensionen m, n
und k seien dem Nutzer bekannt und können folglich eingelesen werden (korrekte Eingabe von
m, n, k prüfen). Danach ist die (reelle) Produktmatrix
Cm,k = Am,n * Bn,k
zu berechnen gemäß
n
cij = ∑ aip * b pj ; i = 1, ..., m; j = 1, ..., k
p =1
und zeilenweise auszugeben.
---------------------------------------------------------------------------------------------------------------------
5.
Zeiger
5.1a) Testen Sie folgendes C-Programm:
/*******************************************************/
#include <stdio.h>
void main()
{
int a;
int *pa;
a = 2;
pa = &a;
/* pa zeigt auf a (ist Zeiger auf a);
mittels *pa kann auf a zugegriffen werden */
printf("a=%d pa=%p *pa=%d \n", a, pa, *pa);
*pa = 5;
printf("a=%d pa=%p *pa=%d \n", a, pa, *pa);
}
/*******************************************************/
5.1b) Erweitern Sie das Programm um die Eingabe einer zweiten Variablen. Geben Sie die
Summe der Zahlen aus. Verwenden Sie für das Ergebnis eine initialisierte Zeigervariable.
---------------------------------------------------------------------------------------------------------------------
4
Institut für Informatik
LV "Grundlagen der Informatik"
Übungsaufgaben zu
Programmierung in C (Teil 2)
5.2 Analysieren Sie das folgende C-Programm zur Berechnung des Quotienten in einer Funktion:
#include <stdio.h>
int func(double x, double y, double *pz)
{
int error;
error = 0;
if (y!=0) *pz = x / y;
else error = 1;
return error;
}
void main()
{
double a, b, c; int error;
scanf("%lf%lf",&a,&b);
error = func(a, b, &c);
if (error == 0) printf("Quotient = %g\n",c);
else printf("Division durch 0\n");
}
/***************************************************/
- Versuchen Sie, in den formalen Parametern keine Zeiger zu verwenden.
- Erweitern Sie die Funktion func (mit Zeigern) um die Berechnung des Produkts.
--------------------------------------------------------------------------------------------------------------------5.3
Resultatrückgabe über Parameterliste
Modifizieren Sie Aufgabe 2.1 (Berechnung von Volumen und Oberfläche einer Kugel) in
folgender Weise:
- Wiederum Eingabe des Radius und Ausgabe der Resultate in der main-Funktion.
- Aber jetzt: Berechnung des Volumen und der Oberfläche gemeinsam in einer Funktion. Beide
Resultate sind über die Parameterliste an die aufrufende Funktion zurückzugeben.
--------------------------------------------------------------------------------------------------------------------*5.4 Dynamische Reservierung von Speicherplatz
Berechnen Sie in einem C-Programm ein Maximum und die Summe von n Meßwerten. Die Zahl
der Messwerte n soll vom Benutzer eingegeben werden. Reservieren Sie den Speicherplatz für
die Meßwerte dynamisch mit:
x = (double*) malloc (n * sizeof (double));
Voraussetzung: Einbinden von <stdlib.h>
---------------------------------------------------------------------------------------------------------------------
6.
Dateiarbeit (Der Datentyp File)
6.1
Dateiarbeit (Datentyp File)
In der Datei
L:\Prog_C\geheim.txt (Weisbach-Bau) bzw. Y:\Lehre\Prog_C\geheim.txt
(Rammler-Bau) ist ein Text verschlüsselt gespeichert. Um den Text lesbar zu machen, müssen
einige Buchstaben in der Datei durch andere Buchstaben ersetzt werden (siehe Tabelle).
Buchstabe in geheim.txt
Buchstabe im Klartext
e
l
l
e
a
r
r
a
t
s
s
t
Schreiben Sie ein C-Programm, das die Datei geheim.txt einliest und den Klartext auf dem
Bildschirm ausgibt.
5
