Demoklausur Allgemeine Informatik II (SS 2004) mit L¨osungen

(1)

mit L¨ osungen

Dies ist eine Sammlung von 7 Aufgaben, die der Klausur am 10. Juli nahe- kommen.

Verzeichnis der Aufgaben Seite 1: BNF-Grammatik Seite 3: Rekursion

Seite 5: Rekursion II Seite 7: Lineare Listen Seite 9: Lineare Listen II Seite 11: Typerweiterungen

Seite 13: FIRST, FOLLOW und LL(1)

(2)

Aufgabe 1 (BNF-Grammatik)

Gegeben sei folgende BNF-Grammatik mit dem Startsymbol hPedigreei:

hPedigreei −→ hNamei

hPedigreei −→ hNameihParentsi hParentsi −→ hPersonihPersoni hPersoni −→ () | (hPedigreei)

hNamei −→ hLetteri | hLetterihNamei hLetteri −→ A | ... | Z | a | ... | z

Uberpr¨ ¨ ufen Sie f¨ ur jede der folgenden Strings, ob es sich dabei um S¨ atze handelt, die von dieser Grammatik erkannt werden. Falls dies zutrifft, ist eine formelle Ableitung anzugeben. Leerzeichen sind zu ignorieren.

(a) Charles

(b) Charles ()

(c) Charles (Elizabeth)

(d) Charles (() Philipp)

(e) Charles () (Philipp)

(f) Charles (Elizabeth) (Philipp)

(3)

(a)

hPedigreei −→ hNamei

−→ Charles

(b) wird nicht erkannt, weil wenn die Eltern genannt werden, f¨ ur beide jeweils ein Klammerpaar anzugeben ist.

(c) wird ebenso nicht erkannt.

(d) wird ebenfalls nicht erkannt.

(e)

hPedigreei −→ hNamei hParentsi

−→ Charles hParentsi

−→ Charles hPersoni hPersoni

−→ Charles () hPersoni

−→ Charles () (hPedigreei)

−→ Charles () (hNamei)

−→ Charles () (Philipp)

(f)

hPedigreei −→ hNamei hParentsi

−→ Charles hParentsi

−→ Charles hPersoni hPersoni

−→ Charles (hPedigreei) hPersoni

−→ Charles (hNamei) hPersoni

−→ Charles (Elizabeth) hPersoni

−→ Charles (Elizabeth) (hPedigreei)

−→ Charles (Elizabeth) (hNamei)

−→ Charles (Elizabeth) (Philipp)

(4)

Aufgabe 2 (Rekursion) Die G¨ obelsche Folge ist folgendermaßen definiert:

x

₀

= 1

x

n

= 1 + x

²₀

+ x

²₁

+ · · · + x

²_n−1

n

Schreiben Sie eine rekursive Prozedur, die x

_n

f¨ ur ein gegebenes n berechnet.

(5)

PROCEDURE Goebel(n: INTEGER) : INTEGER;

VAR

sum: INTEGER;

i: INTEGER;

gi: INTEGER;

BEGIN

ASSERT(n >= 0);

IF n = 0 THEN RETURN 1 ELSE

sum := 1;

i := 0;

WHILE i <= n-1 DO gi := Goebel(i);

INC(sum, gi*gi);

INC(i);

END;

RETURN sum DIV n END;

END Goebel;

(6)

Aufgabe 3 (Rekursion II)

Schreiben Sie eine rekursive Funktionsprozedur zur Berechnung der n-ten Potenz einer reellen Zahl x mit x vom Typ REAL und n vom Typ IN- TEGER. Um die Zahl der Multiplikationen gering zu halten, sind folgende Zusammenh¨ ange zu verwenden:

x

ⁿ

= 1

x

⁻ⁿ

f¨ ur n < 0

x

ⁿ

= x

^n/2

· x

^n/2

f¨ ur gerade n

x

ⁿ

= x

^(n−1)/2

· x

^(n−1)/2

· x f¨ ur ungerade n

(7)

PROCEDURE Power(x: REAL; n: INTEGER) : REAL;

VAR

factor: REAL;

BEGIN

IF n < 0 THEN

RETURN 1 / Power(x, -n) ELSIF n = 0 THEN

RETURN 1

ELSIF ODD(n) THEN

factor := Power(x, (n-1) DIV 2);

RETURN factor * factor * x ELSE

factor := Power(x, n DIV 2);

RETURN factor * factor END;

END Power;

(8)

Aufgabe 4 (Lineare Listen)

(a) Es seien folgende Typen gegeben:

TYPE

Author = ARRAY 64 OF CHAR;

Title = ARRAY 80 OF CHAR;

Book = POINTER TO BookRec;

BookRec = RECORD

author: Author;

title: Title;

next: Book; (* next book in list *) END;

ListOfBooks = RECORD

head: Book; (* linear list of books *)

count: INTEGER; (* number of books in list *) END;

Erg¨ anzen Sie folgende Prozedur, die alle B¨ ucher, die von dem angegebenen Autor stammen, aus der Liste books entfernen und in die Liste results einf¨ ugen soll. Dabei spielt es keine Rolle, in welcher Reihenfolge die aus- gew¨ ahlten B¨ ucher in der Liste results vorkommen.

PROCEDURE ExtractBooksByAuthor(VAR books: ListOfBooks;

author: ARRAY OF CHAR;

VAR results: ListOfBooks);

(b) Welche Komplexit¨ at hat die Prozedur ExtractBooksByAuthor, wenn

n der Zahl der B¨ ucher in der Liste books und m der Zahl der B¨ ucher des

angegebenen Autors entspricht?

(9)

(a)

PROCEDURE ExtractBooksByAuthor(VAR books: ListOfBooks;

author: ARRAY OF CHAR;

VAR results: ListOfBooks);

VAR

prev, ptr, next: Book;

BEGIN

prev := NIL; ptr := books.head;

WHILE ptr # NIL DO

IF ptr.author = author THEN IF prev = NIL THEN

books.head := ptr.next;

ELSE

prev.next := ptr.next;

END;

next := ptr.next;

ptr.next := results.head; results.head := ptr;

DEC(books.count); INC(results.count);

ptr := next;

ELSE

prev := ptr; ptr := ptr.next;

END;

END ExtractBooksByAuthor;

(b) O(n)

(10)

Aufgabe 5 (Lineare Listen II)

Folgende Typ-Deklarationen seien gegeben:

TYPE

Element = POINTER TO ElementRec;

ElementRec = RECORD

value: INTEGER;

next: Element; (* next element in list *) END;

ListOfElements = RECORD

head: Element; (* points to first element in list ) tail: Element; ( points to last element in list *) count: INTEGER;

END;

(a) F¨ ullen Sie folgende Prozedur aus, die die beiden Listen list1 und list2 vereinigt und das Resultat in list1 zur Verf¨ ugung stellt, w¨ ahrend list2 zur leeren Liste wird:

PROCEDURE JoinLists(VAR list1, list2: ListOfElements);

(b) Welche Komplexit¨ at hat die Prozedur JoinLists, wenn n der Zahl der

Elemente aus der Liste list1 und m der Zahl der Elemente aus der Liste list2

entspricht?

(11)

(a)

PROCEDURE JoinLists(VAR list1, list2: ListOfElements);

BEGIN

IF list1.count = 0 THEN list1 := list2;

ELSE

list1.tail.next := list2.head;

list1.tail := list2.tail;

INC(list1.count, list2.count);

END;

list2.head := NIL; list2.tail := NIL; list2.count := 0;

END JoinLists;

(b) O(1)

(12)

Aufgabe 6 (Typerweiterungen)

Gegeben seien folgende Typdefinitionen:

TYPE

Partner = POINTER TO PartnerRec;

PartnerRec = RECORD name, address, phone: ARRAY 80 OF CHAR END;

Person = POINTER TO PersonRec;

PersonRec = RECORD (PartnerRec) title: ARRAY 12 OF CHAR END;

Employee = POINTER TO EmployeeRec;

EmployeeRec = RECORD (PersonRec)

office, department: ARRAY 16 OF CHAR END;

Company = POINTER TO CompanyRec;

CompanyRec = RECORD (PartnerRec) head: Employee END;

(a) Zeichnen Sie ein Diagramm, das die Typ-Hierarchie widerspiegelt.

(b) Bitte kreuzen Sie jeweils das Zutreffende an:

Aussage Korrekt Falsch

Employee ist eine Erweiterung von Partner Company ist eine Erweiterung von Person

Person ist eine direkte Erweiterung von Partner Partner ist eine Erweiterung von Company Hinzu kommen folgende Deklarationen:

VAR partner: Partner; person: Person;

employee: Employee; company: Company;

PROCEDURE Assign(VAR ptr: Partner; partner: Partner);

BEGIN

ptr := partner;

END Assign;

Geben Sie bei folgenden Teilaufgaben jeweils an, ob der jeweilige Programm- text vom Compiler akzeptiert wird und ob er zur Laufzeit fehlerfrei durchl¨ auft.

Begr¨ unden Sie Ihre Angaben jeweils durch die Angaben der statischen und dynamischen Typen von ptr und partner innerhalb von Assign.

(c) NEW(partner); NEW(employee); Assign(partner, employee);

(d) NEW(company); NEW(person); Assign(company, person);

(e) NEW(employee); NEW(person); Assign(employee, person);

(13)

(a)

Partner

Person Company

Employee

(b)

Aussage Korrekt Falsch

Employee ist eine Erweiterung von Partner X

Company ist eine Erweiterung von Person X Person ist eine direkte Erweiterung von Partner X

Partner ist eine Erweiterung von Company X (c), (d), und (e)

ptr partner

Aufgabe statisch dynamisch statisch dynamisch (c) Partner Partner Partner Employee (d) Partner Company Partner Person (e) Partner Employee Partner Person

Alle Varianten werden vom Compiler akzeptiert. Laufzeitfehler gibt es bei

(d), weil Person keine Erweiterung von Company ist und bei (e), weil Person

keine Erweiterung von Employee ist.

(14)

Aufgabe 7 (FIRST, FOLLOW und LL(1))

Gegeben sei folgende BNF-Grammatik mit dem Startsymbol hListi:

hListi −→ (hListOfElementsi) hListOfElementsi −→

hListOfElementsi −→ hCommaSeparatedListi hCommaSeparatedListi −→ hElementi

hCommaSeparatedListi −→ hElementi,hCommaSeparatedListi hElementi −→ hListi

hElementi −→ hDigitsi hDigitsi −→ hDigiti

hDigitsi −→ hDigitihDigitsi

hDigiti −→ 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

(a) Geben Sie jeweils die FIRST- und FOLLOW-Mengen an:

Non-Terminal FIRST FOLLOW

hListi

hListOfElementsi

hCommaSeparatedListi hElementi

hDigitsi hDigiti

(b) Ist diese Grammatik LL(1)? Begr¨ unden Sie bitte Ihre Antwort.

(15)

(a)

Non-Terminal FIRST FOLLOW

hListi “(” $, “,”, “)”

hListOfElementsi , “(”, “0”..“9” “)”

hCommaSeparatedListi “(”, “0”..“9” “)”

hElementi “(”, “0”..“9” “,”, “)”

hDigitsi “0”..“9” “,”, “)”

hDigiti “0”..“9” “0”..“9”, “,”, “)”

(b) Diese Grammatik ist nicht LL(1), da beispielsweise bei hCommaSeparatedListi

beide Alternativen jeweils mit hElementi beginnen und somit die entsprechen-

den FIRST-Mengen nicht disjunkt sind.