1613_01 Flashcards Preview

Hagen_1613 > 1613_01 > Flashcards

Flashcards in 1613_01 Deck (15):
1

Welche const, type und var brauche ich für die Berechnung der Flugzeit?

const
MINSEK = 59;
STUNDE = 23;
type
tMinSek = 0..MINSEK;
tStunde = 0..STUNDE;
tZeit = record
h : tStunde;
m,
s : tMinSek
end;
tUebertrag = 0..1;
var
Abflug,
Ankunft,
Flugdauer : tZeit;
Uebertrag : tUebertrag;

2

Ein Programm, welches die kleinste Zahl unter den Eingabezahlen herausgibt.

program kleinsteZahl (input, output);
{ gibt die kleinste Zahl unter den integer-Eingabezahlen
aus }
var
Zahl,
Minimum : integer;
begin
writeln ('Geben Sie die integer-Zahlen ein. ',
'0 beendet die Eingabe.');
readln (Zahl);
if Zahl = 0 then
writeln ('Es wurde keine Zahl <> 0 eingegeben')
else
begin
Minimum := Zahl;
repeat
if Zahl < Minimum then
Minimum := Zahl;
readln (Zahl)
until Zahl = 0;
writeln ('Die kleinste Zahl lautet ', Minimum, '.')
end
end. { kleinsteZahl }

3

Geben Sie Matr.Nr. und Aktivitaet der ', AnzStud, ' Teilnehmer ein:

writeln ('Geben Sie Matr.Nr. und Aktivitaet der ',
AnzStud, ' Teilnehmer ein:');

for i := 1 to AnzStud do
begin
write ('Matr.Nr. ');
readln (MatrNrFeld[i]);
write ('a - aktiv, p - passiv: ');
readln (Status);
if Status = 'a' then
StatusFeld[i] := aktiv
else
StatusFeld[i] := passiv
end;

4

Eine Funktion zur Bestimmung der Primzahl

function istPrimzahl (p : tNatZahlPlus): boolean;
{ liefert true, falls p Primzahl, und false sonst }

var
q : tNatZahlPlus;
begin
if p < 2 then
istPrimzahl := false
else
begin { p >= 2)}
q := 2;
while (p mod q <> 0) do
q := q + 1;
if q = p then
istPrimzahl := true
else
istPrimzahl := false
end
end; { istPrimzahl }

5

Eine Prozedur zum Vertauschen

procedure vertauschen (
var ioHin,
ioHer : integer);
{ vertauscht die Parameterwerte }

var
Tausch : integer;

begin
Tausch := ioHin;
ioHin := ioHer;
ioHer := Tausch
end; { vertauschen }

6

Datentyp tRefListe, um eine lineare Liste zu erstellen.

type
tRefListe = ^tListe;
tListe = record
info : integer;
next : tRefListe
end;

7

procedure ListeAufbauen(var outRefAnfang : tRefListe);

{ baut eine Liste aus einzulesenden integer-Zahlen
auf }

procedure ListeAufbauen(var outRefAnfang : tRefListe);
{ baut eine Liste aus einzulesenden integer-Zahlen
auf }
var
Zeiger : tRefListe;
Zahl : integer;

begin
{ zunaechst outRefAnfang auf nil setzen, da mit
der leeren Liste gestartet wird }

outRefAnfang := nil;
readln (Zahl);

while Zahl <> 0 do
begin
new (Zeiger);
Zeiger^.info := Zahl;
Zeiger^.next := outRefAnfang; { * }
outRefAnfang := Zeiger; { ** }
readln (Zahl)
end { while-Schleife }
end; { ListeAufbauen }

8

procedure ListeDurchlaufen (inRefAnfang : tRefListe);

{ gibt die Werte der Listenelemente aus }

procedure ListeDurchlaufen (inRefAnfang : tRefListe);
{ gibt die Werte der Listenelemente aus }

var
Zeiger : tRefListe;

begin
Zeiger := inRefAnfang;
while Zeiger <> nil do

begin
writeln (Zeiger^.info);
Zeiger := Zeiger^.next
end
end; { ListeDurchlaufen }

9

function ListenElemSuchen2 (
inRefAnfang : tRefListe;
inZahl : integer): tRefListe;

{ bestimmt das erste Element in einer Liste, bei dem
die info-Komponente gleich inZahl ist }

function ListenElemSuchen2 (
inRefAnfang : tRefListe;
inZahl : integer): tRefListe;

{ bestimmt das erste Element in einer Liste, bei dem
die info-Komponente gleich inZahl ist }

var
Zeiger : tRefListe;

begin
Zeiger := inRefAnfang;
if Zeiger <> nil then
{ Liste nicht leer }
begin
while (Zeiger^.next <> nil) and
(Zeiger^.info <> inZahl) do
Zeiger := Zeiger^.next;
if Zeiger^.info <> inZahl then

{ dann muss Zeiger^.next = nil gewesen sein,
d.h. Zeiger zeigt auf das letzte Element.
Da dessen info-Komponente <> inZahl ist,
kommt inZahl nicht in der Liste vor. }

Zeiger := nil
end;
ListenElemSuchen2 := Zeiger

end; { ListenElemSuchen2 }

10

Berechnung der Fakultät

program Fakultaet (input, output);
{ berechnet die Fakultaet einer einzulesenden
natuerlichen Zahl }
type
tNatZahl = 0..maxint;
var
i : tNatZahl; { Laufvariable }
Zahl, { einzulesende Zahl }
Ergebnis : integer;
begin
write ('Fuer welche Zahl soll die Fakultaet ',
'berechnet werden? ');
readln (Zahl);
if Zahl < 0 then
writeln ('Fuer negative Zahlen ist die ',
'Fakultaet nicht definiert.')
else
begin
Ergebnis := 1; { Initialisierung }
for i := 1 to Zahl do
Ergebnis := Ergebnis * i;
writeln ('Die Fakultaet von ', Zahl, ' lautet ',
Ergebnis, '.')
end
end. { Fakultaet }

11

Der größte gemeinsame Teiler

program ggTBerechnung (input, output);
{ berechnet den groessten gemeinsamen Teiler zweier
einzulesender integer-Zahlen x und y groesser Null }
var
x,
y : integer;
begin
writeln ('Bitte geben Sie 2 natuerliche Zahlen > 0 ',
'ein:');
readln (x);
readln (y);
if (x <= 0) or (y <= 0) then
writeln ('Eingabefehler!')
else
begin
write ('Der ggT von ', x, ' und ', y, ' ist ');
{ Ausgabe von x und y schon hier, da nach der
while-Schleife die Originalwerte nicht mehr
existieren }
while x <> y do
if x > y then
x := x - y
else
y := y - x;
writeln (x, '.')
end
end. { ggTBerechnung }

12

Folgen Maximum (Mit Array)
liest eine Folge von 5 integer-Zahlen ein
und bestimmt das Maximum

program FolgenMaximum (input, output);
{ liest eine Folge von 5 integer-Zahlen ein
und bestimmt das Maximum }
const
FELDGROESSE = 5;
type
tIndex = 1..FELDGROESSE;
tZahlenFeld = array [tIndex] of integer;
var
Feld : tZahlenFeld;
Maximum : integer;
i : tIndex;
begin
{ Einlesen des Feldes }
writeln ('Geben Sie ', FELDGROESSE:2, ' Werte ein:');
for i := 1 to FELDGROESSE do
readln (Feld[i]);
{ Bestimmen des Maximums }
Maximum := Feld[1];
for i := 2 to FELDGROESSE do
if Feld[i] > Maximum then
Maximum := Feld[i];
{ Ausgabe des Maximums }
writeln ('Die groesste Zahl ist ', Maximum, '.')
end. { FolgenMaximum }

13

program VokaleUndKonsonanten (input, output);
{ bestimmt in einem einzulesenden Satz die Anzahl der
vorkommenden Vokale und Konsonanten }
type
tBuchst = 'a'..'z';
tNatZahl = 0..maxint;
tHaeufigkeit = array [tBuchst] of tNatZahl;
var
Anzahl : tHaeufigkeit;
Zeichen : char;
Gesamtzahl,
Vokalzahl : tNatZahl;

begin
{ Initialisieren der Zaehler }
for Zeichen := 'a' to 'z' do
Anzahl[Zeichen] := 0;
Gesamtzahl := 0;
{ Zeichenweises Einlesen des Textes
und Aufaddieren der Zaehler }
read (Zeichen);
while Zeichen <> '.' do
begin
if (Zeichen >= 'a') and (Zeichen <= 'z') then
begin
Anzahl[Zeichen] := Anzahl[Zeichen] + 1;
Gesamtzahl := Gesamtzahl + 1
end; { if }
read (Zeichen)
end; { while-Schleife }
writeln;
{ Ausgabe der Statistik }
Vokalzahl := Anzahl['a'] + Anzahl['e'] + Anzahl['i'] +
Anzahl['o'] + Anzahl['u'];
writeln ('Anzahl der Vokale: ', Vokalzahl, '.');
write ('Anzahl der Konsonanten: ');
writeln (Gesamtzahl - Vokalzahl, '.')
end. { VokaleUndKonsonanten }

14

Lesen einer Matrix und Berechnen der Zeilensumme

const
ZEILENMAX = 3;
SPALTENMAX = 4;
type
tZeile = 1..ZEILENMAX;
tSpalte = 1..SPALTENMAX;
tMatrix = array [tZeile, tSpalte] of integer;
tZeilensumme = array [tZeile] of integer;
tSpaltensumme = array [tSpalte] of integer;
var
A : tMatrix;
B : tZeilensumme;
C : tSpaltensumme;
i : tZeile;
j : tSpalte;
begin
{ Lesen der Matrixwerte in A }
for i := 1 to ZEILENMAX do
for j := 1 to SPALTENMAX do
readln (A[i, j]);
{ Berechnen der Zeilensumme in B }
for i := 1 to ZEILENMAX do
begin
B[i] := 0;
for j := 1 to SPALTENMAX do
B[i] := B[i] + A[i, j]
end;

15

procedure Zahlenliste (var outListe : tRefListe ) ;
{ liest integer-Zahlen von der Tastatur ein und speichertsie in der Reihenfolge der Eingabe in der linearen Liste
outListe; Null beendet die Eingabe }

var
Zahl : integer;
AnfListe, EndListe, hilf : tRefListe;

begin
AnfListe := nil;
writeln ('Bitte natuerliche Zahlen eingeben, 0=Ende!');
read (Zahl) ;
while Zahl o 0 do begin
new (hilf) ;
hilf^.info := Zahl;
hilf^.next := nil;
if AnfListe = nil then begin
{ erste Zahl, Zeiger initialisieren }
AnfListe := hilf;
EndListe := hilf
end
eise begin
{ zweite und weitere Zahlen } EndListe^.next := hilf;
EndListe := hilf
end;
readln (Zahl)

end; { while }

outListe := AnfListe end; { Zahlenliste }