Loesung3

Lösung 5.1
Schleifen
1. while (x < 5)
{
x = x + 1; 
}
if (x < 5) then
do {
x = x + 1;
}
while (x < 5)
while B
{
A

}
if B then
do {
A
}
while B
do {
x = x + 1; 
}
while (x < 5)
x = x + 1;
while (x < 5) {
x = x + 1;
}
do {
A

}
while B
A
while B {
A
}
2. 1: if x >= 5 goto 2
x = x + 1;
goto 1
2: ...
1: if !B goto 2
A
goto 1
2: ...
3. 1: x = x + 1;
if x < 5 goto 1
2: ...
1: A
if B goto 1
2: ...
Lösung 5.2
1.
2.
Spiel des Lebens: Aufgabe
Überlegen Sie sich Rahmenbedingungen für das Spiel des Lebens
(Anhang B)
Formalisieren Sie dieses Problem
Gegeben ist:
Eine zweidimensionales „Spielfeld“
Annahme:
die Grenzen werden verbunden.
Auch möglich: „Unendliche“ Grenzen, „abschneidende“ Grenzen
Anfangszustand:
beliebige Nöpelpositionen im Spielfeld
Regeln:
entsprechend der Spielregeln für „Spiel des Lebens“
Gesucht:
„Zwischenzustand“ nach beliebigen Generation (entsprechend der Regeln)
Optional: Erkennung von „Endzuständen“
Lösung 5.2
Spiel des Lebens: Ansätze
3. Stellen sie einen umgangssprachlichen Lösungsansatz auf
Entwurf der Datenstrukturen - zwei Ansätze:
Der Spielfeldzustand wird als zweidimensionales Feld repräsentiert
Der Spielfeldzustand wird über die Positionen der Nöpel präsentiert
Entwurf des Algorithmus
act_state = Startzustand
solange kein Endzustand {
get_next_state (act_state, next_state);
}
zwei entsprechende Ansätze:
get_next_state (In: act_state, Out: next_state)
Der Spielfeldzustand wird als zweidimensionales Feld repräsentiert:
{ durchlaufe Felder und setze Nöpel „entsprechend“ }
Der Spielfeldzustand wird über die Positionen der Nöpel präsentiert:
{ durchlaufe Nöpelliste und setze Nöpel „entsprechend“ }
Vor- / Nachteile ?
Lösung 5.2
Spiel des Lebens: Feld
 0,1,4,5,6,7,8
 2,3
3
3. a) Der Spielfeldzustand wird als zweidimensionales Feld repräsentiert
get_next_state (In: act_state, Out: next_state)
{
// determine survivors
durchlaufe act_state // zweifach-verschachtelte Schleife
{
falls act_state[act_field] hat 2,3 Nachbarn in act_state
setze next_state[act_field]
}
// determine babies
durchlaufe next_state // zweifach-verschachtelte Schleife
{
falls next_state[act_field] hat 3 Nachbarn in act_state
setze next_state[act_field]
}
}
Lösung 5.2
Spiel des Lebens: Liste
 0,1,4,5,6,7,8
 2,3
3
3. b) Der Spielfeldzustand wird über die Positionen der Nöpel präsentiert
get_next_state (In: act_state, Out: next_state)
{
durchlaufe act_state // einfache Schleife durch Nöpelliste
{
// determine survivors
find_neighbors(act_nöpel, no_of_neighbors)
falls no_of_neighbors = 2 oder 3
kopiere act_nöpel nach next_state
// determine babies
durchlaufe nachbar_nöpel von act_nöpel // max. 8
{
find_neighbors(nachbar_nöpel, no_of_neighbors)
falls no_of_neighbors = 3
kopiere nachbar_nöpel nach next_state
}
}
}
Lösung 5.2
Spiel des Lebens: Strukturen
3. Stellen sie einen umgangssprachlichen Lösungsansatz auf
Entwurf der Datenstrukturen - zwei Ansätze:
Der Spielfeldzustand wird als zweidimensionales Feld repräsentiert
act_state: array [1..max_reihen][1..max_spalten] of boolean;
0
0
1
0
0
0
0
0
1
1
1
0
0
0
0
...
0
1
0
0
0
0
...
Der Spielfeldzustand wird über die Positionen der Nöpel präsentiert
typedef struct nöpel {reihe: int;
spalte: int ; // next_nöpel: *nöpel
} ;
act_state: array [1..max_nöpel] of nöpel;
1
3
2
2
2
3
2
4
3
3
...
Lösung 5.2
Spiel des Lebens: Komplexität
6. Bewerten Sie den Algorithmus bezüglich seine Laufzeit und seines
Platzbedarfes
get_next_state (In: act_state, Out: next_state)
{
durchlaufe act_state // einfache Schleife durch Nöpelliste
{
// determine survivors
find_neighbors(act_nöpel, no_of_neighbors) // Durchsuche
// alle Nöpel
falls no_of_neighbors = 2 oder 3
kopiere act_nöpel nach next_state
// determine babies
durchlaufe nachbar_nöpel von act_nöpel // max. 8
{
find_neighbors(nachbar_nöpel, no_of_neighbors)
falls no_of_neighbors = 3
kopiere nachbar_nöpel nach next_state
}
} // Zeit: Nöpel * ( Nöpel + ( 8 * Nöpel ) ) = 9 * Nöpel 2
}
// Platz: 2 * Nöpel
Lösung 5.3
Rekursion
1. Programmieren Sie die Fakultätsfunktion
fakultaet (IN: n:integer, OUT: result:integer) {
if (n == 0) then result = 1;
else {
fakultaet (n-1, result);
result = result * n;
}
}
fakultaet (IN: n:integer, OUT: result:integer) {
result; old_result : int;
// declaration
result = 1; old_result = 1 // initialization
for i=1 to n {
result = i * old_result;
old_result = result
}
}
// Anzahl Multiplikationen in beiden Fällen proportional n
Lösung 5.4
Acht Damen Problem
1. siehe Homepage