12. Felder (Arrays) II. Caesar-Code, Strings, Lindenmayer-Systeme, Mehrdimensionale Felder, Vektoren von Vektoren, Kürzeste Wege
|
|
|
- Alexander Morgenstern
- vor 6 Jahren
- Abrufe
Transkript
1 Felder (Arrays) II Caesar-Code, Strings, Lindenmayer-Systeme, Mehrdimensionale Felder, Vektoren von Vektoren, Kürzeste Wege
2 Caesar-Code 374 Ersetze jedes druckbare Zeichen in einem Text durch seinen Vor-Vor-Vorgänger. (32) (124)! (33) (125)... D (68) A (65) E (69) B (66)... (126) { (123)
3 Caesar-Code 374 Ersetze jedes druckbare Zeichen in einem Text durch seinen Vor-Vor-Vorgänger. (32) (124)! (33) (125)... D (68) A (65) E (69) B (66)... (126) { (123)
4 Caesar-Code: // Program: caesar_encrypt.cpp // encrypts a text by applying a cyclic shift of 3 #include<iostream> #include<cassert> #include<ios> // for std::noskipws Hauptprogramm // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s); int main () { std::cin >> std::noskipws; // don t skip whitespaces! // encryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; return 0; 375
5 Caesar-Code: Hauptprogramm // Program: caesar_encrypt.cpp // encrypts a text by applying a cyclic shift of 3 #include<iostream> #include<cassert> #include<ios> // for std::noskipws // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s); int main () { std::cin >> std::noskipws; // don t skip whitespaces! Leerzeichen und Zeilenumbrüche sollen nicht ignoriert werden // encryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; return 0; 375
6 Caesar-Code: Hauptprogramm // Program: caesar_encrypt.cpp // encrypts a text by applying a cyclic shift of 3 #include<iostream> #include<cassert> #include<ios> // for std::noskipws // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s); int main () { std::cin >> std::noskipws; // don t skip whitespaces! // encryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; return 0; Konversion nach bool: liefert false genau dann, wenn die Eingabe leer ist. 375
7 Caesar-Code: // Program: caesar_encrypt.cpp // encrypts a text by applying a cyclic shift of 3 #include<iostream> #include<cassert> #include<ios> // for std::noskipws Hauptprogramm // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s); int main () { std::cin >> std::noskipws; // don t skip whitespaces! // encryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; return 0; Behandelt nur die druckbaren Zeichen. 375
8 Caesar-Code: shift-funktion 376 // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s) { assert (s < 95 && s > 95); if (c >= 32 && c <= 126) { if (c + s > 126) c += (s 95); else if (c + s < 32) c += (s + 95); else c += s;
9 Caesar-Code: shift-funktion 376 // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s) { assert (s < 95 && s > 95); if (c >= 32 && c <= 126) { if (c + s > 126) c += (s 95); else if (c + s < 32) c += (s + 95); else c += s; Call by reference!
10 Caesar-Code: shift-funktion 376 // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s) { assert (s < 95 && s > 95); if (c >= 32 && c <= 126) { if (c + s > 126) c += (s 95); else if (c + s < 32) c += (s + 95); else c += s; Normale Verschiebung
11 Caesar-Code: shift-funktion 376 // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s) { assert (s < 95 && s > 95); if (c >= 32 && c <= 126) { if (c + s > 126) c += (s 95); else if (c + s < 32) c += (s + 95); else c += s; Überlauf 95 zurück!
12 Caesar-Code: shift-funktion 376 // PRE: s < 95 && s > 95 // POST: if c is one of the 95 printable ASCII characters, c is // cyclically shifted s printable characters to the right void shift (char& c, int s) { assert (s < 95 && s > 95); if (c >= 32 && c <= 126) { if (c + s > 126) c += (s 95); else if (c + s < 32) c += (s + 95); else c += s; Unterlauf 95 vorwärts!
13 377./caesar encrypt < power8.cpp Moldo^j7 mltbo5+ mm O^fpb ^ krj_bo ql qeb bfdeqe mltbo+ fk irab 9flpqob^j; fkq j^fk%& x fkmrq pqa77 lrq 99 ~@ljmrqb ^[5 clo ^ :< ~8 fkq ^8 pqa77 fk ;; ^8 ljmrq^qflk fkq _ : ^ ^8 _ : ^[/ _ : _ _8 _ : ^[1 lrqmrq _ _) f+b+) ^[5 pqa77 lrq 99 ^ 99 ~[5 : ~ 99 _ _ 99 ~+Yk~8 obqrok -8 z
14 377./caesar encrypt < power8.cpp Moldo^j7 mltbo5+ mm O^fpb ^ krj_bo ql qeb bfdeqe mltbo+ Program = Moldo j fk irab 9flpqob^j; fkq j^fk%& x fkmrq pqa77 lrq 99 ~@ljmrqb ^[5 clo ^ :< ~8 fkq ^8 pqa77 fk ;; ^8 ljmrq^qflk fkq _ : ^ ^8 _ : ^[/ _ : _ _8 _ : ^[1 lrqmrq _ _) f+b+) ^[5 pqa77 lrq 99 ^ 99 ~[5 : ~ 99 _ _ 99 ~+Yk~8 obqrok -8 z
15 Caesar-Code: Entschlüsselung 378 int main () { std::cin >> std::noskipws; // don t skip whitespaces! // decryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; return 0;
16 Caesar-Code: Entschlüsselung 378 int main () { std::cin >> std::noskipws; // don t skip whitespaces! // decryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; Jetzt: Verschiebung um 3 nach rechts return 0;
17 Caesar-Code: Entschlüsselung 378 int main () { std::cin >> std::noskipws; // don t skip whitespaces! // decryption loop char next; while (std::cin >> next) { shift (next, 3); std::cout << next; Jetzt: Verschiebung um 3 nach rechts return 0; Interessante Art, power8.cpp auszugeben:./caesar_encrypt < power8.cpp./caeser_decrypt
18 Strings als Felder 379 sind repräsentierbar mit zugrundeliegendem Typ char char text[] = { b, o, o, l
19 Strings als Felder 379 sind repräsentierbar mit zugrundeliegendem Typ char char text[] = { b, o, o, l definiert ein Feld der Länge 4, das dem Text bool entspricht.
20 Strings als Felder 379 sind repräsentierbar mit zugrundeliegendem Typ char char text[] = { b, o, o, l können auch durch String-Literale definiert werden char text[] = "bool"
21 Strings als Felder 379 sind repräsentierbar mit zugrundeliegendem Typ char char text[] = { b, o, o, l können auch durch String-Literale definiert werden char text[] = "bool" definiert ein Feld der Länge 5, das dem Text bool entspricht und null-terminiert ist. Extrazeichen 0 wird am Ende angehängt Der Text speichert seine Länge
22 Strings als Felder 379 sind repräsentierbar mit zugrundeliegendem Typ char char text[] = { b, o, o, l können auch durch String-Literale definiert werden char text[] = "bool" können nur mit konstanter Grösse definiert werden
23 Texte 380 können mit dem Typ std::string aus der Standardbibliothek repräsentiert werden. std::string text = "bool"; definiert einen String der Länge 4
24 Texte 380 können mit dem Typ std::string aus der Standardbibliothek repräsentiert werden. std::string text = "bool"; definiert einen String der Länge 4
25 Strings: gepimpte char-felder 381 Ein std::string... kennt seine Länge text.length()
26 Strings: gepimpte char-felder 381 Ein std::string... kann mit variabler Länge initialisiert werden std::string text (n, a )
27 Strings: gepimpte char-felder 381 Ein std::string... versteht Vergleiche if (text1 == text2)...
28 Lindenmayer-Systeme (L-Systeme) 382 Fraktale aus Strings und Schildkröten
29 Definition und Beispiel 383 Alphabet Σ { F, +,
30 Definition und Beispiel 383 Alphabet Σ Σ : alle endlichen Wörter über Σ { F, +,
31 Definition und Beispiel 383 Alphabet Σ Σ : alle endlichen Wörter über Σ Produktion P : Σ Σ { F, +, c P (c) F F + F + + +
32 Definition und Beispiel 383 Alphabet Σ Σ : alle endlichen Wörter über Σ Produktion P : Σ Σ Startwort s Σ { F, +, c P (c) F F + F F
33 Definition und Beispiel 383 Alphabet Σ Σ : alle endlichen Wörter über Σ Produktion P : Σ Σ Startwort s Σ { F, +, c P (c) F F + F Definition Das Tripel L = (Σ, P, s 0 ) ist ein L-System. F
34 384 Die beschriebene Sprache Wörter w 0, w 1, w 2,... Σ : P ( F ) = F + F + w 0 := s w 0 := F
35 384 Die beschriebene Sprache Wörter w 0, w 1, w 2,... Σ : P ( F ) = F + F + w 0 := s w 0 := F w 1 := P (w 0 ) w 1 := F + F +
36 384 Die beschriebene Sprache Wörter w 0, w 1, w 2,... Σ : P ( F ) = F + F + w 0 := s w 0 := F w 1 := P (w 0 ) w 2 := P (w 1 ) w 1 := F + F + w 2 := F + F + + F + F + + Definition P (c 1 c 2... c n ) := P (c 1 )P (c 2 )... P (c n )
37 384 Die beschriebene Sprache Wörter w 0, w 1, w 2,... Σ : P ( F ) = F + F + w 0 := s w 1 := P (w 0 ) w 0 := F F + F + w 1 := F + F + w 2 := P (w 1 ) w 2 := F + F + + F + F + + P ( F ) P ( + ) P ( F ) P ( + ) Definition P (c 1 c 2... c n ) := P (c 1 )P (c 2 )... P (c n )
38 384 Die beschriebene Sprache Wörter w 0, w 1, w 2,... Σ : P ( F ) = F + F + w 0 := s w 0 := F w 1 := P (w 0 ) w 2 := P (w 1 ) w 1 := F + F + w 2 := F + F + + F + F + +..
39 Turtle-Grafik 385 Schildkröte mit Position und Richtung
40 Turtle-Grafik 385 Schildkröte mit Position und Richtung Schildkröte versteht 3 Befehle: F : Gehe einen Schritt vorwärts + : Drehe dich um 90 Grad : Drehe dich um 90 Grad
41 Turtle-Grafik 385 Schildkröte mit Position und Richtung Schildkröte versteht 3 Befehle: F : Gehe einen Schritt vorwärts + : Drehe dich um 90 Grad : Drehe dich um 90 Grad
42 Turtle-Grafik 385 Schildkröte mit Position und Richtung Schildkröte versteht 3 Befehle: F : Gehe einen Schritt vorwärts + : Drehe dich um 90 Grad : Drehe dich um 90 Grad Spur
43 Turtle-Grafik 385 Schildkröte mit Position und Richtung Schildkröte versteht 3 Befehle: F : Gehe einen Schritt vorwärts + : Drehe dich um 90 Grad : Drehe dich um 90 Grad
44 Turtle-Grafik 385 Schildkröte mit Position und Richtung Schildkröte versteht 3 Befehle: F : Gehe einen Schritt vorwärts + : Drehe dich um 90 Grad : Drehe dich um 90 Grad
45 Wörter zeichnen! 386 w 1 = F + F +
46 Wörter zeichnen! 386 w 1 = F + F +
47 Wörter zeichnen! 386 w 1 = F + F +
48 Wörter zeichnen! 386 w 1 = F + F +
49 Wörter zeichnen! 386 w 1 = F + F +
50 Wörter zeichnen! 386 w 1 = F + F +
51 lindenmayer.cpp: Hauptprogramm 387 Wörter w 0, w 1, w 2,... w n Σ : std::string int main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n; std::string w = "F"; for (unsigned int i = 0; i < n; ++i) w = next_word (w); draw_word (w); return 0;
52 lindenmayer.cpp: Hauptprogramm 387 Wörter w 0, w 1, w 2,... w n Σ : std::string int main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n; std::string w = "F"; w = w 0 = F for (unsigned int i = 0; i < n; ++i) w = next_word (w); draw_word (w); return 0;
53 lindenmayer.cpp: Hauptprogramm 387 Wörter w 0, w 1, w 2,... w n Σ : std::string int main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n; std::string w = "F"; for (unsigned int i = 0; i < n; ++i) w = next_word (w); w = w i w = w i+1 draw_word (w); return 0;
54 lindenmayer.cpp: Hauptprogramm 387 Wörter w 0, w 1, w 2,... w n Σ : std::string int main () { std::cout << "Number of iterations =? "; unsigned int n; std::cin >> n; std::string w = "F"; for (unsigned int i = 0; i < n; ++i) w = next_word (w); draw_word (w); Zeichne w = w n! return 0;
55 lindenmayer.cpp: next word 388 // POST: replaces all symbols in word according to their // production and returns the result std::string next_word (const std::string& word) { std::string next; for (unsigned int k = 0; k < word.length(); ++k) next += production (word[k]); return next;
56 lindenmayer.cpp: next word 388 // POST: replaces all symbols in word according to their // production and returns the result std::string next_word (const std::string& word) { std::string next; for (unsigned int k = 0; k < word.length(); ++k) next += production (word[k]); return next;
57 lindenmayer.cpp: next word 388 // POST: replaces all symbols in word according to their // production and returns the result std::string next_word (const std::string& word) { std::string next; for (unsigned int k = 0; k < word.length(); ++k) next += production (word[k]); return next; // POST: returns the production of c std::string production (const char c) { switch (c) { case F : return "F+F+"; default: return std::string (1, c); // trivial production c > c
58 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { case F : turtle::forward(); break; case + : turtle::left(90); break; case : turtle::right(90);
59 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { springe zum case, der dem Wert von word[k] entspricht case F : turtle::forward(); break; case + : turtle::left(90); break; case : turtle::right(90);
60 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { case F : turtle::forward(); Vorwärts! (Funktion aus unserer Schildkröten-Bibliothek) break; case + : turtle::left(90); break; case : turtle::right(90);
61 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { case F : turtle::forward(); break; Überspringe die folgenden cases case + : turtle::left(90); break; case : turtle::right(90);
62 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { case F : turtle::forward(); break; case + : turtle::left(90); break; case : turtle::right(90); Drehe dich um 90 Grad! (Funktion aus unserer Schildkröten-Bibliothek)
63 lindenmayer.cpp: draw word 389 // POST: draws the turtle graphic interpretation of word void draw_word (const std::string& word) { for (unsigned int k = 0; k < word.length(); ++k) switch (word[k]) { case F : turtle::forward(); break; case + : turtle::left(90); break; case : turtle::right(90); Drehe dich um -90 Grad! (Funktion aus unserer Schildkröten-Bibliothek)
64 L-Systeme: Erweiterungen 390 Beliebige Symbole ohne grafische Interpretation (dragon.cpp) Beliebige Drehwinkel (snowflake.cpp) Sichern und Wiederherstellen des Schildkröten-Zustandes Pflanzen (bush.cpp)
65 L-System-Challenge: amazing.cpp! 391
66 Mehrdimensionale Felder 392 sind Felder von Feldern dienen zum Speichern von Tabellen, Matrizen,...
67 Mehrdimensionale Felder 392 sind Felder von Feldern int a[2][3] a hat zwei Elemente, und jedes von ihnen ist ein Feld der Länge 3 mit zugrundeliegendem Typ int
68 Mehrdimensionale Felder 392 sind Felder von Feldern int a[2][3] a hat zwei Elemente, und jedes von ihnen ist ein Feld der Länge 3 mit zugrundeliegendem Typ int Im Speicher: flach a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2] a[0] a[1]
69 Mehrdimensionale Felder 392 sind Felder von Feldern int a[2][3] a hat zwei Elemente, und jedes von ihnen ist ein Feld der Länge 3 mit zugrundeliegendem Typ int Im Kopf: Matrix, Tabelle, etc. Spalten Zeilen a[0][0] a[0][1] a[0][2] 1 a[1][0] a[1][1] a[1][2]
70 Mehrdimensionale Felder 393 sind Felder von Feldern von Feldern... T a[expr 1 ]... [expr k ] Konstante Ausdrücke! a hat expr 1 Elemente und jedes von ihnen ist ein Feld mit expr 2 Elementen, von denen jedes ein Feld mit expr 3 Elementen ist,...
71 Mehrdimensionale Felder 394 Initialisierung: int a[2][3] = { {2,4,6,{1,3,
72 Mehrdimensionale Felder 394 Initialisierung: int a[][3] = { {2,4,6,{1,3,5 Erste Dimension kann weggelassen werden
73 Vektoren von Vektoren 395 Wie bekommen wir mehrdimensionale Felder mit variablen Dimensionen? Lösung: Vektoren von Vektoren Beispiel: Vektor der Länge n von Vektoren der Länge m: std::vector<?> a (n,?); Zugrundeliegender Typ des ersten Vektors?
74 Vektoren von Vektoren 395 Wie bekommen wir mehrdimensionale Felder mit variablen Dimensionen? Lösung: Vektoren von Vektoren Beispiel: Vektor der Länge n von Vektoren der Länge m: std::vector<?> a (n,?); Zugrundeliegender Typ des ersten Vektors? std::vector<int>, initialisiert mit Länge m: std::vector<int>(m)
75 Vektoren von Vektoren 395 Wie bekommen wir mehrdimensionale Felder mit variablen Dimensionen? Lösung: Vektoren von Vektoren Beispiel: Vektor der Länge n von Vektoren der Länge m: std::vector<std::vector<int> > a (n, std::vector<int>(m));
76 396 Anwendung: Kürzeste Wege Fabrik-Halle (n m quadratische Zellen) S T
77 Anwendung: Kürzeste Wege Fabrik-Halle (n m quadratische Zellen) Hindernis freie Zelle S Startposition des Roboters Zielposition des Roboters T
78 396 Anwendung: Kürzeste Wege Fabrik-Halle (n m quadratische Zellen) Hindernis freie Zelle S Startposition des Roboters Zielposition des Roboters Ziel: Finde den kürzesten Weg des Roboters von S nach T über freie Zellen! T
79 398 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen
80 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Län gen 398
81 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Startposition des Roboters Zielposition des 12 Roboters Kürzester Weg hat Länge Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Längen
82 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Startposition des Roboters Zielposition des 12 Roboters Kürzester Weg hat Länge Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Längen
83 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Startposition des Roboters Zielposition des 12 Roboters Kürzester Weg hat Länge Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Längen
84 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Startposition des Roboters Zielposition des 12 Roboters Kürzester Weg hat Länge Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Längen
85 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen Startposition des Roboters Zielposition des 12 Roboters Kürzester Weg hat Länge Das löst auch das Original- Problem: Starte in T; folge einem Weg mit sinkenden Längen
86 399 Ein (scheinbar) anderes Problem Finde die Längen der kürzesten Wege zu allen möglichen Zielen
87 401 Vorbereitung: Wächter (Sentinels) Zeile 0, Spalte 0 Zeile 0, Spalte m+1 S Umrandung der Halle mit Sentinels zur Vermeidung von Spezialfällen Zeile n, Spalte 0 Zeile n+1, Spalte m+1 T
88 402 Vorbereitung: Initiale Markierung start
89 404 Das Kürzeste-Wege-Programm // define a two dimensional // array of dimensions // (n+2) x (m+2) to hold the floor // plus extra walls around std::vector<std::vector<int> > floor (n+2, std::vector<int>(m+ 2)); // Einlesen der Hallenbeleung (weggelassen > handout)... // Waende for (int r=0; r<n+2; ++r) floor[r][0] = floor[r][m+1] = 2; for (int c=0; c<m+2; ++c) floor[0][c] = floor[n+1][c] = 2;
90 404 Das Kürzeste-Wege-Programm // define a two dimensional // array of dimensions Wächter (Sentinel) // (n+2) x (m+2) to hold the floor // plus extra walls around std::vector<std::vector<int> > floor (n+2, std::vector<int>(m+ 2)); // Einlesen der Hallenbeleung (weggelassen > handout)... // Waende for (int r=0; r<n+2; ++r) floor[r][0] = floor[r][m+1] = 2; for (int c=0; c<m+2; ++c) floor[0][c] = floor[n+1][c] = 2;
91 404 Das Kürzeste-Wege-Programm // define a two dimensional // array of dimensions // (n+2) x (m+2) to hold the floor // plus extra walls around std::vector<std::vector<int> > floor (n+2, std::vector<int>(m+ 2)); // Einlesen der Hallenbeleung (weggelassen > handout)... // Waende for (int r=0; r<n+2; ++r) floor[r][0] = floor[r][m+1] = 2; for (int c=0; c<m+2; ++c) floor[0][c] = floor[n+1][c] = 2; Spalten 0 und m+1 Zeilen 0 und n+1
92 407 Markierung aller Zellen mit ihren Weglängen Schritt 0: Alle Zellen mit Weglänge 0 0 T
93 Markierung aller Zellen mit ihren Weglängen Schritt 1: Alle Zellen mit Weglänge T Unmarkierte Nachbarn der Zellen mit Länge 0 407
94 Markierung aller Zellen mit ihren Weglängen Schritt 2: Alle Zellen mit Weglänge T Unmarkierte Nachbarn der Zellen mit Länge 1 407
95 Markierung aller Zellen mit ihren Weglängen Schritt 3: Alle Zellen mit Weglänge T Unmarkierte Nachbarn der Zellen mit Länge 2 407
96 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { bool progress = false; for (int r=1; r<n+1; ++r) for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break;
97 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { bool progress = false; for (int r=1; r<n+1; ++r) for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; Variable progress zeigt an, ob in einem Durchlauf durch alle Zellen Fortschritt gemacht wurde if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break;
98 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { bool progress = false; for (int r=1; r<n+1; ++r) Gehe über alle Zellen for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break;
99 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { Zelle schon markiert oder Hindernis bool progress = false; for (int r=1; r<n+1; ++r) for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break;
100 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { Ein Nachbar hat Weglänge i 1. Man bool progress = false; darf alle Nachbarn testen, da durch die for (int r=1; r<n+1; ++r) Wächter Nachbarn garantiert existieren. for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break;
101 408 Das Kürzeste-Wege-Programm Hauptschleife: finde und markiere alle Zellen mit Weglängen i = 1, 2, 3... for (int i=1;; ++i) { bool progress = false; for (int r=1; r<n+1; ++r) for (int c=1; c<m+1; ++c) { if (floor[r][c]!= 1) continue; if (floor[r 1][c] == i 1 floor[r+1][c] == i 1 floor[r][c 1] == i 1 floor[r][c+1] == i 1 ) { floor[r][c] = i; // label cell with i progress = true; if (!progress) break; Kein Fortschritt, alle erreichbaren Zellen markiert; fertig.
102 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d)
103 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d) Zielkoordinaten
104 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d) Solange Ziel nicht erreicht
105 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d) d: um eins kleinere Weglänge
106 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d) Markiere Zelle mit 3
107 409 Das Kürzeste-Wege-Programm Markieren des kürzesten Weges durch Rückwärtslaufen vom Ziel zum Start int r = tr; int c = tc; while (floor[r][c] > 0) { const int d = floor[r][c] 1; floor[r][c] = 3; if (floor[r 1][c] == d) r; else if (floor[r+1][c] == d) ++r; else if (floor[r][c 1] == d) c; else ++c; // (floor[r][c+1] == d) Gehe zu Nachbarzelle mit Weglänge d (existiert!) und wiederhole...
108 410 Markierung am Ende
109 412 Das Kürzeste-Wege-Programm Algorithmus: Breitensuche
110 412 Das Kürzeste-Wege-Programm Algorithmus: Breitensuche Das Programm kann recht langsam sein, weil für jedes i alle Zellen durchlaufen werden
111 412 Das Kürzeste-Wege-Programm Algorithmus: Breitensuche Das Programm kann recht langsam sein, weil für jedes i alle Zellen durchlaufen werden Verbesserung: durchlaufe jeweils nur die Nachbarn der Zellen mit Markierung i 1
112 413 Zeiger 13. Zeiger, Algorithmen, Iteratoren und Container I
113 Komische Dinge #include<iostream> #include<algorithm> int main() { int a[] = {3, 2, 1, 5, 4, 6, 7; // gib das kleinste Element in a aus std::cout << *std::min_element (a, a+ 5); return 0;
114 Komische Dinge #include<iostream> #include<algorithm> int main() { int a[] = {3, 2, 1, 5, 4, 6, 7; // gib das kleinste Element in a aus std::cout << *std::min_element (a, a+ 5); return 0;??????
115 Komische Dinge #include<iostream> #include<algorithm> int main() { int a[] = {3, 2, 1, 5, 4, 6, 7; // gib das kleinste Element in a aus std::cout << *std::min_element (a, a+ 5); return 0;?????? Dafür müssen wir zuerst Zeiger verstehen!
116 Swap mit Zeigern 415 void swap(int a, int b){ int t = a; a = b; b = t;... int x = 2; int y = 3; swap(&x, &y); std::cout << "x = " << x << "\n"; // 3 std::cout << "y = " << y << "\n"; // 2
117 Zeiger Typen 416 T* Zeiger-Typ zum zugrunde liegenden Typ T. Ein Ausdruck vom Typ T* heisst Zeiger (auf T).
118 Zeiger Typen 417 Wert eines Zeigers auf T ist die Adresse eines Objektes vom Typ T. Beispiele int* p; Variable p ist Zeiger auf ein int. float* q; Variable q ist Zeiger auf ein float.
119 Zeiger Typen 417 Wert eines Zeigers auf T ist die Adresse eines Objektes vom Typ T. int* p =...; adr (Ganzzahlwert) p = adr
10. Referenztypen. Referenztypen: Definition und Initialisierung, Call By Value, Call by Reference, Temporäre Objekte
288 10. Referenztypen Referenztypen: Definition und Initialisierung, Call By Value, Call by Reference, Temporäre Objekte Swap! // POST: values of x and y are exchanged void swap (int& x, int& y) { int
9. Referenztypen. Swap! Referenztypen: Definition. Referenztypen
Swap! 9. Referenztypen Referenztypen: Definition und Initialisierung, Call By Value, Call by Reference, Temporäre Objekte, Konstanten, Const-Referenzen 255 // POST: values of x and y are exchanged void
11. Referenztypen. Swap! Referenztypen. Referenztypen: Definition
380 Swap! 381 11. Referenztypen Referenztypen: Definition und Initialisierung, Call By Value, Call by Reference, Temporäre Objekte, Konstanten, Const-Referenzen Referenztypen 378 // POST: values of x and
Programmier-Befehle - Woche 8
Datentypen Array (mehrdim.) mehrdimensionale Massenvariable eines bestimmten Typs Definition: int my arr[2][3] = { {2, 1, 6}, {8, -1, 4} }; Zugriff: my arr[1][1] = 8 * my arr[0][2]; (Die Definition kann
Lindenmayer-Systeme: Fraktale rekursiv zeichnen
Lindenmayer-Systeme: Fraktale rekursiv zeichnen Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} ) Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} ) o Σ * = Menge aller
Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Definition. Definition. Definition. o Alphabet Σ ( Beispiel: {F, +, -} )
Fraktale rekursiv zeichnen Definition o Alphabet Σ ( Beispiel: F, +, - ) Definition o Alphabet Σ ( Beispiel: F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) Definition
Programmier-Befehle - Woche 10
Funktionen Rekursion Selbstaufruf einer Funktion Jeder rekursive Funktionsaufruf hat seine eigenen, unabhängigen Variablen und Argumente. Dies kann man sich sehr gut anhand des in der Vorlesung gezeigten
Mathematische Rekursion
Rekursion Mathematische Rekursion o Viele mathematische Funktionen sind sehr natürlich rekursiv definierbar, d.h. o die Funktion erscheint in ihrer eigenen Definition. Mathematische Rekursion o Viele mathematische
Felder (Arrays) und Zeiger (Pointers) - Teil I
Felder (Arrays) und Zeiger (Pointers) - Teil I Feldtypen, Sieb des Eratosthenes, Iteration, Zeigertypen, Zeigerarithmetik, dynamische Speicherverwaltung Felder: Motivation n Wir können jetzt über Zahlen
Schleifen Datenfelder (Arrays) Verzweigungen
Schleifen Datenfelder (Arrays) Verzweigungen Vektoren, Matrizen, Tabellen for, while, foreach, if-else und switch-case Dr. Beatrice Amrhein Überblick Schleifen o for, while, foreach Eindimensionale Arrays
Felder (Arrays) und Zeiger (Pointers) - Teil I
Felder (Arrays) und Zeiger (Pointers) - Teil I Feldtypen, Sieb des Eratosthenes, Iteration, Zeigertypen, Zeigerarithmetik, dynamische Speicherverwaltung Felder: Motivation Wir können jetzt über Zahlen
Felder (Arrays) und Zeiger (Pointers) - Teil I
Felder (Arrays) und Zeiger (Pointers) - Teil I Felder: Motivation Wir können jetzt über Zahlen iterieren: for (int i=0; i
Sprachkonstrukte Verzweigungen und Array-Strukturen
Sprachkonstrukte Verzweigungen und Array-Strukturen Dr. Beatrice Amrhein Überblick Verzweigungen o if/else o switch/case Array-Strukturen o Vektoren und Matrizen 2 Verzweigungen 3 Verzweigungen: if/else
1. Zeiger, Algorithmen, Iteratoren und Container. Felder als Funktionsargumente, Zeiger, Iteratoren auf Vektoren, Container
1 1. Zeiger, Algorithmen, Iteratoren und Container Felder als Funktionsargumente, Zeiger, Iteratoren auf Vektoren, Container Arrays und Funktionen - Ein Wunder? 2 // Program: fill.cpp // define and use
Teil 5: Zeiger, Felder, Zeichenketten Gliederung
Teil 5: Zeiger, Felder, Zeichenketten Gliederung Zeiger und Adressen Felder (Arrays) Zeichenketten (Strings) Zeigerarithmetik Mehrdimensionale Felder Zeiger und Adressen Felder Zeichenketten Zeigerarithmetik
Elementare Datentypen in C++
Elementare Datentypen in C++ bool signed/unsigned char signed/unsigned short int signed/unsigned int signed/unsigned long int (signed/unsigned long long int) float double long double void enum char Der
Dynamische Datentypen. Destruktor, Copy-Konstruktor, Zuweisungsoperator, Dynamischer Datentyp, Vektoren
Dynamische Datentypen Destruktor, Copy-Konstruktor, Zuweisungsoperator, Dynamischer Datentyp, Vektoren Probleme mit Feldern (variabler Länge) man kann sie nicht direkt kopieren und zuweisen Probleme mit
C++ Teil 2. Sven Groß. 16. Apr IGPM, RWTH Aachen. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 22
C++ Teil 2 Sven Groß IGPM, RWTH Aachen 16. Apr 2015 Sven Groß (IGPM, RWTH Aachen) C++ Teil 2 16. Apr 2015 1 / 22 Themen der letzten Vorlesung Hallo Welt Elementare Datentypen Ein-/Ausgabe Operatoren Sven
Visuelle Kryptographie. Anwendung von Zufallszahlen
Visuelle Kryptographie Anwendung von Zufallszahlen Verschlüsseln eines Bildes Wir wollen ein Bild an Alice und Bob schicken, so dass Verschlüsseln eines Bildes Wir wollen ein Bild an Alice und Bob schicken,
3. Wahrheitswerte. Boolesche Funktionen; der Typ bool; logische und relationale Operatoren; Kurzschlussauswertung; Assertions und Konstanten
114 3. Wahrheitswerte Boolesche Funktionen; der Typ bool; logische und relationale Operatoren; Kurzschlussauswertung; Assertions und Konstanten Wo wollen wir hin? 115 int a; std::cin >> a; if (a % 2 ==
Kurze Einführung in die Programmiersprache C++ und in Root
Kurze Einführung in die Programmiersprache C++ und in Root Statistik, Datenanalyse und Simulation; 31.10.2006 Inhalt 1 Einführung in die Programmiersprache C++ Allgemeines Variablen Funktionen 2 1 Einführung
Es ist für die Lösung der Programmieraufgabe nicht nötig, den mathematischen Hintergrund zu verstehen, es kann aber beim Verständnis helfen.
Ziele sind das Arbeiten mit Funktionen und dem Aufzählungstyp (enum), sowie - einfache Verzweigung (if else) - Alternativen switch case - einfache Schleifen (while oder do while) Aufgabe 3: Diese Aufgabe
Grundlagen der Informatik 2. Typen
Grundlagen der Informatik 2. Typen Speicher, Speicherbedarf Ein-/Ausgabe Grundlagen der Informatik (Alex Rempel) 1 Wiederholung // root calculation #include #include using namespace
Algorithmen zur Datenanalyse in C++
Algorithmen zur Datenanalyse in C++ Hartmut Stadie 16.04.2012 Algorithmen zur Datenanalyse in C++ Hartmut Stadie 1/ 39 Einführung Datentypen Operatoren Anweisungssyntax Algorithmen zur Datenanalyse in
Grundlagen der Programmierung in C++ Arrays und Strings, Teil 1
Grundlagen der Programmierung in C++ Arrays und Strings, Teil 1 Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Das C++ Typsystem simple structured integral enum
Schleifen in C/C++/Java
Schleifen in C/C++/Java Alle 3 Sprachen stellen mindestens die folgenden 3 Schleifenkonstruktionen zur Verfügung. In C gibt es auch keine weiteren, C++, Java und C# haben noch weitere nützliche Varianten.
Dynamische Datentypen
Dynamische Datentypen Tupel und Folgen o Wertebereich eines Structs / einer Klasse: T1 T2... Tk Werte sind k-tupel Tupel und Folgen o Wertebereich eines Structs / einer Klasse: T1 T2... Tk Werte sind k-tupel
Welche Informatik-Kenntnisse bringen Sie mit?
Welche Informatik-Kenntnisse bringen Sie mit? So gehen Sie vor! Lösen Sie die Aufgaben der Reihe nach von 1 bis 20, ohne das Lösungsblatt zur Hilfe zu nehmen. Der Schwierigkeitsgrad der Aufgaben nimmt
Felder: Motivation. Felder (Arrays) und Zeiger (Pointers) - Teil I. Felder: erste Anwendung. Felder: erste Anwendung
Felder (Arrays) und Zeiger (Pointers) - Teil I Felder: Motivation Wir können jetzt über Zahlen iterieren: for (int i=; i
Einstieg in die Informatik mit Java
Vorlesung vom 18.4.07, Grundlagen Übersicht 1 Kommentare 2 Bezeichner für Klassen, Methoden, Variablen 3 White Space Zeichen 4 Wortsymbole 5 Interpunktionszeichen 6 Operatoren 7 import Anweisungen 8 Form
Zusammenfassung des Handzettels für Programmieren in C
Zusammenfassung des Handzettels für Programmieren in C In der handschriftlichen Kopie werden mehr Abkürzungen verwendet. Alles Grün markierte dient zum lernen und wird nicht auf den Handzettel übertragen.
Zeichendarstellung. Zeichen sind Zahlen (in C) Zeichen und switch
darstellung Arbeiten mit darstellung werden im Computer durch (kleine) Zahlen dargestellt in C können im Datentyp char gespeichert werden, dieser umfasst ein Byte und gilt als Ganzzahltyp darstellung Arbeiten
Grundlagen der Programmierung Teil1 Einheit III Okt. 2010
Grundlagen der Programmierung Teil1 Einheit III - 22. Okt. 2010 GDP DDr. Karl D. Fritscher basierend auf der Vorlesung Grundlagen der Programmierung von DI Dr. Bernhard Pfeifer Einschub Bevor wir mit den
1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays)
1. Erste Schritte 2. Einfache Datentypen 3. Anweisungen und Kontrollstrukturen 4. Verifikation 5. Reihungen (Arrays) II.1.3. Anweisungen und Kontrollstrukturen - 1 - Anweisung Anweisung Zuweisung Methodenaufruf
Die for -Schleife HEUTE. Schleifen. Arrays. Schleifen in JAVA. while, do reichen aus, um alle iterativen Algorithmen zu beschreiben
18.11.5 1 HEUTE 18.11.5 3 Schleifen Arrays while, do reichen aus, um alle iterativen Algorithmen zu beschreiben Nachteil: Steuermechanismus ist verteilt Übersicht nicht immer leicht dazu gibt es for (
Arbeitsblätter für die Lehrveranstaltung OOP JAVA 1
Fachhochschule Stralsund Fachbereich Maschinenbau Lehrgebiet Informatik Prof. Dr.-Ing. Ch.Wahmkow Arbeitsblätter für die Lehrveranstaltung OOP I. Aufbau eines Java-Programmes JAVA 1 Escape-Sequenzen zur
Variablen in C++ Einfache Variablen Strukturen Arrays und Zeichenketten Zeiger und Referenzen Parameter Dynamische Speicherverwaltung
Variablen in C++ Einfache Variablen Strukturen Arrays und Zeichenketten Zeiger und Referenzen Parameter Dynamische Speicherverwaltung Einfache Variablen Typen int, long, short, unsigned bool char float,
Grundlagen der Informatik 6. Arrays I
6. Arrays I Motivation Array (konstante Länge) Speicherbereich Eingabe von Arrays Grundlagen der Informatik (Alex Rempel) 1 Motivation Beispiel: Bildschirmpixel zeichnen Auflösung 800x600, d.h. insgesamt
JAVA BASICS. 2. Primitive Datentypen. 1. Warum Java? a) Boolean (logische Werte wahr & falsch)
JAVA BASICS 2. Primitive Datentypen 1. Warum Java? weit verbreitet einfach und (relativ) sicher keine Pointer (?) keine gotos kein Präprozessor keine globalen Variablen garbage collection objekt-orientiert
RO-Tutorien 3 / 6 / 12
RO-Tutorien 3 / 6 / 12 Tutorien zur Vorlesung Rechnerorganisation Christian A. Mandery WOCHE 2 AM 06./07.05.2013 KIT Universität des Landes Baden-Württemberg und nationales Forschungszentrum in der Helmholtz-Gemeinschaft
Informatik 1 ( ) D-MAVT F2010. Schleifen, Felder. Yves Brise Übungsstunde 5
Informatik 1 (251-0832-00) D-MAVT F2010 Schleifen, Felder Nachbesprechung Blatt 3 Aufgabe 1 ASCII... A > a Vorsicht: Lösen Sie sich von intuitiven Schlussfolgerungen. A ist nicht grösser als a, denn in
Intensivkurs C++ Tag 2: Grundlagen++ Marc Tschentscher Institut für Neuroinformatik
Intensivkurs C++ Tag 2: Grundlagen++ Marc Tschentscher Institut für Neuroinformatik www.ini.rub.de/rtcv 19.09.2017 Intensivkurs C++ 19.09.2017 Marc Tschentscher 1 Themen 1 Gültigkeitsbereiche und Namensräume
einlesen n > 0? Ausgabe Negative Zahl
1 Lösungen Kapitel 1 Aufgabe 1.1: Nassi-Shneiderman-Diagramm quadratzahlen Vervollständigen Sie das unten angegebene Nassi-Shneiderman-Diagramm für ein Programm, welches in einer (äußeren) Schleife Integer-Zahlen
4.4 Imperative Algorithmen Prozeduren
4.4.2 Prozeduren Der Wert eines Ausdrucks u in Zustand z Z lässt sich damit auch leicht definieren (jetzt W Z statt W σ ) Dazu erweitern wir die rekursive Definition von Folie 57 (Wert eines Ausdrucks):
Unterlagen. CPP-Uebungen-08/
Unterlagen http://projects.eml.org/bcb/people/ralph/ CPP-Uebungen-08/ http://www.katjawegner.de/lectures.html Kommentare in C++ #include /* Dies ist ein langer Kommentar, der über zwei Zeilen
4.2 Programmiersprache C
4.2.1. Elementare Datentypen (signed) int, unsigned int, (signed) short (int), unsigned short (int), (signed) long (int), unsigned long (int) Elementare Datentypen für ganze Zahlen mit oder ohne Vorzeichen.
Einführung in die Programmierung Wintersemester 2011/12
Einführung in die Programmierung Wintersemester 2011/12 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund : Kontrollstrukturen Inhalt Wiederholungen - while
C# - Einführung in die Programmiersprache Bedingte Anweisungen und Schleifen
C# - Einführung in die Programmiersprache Bedingte Anweisungen und Schleifen Gehe nach links oder rechts Gehe solange geradeaus... Leibniz Universität IT Services Anja Aue Programmabläufe grafisch abbilden
Vorlesungsprüfung Programmiersprache 1
Vorlesungsprüfung Programmiersprache 1 Termin der Prüfung: 1) Di 20.03.2018 16:15 17:00 HSB 3 2) Di 15.05.2018 16:15 17:00 HSB 3 3) Di 12.06.2018 16:15 17:00 HSB 3 Stoffgebiete: 1) Ganzzahltypen: char,
Martin Unold INFORMATIK. Geoinformatik und Vermessung
Wiederholung So sieht ein leeres Java-Programm aus public class Programmname { public static void main (String[] args) { // Hier stehen die Anweisungen Welche Arten von Anweisungen gibt es? Anweisungen
2 Teil 2: Nassi-Schneiderman
2 Teil 2: Nassi-Schneiderman Wie kann man Nassi-Schneiderman in einer objektorientierten Sprache verwenden? Jedes Objekt besitzt Methoden, welche die Attribute des Objektes verändern. Das Verhalten der
Graphdurchmusterung, Breiten- und Tiefensuche
Prof. Thomas Richter 18. Mai 2017 Institut für Analysis und Numerik Otto-von-Guericke-Universität Magdeburg thomas.richter@ovgu.de Material zur Vorlesung Algorithmische Mathematik II am 18.05.2017 Graphdurchmusterung,
4.2 Gleitkommazahlen. Der Speicherbedarf (in Bits) ist üblicherweise. In vielen Anwendungen benötigt man gebrochene Werte. Physikalische Größen
. Gleitkommazahlen In vielen Anwendungen benötigt man gebrochene Werte. Physikalische Größen Umrechnen von Einheiten und Währungen Jede Zahl x Q mit x 0 lässt sich folgendermaßen schreiben: x = s m e mit
RO-Tutorien 15 und 16
Tutorien zur Vorlesung Rechnerorganisation Tutorienwoche 2 am 04.05.2011 1 Christian A. Mandery: KIT Universität des Landes Baden-Württemberg und nationales Grossforschungszentrum in der Helmholtz-Gemeinschaft
Programmierung für Mathematik (HS13)
software evolution & architecture lab Programmierung für Mathematik (HS13) Übung 11 1 Aufgabe: Codeverständnis 1.1 Aufgabenstellung Notieren Sie, was der folgende Code ausgeben würde, wenn er so in einer
Programmiersprachen Einführung in C
Programmiersprachen Einführung in C Teil 2: Prof. Dr. Unser erstes C-Programm int main (int argc, char *argv[]) int i; int sum = 0; for (i = 0; i
Programmierkurs C++ Variablen und Datentypen
Programmierkurs C++ Variablen und Datentypen Prof. Dr. Stefan Fischer Institut für Telematik, Universität zu Lübeck http://www.itm.uni-luebeck.de/people/fischer #2 Überblick Welche Datentypen gibt es in
Structs, Referenztypen und Const-Typen
Structs, Referenztypen und Const-Typen Rechnen mit rationalen Zahlen o Rationale Zahlen (Q) sind von der Form n/d, mit n und d ausz o C++ hat keinen eingebauten Typ für rationale Zahlen Rechnen mit rationalen
9. Vektoren. (auch Felder/array)
9. Vektoren (auch Felder/array) Motivation Hat man mehrere Objekte gleichen Datentyps, so kann man sie explizit deklarieren, wenn die Anzahl bekannt ist double x1,x2,x3,x4; Nachteile: versagt, -wenn die
Ganze Zahlen. Die Typen int, unsigned int; Auswertung arithmetischer Ausdrücke, arithmetische Operatoren
Ganze Zahlen Die Typen int, unsigned int; Auswertung arithmetischer Ausdrücke, arithmetische Operatoren Celsius to Fahrenheit // Program: fahrenheit.cpp // Convert temperatures from Celsius to Fahrenheit.
Lexikalische Programmanalyse der Scanner
Der Scanner führt die lexikalische Analyse des Programms durch Er sammelt (scanned) Zeichen für Zeichen und baut logisch zusammengehörige Zeichenketten (Tokens) aus diesen Zeichen Zur formalen Beschreibung
Programmiertechnik. Teil 4. C++ Funktionen: Prototypen Overloading Parameter. C++ Funktionen: Eigenschaften
Programmiertechnik Teil 4 C++ Funktionen: Prototypen Overloading Parameter C++ Funktionen: Eigenschaften Funktionen (Unterprogramme, Prozeduren) fassen Folgen von Anweisungen zusammen, die immer wieder
Java - Programmierung - Prozedurale Programmierung 1
Java - Programmierung - Prozedurale Programmierung 1 // elementare Datentypen public class el_dt public static void main(string args []) byte b = 127; short s = 32767; int i = 2147483647; long l = 9223372036854775807L,
Hochschule Darmstadt Informatik-Praktikum (INF 1) WS 2015/2016 Wirtschaftsingenieur Bachelor 5. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für eine Hausverwaltung sollen für maximal 500 Wohnungen Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Art Baujahr Wohnung Whnginfo Nebenkosten
Anweisungen zur Ablaufsteuerung
Anweisungen zur Ablaufsteuerung if-else switch while do-while for Ausdrücke Ein Ausdruck ist eine Folge von Variablen, Operatoren und Methodenaufrufen, der zu einem einzelnen Wert ausgewertet wird. Operanden
Informatik 1 ( ) D-MAVT F2010. Pointer, Structs, Sortieren. Yves Brise Übungsstunde 6
Informatik 1 (251-0832-00) D-MAVT F2010 Pointer, Structs, Sortieren Aufgabe 1.1 Werden die Variablen später noch gebraucht? for (double d = 13, double e = 0;...) {... Ja... dann e vorher deklarieren. In
Operatoren (1) Operatoren (2)
Operatoren (1) Binäre Operatoren + - * / % < = > & ^ > && Addition Subtraktion Multiplikation Division Divisionsrest Vergl. auf kleiner Vergl. auf kleiner oder gleich Vergl. auf gleich Vergl.
Hochschule Darmstadt Informatik-Praktikum (INF 1) WS 2014/2015 Wirtschaftsingenieur Bachelor 4. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für ein Baumkataster sollen für maximal 500 Bäume Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Nummer Bauminfo Baumart Hoehe Baum Umfang
Vorkurs C++ Programmierung
Vorkurs C++ Programmierung Funktionen Rückblick Operatoren logische Verknüpfungen Zusammengesetzte Operatoren ( Zuweisungsoperatoren ) Kontrollstrukturen Bedingte Anweisungen (if-abfrage, switch-konstrukt)
Einführung in die C-Programmierung
Einführung in die C-Programmierung Warum C? Sehr stark verbreitet (Praxisnähe) Höhere Programmiersprache Objektorientierte Erweiterung: C++ Aber auch hardwarenahe Programmierung möglich (z.b. Mikrokontroller).
JavaScript. Dies ist normales HTML. Hallo Welt! Dies ist JavaScript. Wieder normales HTML.
JavaScript JavaScript wird direkt in HTML-Dokumente eingebunden. Gib folgende Zeilen mit einem Texteditor (Notepad) ein: (Falls der Editor nicht gefunden wird, öffne im Browser eine Datei mit der Endung
Java 8. Elmar Fuchs Grundlagen Programmierung. 1. Ausgabe, Oktober 2014 JAV8
Java 8 Elmar Fuchs Grundlagen Programmierung 1. Ausgabe, Oktober 2014 JAV8 5 Java 8 - Grundlagen Programmierung 5 Kontrollstrukturen In diesem Kapitel erfahren Sie wie Sie die Ausführung von von Bedingungen
Einführung Programmierpraktikum C Michael Zwick
Einführung Programmierpraktikum C Michael Zwick Vorlesung, Übung & Fragestunde Dr.-Ing. Michael Zwick Raum Z945 zwick@tum.de (089) 289 23609 Tutorium Ab Dienstag: Auswahl Tutoriumsplatz auf www.ldv.ei.tum.de/lehre/computertechnik
RO-Tutorien 17 und 18
RO-Tutorien 17 und 18 Tutorien zur Vorlesung Rechnerorganisation Christian A. Mandery TUTORIENWOCHE 2 AM 10.05.2012 KIT Universität des Landes Baden-Württemberg und nationales Forschungszentrum in der
Martin Unold INFORMATIK. Geoinformatik und Vermessung
Wiederholung So sieht ein leeres Java-Programm aus public class Programmname { public static void main (String[] args) { // Hier stehen die Anweisungen Wiederholung Anweisungen durch Methodenaufrufe Ausgabe
FH München, FB 03 FA WS 06/07. Ingenieurinformatik. Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz
FH München, FB 03 FA WS 06/07 Ingenieurinformatik Name Vorname Matrikelnummer Sem.Gr.: Hörsaal Platz Zulassung geprüft vom Aufgabensteller: Teil I Aufg. 2 Aufg. 3 Aufg. 4 Aufg. 5 Summe Note Aufgabensteller:
Arrays, Zeiger und Funktionen (call by reference)
Arrays, Zeiger und Funktionen (call by reference) Aufgabe 1: Zeichenketten Gegeben sei das folgende Programm: char text[] = "Informatik\aist toll\n"; printf("%i\n", sizeof(text)/sizeof(char)); printf("%s\n",
Algorithmen und Datenstrukturen Musterlösung 5
Algorithmen und Datenstrukturen Musterlösung 5 Martin Avanzini Thomas Bauereiß Herbert Jordan René Thiemann
Datenfelder (Arrays) Vektoren, Matrizen, Tabellen. Dr. Beatrice Amrhein
Datenfelder (Arrays) Vektoren, Matrizen, Tabellen Dr. Beatrice Amrhein Überblick Eindimensionale Arrays o Deklaration, Initialisierung, Zugriff Mehrdimensionale Arrays o Deklaration, Initialisierung, Zugriff
Informatik I (D-ITET)
Ablauf Informatik I (D-ITET) Übungsstunde 5, 26.10.2009 simonmayer@student.ethz.ch ETH Zürich Nachbesprechung Übung 3 Besprechung/Vertiefung der Vorlesung [21.10.2009] Vorbesprechung Übung 5 2.c) Test
Proseminar String Matching
Proseminar Textsuche Proseminar String Matching PD Dr. habil. Hanjo Täubig Lehrstuhl für Theoretische Informatik (Prof. Dr. Susanne Albers) Institut für Informatik Technische Universität München Wintersemester
Das erste C++ Programm
Das erste C++ Programm // Program: power8.c // Raise a number to the eighth power. #include int main() { // input std::cout > a; // computation int
Einführung Datentypen Verzweigung Schleifen Funktionen Dynamische Datenstrukturen. Java Crashkurs. Kim-Manuel Klein (kmk@informatik.uni-kiel.
Java Crashkurs Kim-Manuel Klein (kmk@informatik.uni-kiel.de) May 7, 2015 Quellen und Editoren Internet Tutorial: z.b. http://www.java-tutorial.org Editoren Normaler Texteditor (Gedit, Scite oder ähnliche)
C-Arrays vs. C++-Container
C-Arrays vs. C++-Container In C verwendet man (mangels Alternativen) sehr häufig das C-Array (= Feld): im Speicher hintereinander abgelegte Elemente vom gleichen Typ. Arrays haben einen Basistyp (Typ des
C++ Teil 4. Sven Groß. 30. Apr IGPM, RWTH Aachen. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16
C++ Teil 4 Sven Groß IGPM, RWTH Aachen 30. Apr 2015 Sven Groß (IGPM, RWTH Aachen) C++ Teil 4 30. Apr 2015 1 / 16 Themen der letzten Vorlesung Funktionen: Definition und Aufruf Wert- und Referenzparameter,
2.2 Der Algorithmus von Knuth, Morris und Pratt
Suchen in Texten 2.1 Grundlagen Ein Alphabet ist eine endliche Menge von Symbolen. Bsp.: Σ a, b, c,..., z, Σ 0, 1, Σ A, C, G, T. Wörter über Σ sind endliche Folgen von Symbolen aus Σ. Wörter werden manchmal
3. Anweisungen und Kontrollstrukturen
3. Kontrollstrukturen Anweisungen und Blöcke 3. Anweisungen und Kontrollstrukturen Mit Kontrollstrukturen können wir den Ablauf eines Programmes beeinflussen, z.b. ob oder in welcher Reihenfolge Anweisungen
Verschlüsseln eines Bildes. Visuelle Kryptographie. Verschlüsseln eines Bildes. Verschlüsseln eines Bildes
Verschlüsseln eines Bildes Visuelle Kryptographie Anwendung von Zufallszahlen Wir wollen ein Bild an Alice und Bob schicken, so dass Alice allein keine Information über das Bild bekommt Bob allein keine
Einstieg in die Informatik mit Java
1 / 47 Einstieg in die Informatik mit Java Anweisungen Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 47 1 Ausdrucksanweisung 2 Einfache Ausgabeanweisung 3 Einfache Eingabeanweisung,
Arrays. Gilbert Beyer und Annabelle Klarl. Einführung in die Informatik. Zentralübung zur Vorlesung Einführung in die Informatik
Arrays Zentralübung zur Vorlesung Einführung in die Informatik http://www.pst.ifi.lmu.de/lehre/wise-11-12/infoeinf WS11/12 Inhalte der heutigen Vorlesung: Arraytypen Speicherdarstellung von Arrays Auswertung
2. Programmierung in C
2. Programmierung in C Inhalt: Überblick über Programmiersprachen, Allgemeines zur Sprache C C: Basisdatentypen, Variablen, Konstanten Operatoren, Ausdrücke und Anweisungen Kontrollstrukturen (Steuerfluss)
Annehmende Schleife do while
Annehmende Schleife do while Schleife mit nachfolgender Bedingungsprüfung: annehmende Schleife B S Mit B wird eine Bedingung (logischer Ausdruck) bezeichnet, S ist ein Strukturblock. Zuerst wird S ausgeführt,
Modellierung und Programmierung 1
Modellierung und Programmierung 1 Prof. Dr. Sonja Prohaska Computational EvoDevo Group Institut für Informatik Universität Leipzig 19. November 2015 Gültigkeitsbereich (Scope) von Variablen { int m; {
Einführung in den Einsatz von Objekt-Orientierung mit C++ I
Einführung in den Einsatz von Objekt-Orientierung mit C++ I ADV-Seminar Leiter: Mag. Michael Hahsler Syntax von C++ Grundlagen Übersetzung Formale Syntaxüberprüfung Ausgabe/Eingabe Funktion main() Variablen
Einstieg in die Informatik mit Java
Vorlesung vom 6.11.07, Weitere Anweisungen Übersicht 1 Verbundanweisung 2 Bedingte Anweisung 3 Auswahlanweisung 4 for Schleife 5 while Schleife 6 do Schleife 7 break Anweisung 8 continue Anweisung 9 Leere
Felder, Rückblick Mehrdimensionale Felder. Programmieren in C
Übersicht Felder, Rückblick Mehrdimensionale Felder Rückblick Vereinbarung von Feldern: typ name [anzahl]; typ name = {e1, e2, e3,..., en} Die Adressierung von Feldelementen beginnt bei 0 Die korrekte
C# - Einführung in die Programmiersprache Methoden. Leibniz Universität IT Services
C# - Einführung in die Programmiersprache Methoden Leibniz Universität IT Services 02.07.12 Methoden... sind Subroutinen in einer Klasse. können einen Wert an den Aufrufer zurückgeben. verändern die Eigenschaften
Felder (1) Allgemeines
Felder (1) Allgemeines Gleichartige Daten, wie Tabelle von Zahlen, Datumswerten, Namen etc. Felder (engl. Array) stellen einen Verbundtyp dar, in dem mehrere Daten desselben Typs gespeichert werden Oft
Übungspaket 23 Mehrdimensionale Arrays
Übungspaket 23 Mehrdimensionale Arrays Übungsziele: Skript: Deklaration und Verwendung mehrdimensionaler Arrays Kapitel: 49 Semester: Wintersemester 2016/17 Betreuer: Kevin, Matthias, Thomas und Ralf Synopsis: