diff --git a/20200109/Tower_of_Hanoi.jpeg b/20200109/Tower_of_Hanoi.jpeg new file mode 120000 index 0000000000000000000000000000000000000000..a1a794afda08596ffa2f46f278db53455de25b6c --- /dev/null +++ b/20200109/Tower_of_Hanoi.jpeg @@ -0,0 +1 @@ +../common/Tower_of_Hanoi.jpeg \ No newline at end of file diff --git a/20200109/bsort-1.c b/20200109/bsort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..3c02adc72e6a7e702e2c7c68c838fc94cc8ef547 --- /dev/null +++ b/20200109/bsort-1.c @@ -0,0 +1,48 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + for (int i = 1; name[i]; i++) + if (compare (name, i - 1, i) > 0) + { + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/bsort-1a.c b/20200109/bsort-1a.c new file mode 100644 index 0000000000000000000000000000000000000000..348b638843002926f57cdcf1d4fbc9bd88d2a10c --- /dev/null +++ b/20200109/bsort-1a.c @@ -0,0 +1,48 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + for (int i = 1; name[i]; i++) + if (compare (name, i - 1, i) > 0) + { + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Zacharias", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/bsort-2.c b/20200109/bsort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..d277be0182a40ecd0c66eaeef94d7aebac6aa542 --- /dev/null +++ b/20200109/bsort-2.c @@ -0,0 +1,55 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0) + { + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted--; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/bsort-3.c b/20200109/bsort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..67d0097b913171b4523f4f04b6b6ff494046dabd --- /dev/null +++ b/20200109/bsort-3.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int done = 0; + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0 && !done) + { + done = 1; + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + done = 0; + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted--; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/bsort-4.c b/20200109/bsort-4.c new file mode 100644 index 0000000000000000000000000000000000000000..241270a46f4ffa005d252207d769c3c4059ed7e2 --- /dev/null +++ b/20200109/bsort-4.c @@ -0,0 +1,57 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + sorted++; + while (sorted > 0) + { + int new_sorted = 0; + for (int i = 1; i < sorted; i++) + if (compare (name, i - 1, i) > 0) + { + new_sorted = i; + char *temp = name[i - 1]; + name[i - 1] = name[i]; + name[i] = temp; + } + sorted = new_sorted; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/hanoi-0.c b/20200109/hanoi-0.c new file mode 100644 index 0000000000000000000000000000000000000000..83b5f081e33e699f2d5eaa1f858320530e1b2820 --- /dev/null +++ b/20200109/hanoi-0.c @@ -0,0 +1,26 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = 0; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20200109/hanoi-1.c b/20200109/hanoi-1.c new file mode 100644 index 0000000000000000000000000000000000000000..6d005f0b12afa6086afb65e1794fb5c977b474e2 --- /dev/null +++ b/20200109/hanoi-1.c @@ -0,0 +1,30 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = 4; + tower[0][0] = 4; + tower[0][1] = 3; + tower[0][2] = 2; + tower[0][3] = 1; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20200109/hanoi-2.c b/20200109/hanoi-2.c new file mode 100644 index 0000000000000000000000000000000000000000..c928c1130539da08d0882249bdffc877d72289b2 --- /dev/null +++ b/20200109/hanoi-2.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + return 0; +} diff --git a/20200109/hanoi-3.c b/20200109/hanoi-3.c new file mode 100644 index 0000000000000000000000000000000000000000..4b59c046962c1f79eca315882d93faf6b6c298c1 --- /dev/null +++ b/20200109/hanoi-3.c @@ -0,0 +1,44 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + move (2, 0, 1); + display (); + return 0; +} diff --git a/20200109/hanoi-4.c b/20200109/hanoi-4.c new file mode 100644 index 0000000000000000000000000000000000000000..162a5ba7cccedf64bff8ae9a514aaf146088e3a4 --- /dev/null +++ b/20200109/hanoi-4.c @@ -0,0 +1,44 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + move (0, 2, 1); + display (); + return 0; +} diff --git a/20200109/hanoi-5.c b/20200109/hanoi-5.c new file mode 100644 index 0000000000000000000000000000000000000000..e04ad85f63fe92e5c15d22646beb9e9107bf78d6 --- /dev/null +++ b/20200109/hanoi-5.c @@ -0,0 +1,45 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, 1); + return 0; +} diff --git a/20200109/hanoi-6.c b/20200109/hanoi-6.c new file mode 100644 index 0000000000000000000000000000000000000000..1267605f802246e857c32d29cc0a132609cb24ce --- /dev/null +++ b/20200109/hanoi-6.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 4 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20200109/hanoi-7.c b/20200109/hanoi-7.c new file mode 100644 index 0000000000000000000000000000000000000000..f71fcdc0c3f66047ee3ad870d019a06eb328050f --- /dev/null +++ b/20200109/hanoi-7.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 5 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20200109/hanoi-8.c b/20200109/hanoi-8.c new file mode 100644 index 0000000000000000000000000000000000000000..6d804063531d424a82924a89d85424c33994793b --- /dev/null +++ b/20200109/hanoi-8.c @@ -0,0 +1,52 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 64 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + display (); + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + return 0; +} diff --git a/20200109/hanoi-9.c b/20200109/hanoi-9.c new file mode 100644 index 0000000000000000000000000000000000000000..7694b373b7011e96f6be0ad0f00ba54b67086158 --- /dev/null +++ b/20200109/hanoi-9.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 64 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + static int counter = 1; + if (counter++ >= 100000000) + { + display (); + counter = 1; + } + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + display (); + return 0; +} diff --git a/20200109/hanoi-9a.c b/20200109/hanoi-9a.c new file mode 100644 index 0000000000000000000000000000000000000000..55e8d74db6d7284d6db225a6f8f3e08ab4efdc06 --- /dev/null +++ b/20200109/hanoi-9a.c @@ -0,0 +1,58 @@ +#include <stdio.h> +#include <error.h> + +#define DISKS 32 + +int n[3], tower[3][DISKS]; + +void display (void) +{ + printf ("\n"); + for (int i = 0; i < 3; i++) + { + printf ("tower %d:", i); + for (int j = 0; j < n[i]; j++) + printf (" %d", tower[i][j]); + printf ("\n"); + } +} + +void move (int from, int to, int disks) +{ + if (disks == 1) + { + if (n[from] <= 0) + error (1, 0, "trying to move disk from empty tower"); + if (n[to] > 0 && tower[to][n[to] - 1] < tower[from][n[from] - 1]) + error (1, 0, "trying to move larger disk on smaller one"); + tower[to][n[to]] = tower[from][n[from] - 1]; + n[to]++; + n[from]--; + static int counter = 1; + if (counter++ >= 100000000) + { + display (); + counter = 1; + } + } + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } +} + +int main (void) +{ + n[0] = DISKS; + for (int i = 0; i < DISKS; i++) + tower[0][i] = DISKS - i; + n[1] = 0; + n[2] = 0; + display (); + move (0, 2, DISKS); + display (); + return 0; +} diff --git a/20200109/hello-gtk.png b/20200109/hello-gtk.png new file mode 120000 index 0000000000000000000000000000000000000000..cca99209d86683a9a3b0f70bbc149780bae10ba6 --- /dev/null +++ b/20200109/hello-gtk.png @@ -0,0 +1 @@ +../common/hello-gtk.png \ No newline at end of file diff --git a/20200109/hp-2019ws-p4.pdf b/20200109/hp-2019ws-p4.pdf new file mode 100644 index 0000000000000000000000000000000000000000..12d85b607400d6e182675fc0f82e78202dc118f5 Binary files /dev/null and b/20200109/hp-2019ws-p4.pdf differ diff --git a/20200109/hp-2019ws-p4.tex b/20200109/hp-2019ws-p4.tex new file mode 100644 index 0000000000000000000000000000000000000000..3f4a14e0d8fc82d0b78e65837211f62cbf8f41b6 --- /dev/null +++ b/20200109/hp-2019ws-p4.tex @@ -0,0 +1,193 @@ +% hp-2019ws-p4.pdf - Labor Notes on Low-Level Programming +% Copyright (C) 2014, 2015, 2016, 2018, 2019, 2020 Peter Gerwinski +% +% This document is free software: you can redistribute it and/or +% modify it either under the terms of the Creative Commons +% Attribution-ShareAlike 3.0 License, or under the terms of the +% GNU General Public License as published by the Free Software +% Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% This document is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this document. If not, see <http://www.gnu.org/licenses/>. +% +% You should have received a copy of the Creative Commons +% Attribution-ShareAlike 3.0 Unported License along with this +% document. If not, see <http://creativecommons.org/licenses/>. + +% README: Versuch 16. und 23.1.2020: Objektorientiertes Grafik-Programm + +\documentclass[a4paper]{article} + +\usepackage{pgscript} +\usepackage{multicol} +\usepackage{amsmath} +\usepackage{sfmath} + +\sloppy +%\pagestyle{empty} +\newcommand{\sep}{~$\cdot$~} +\newcommand{\mylicense}{CC-by-sa (Version 3.0) oder GNU GPL (Version 3 oder höher)} + +\begin{document} + + \makebox(0,0.005)[tl]{\includegraphics[scale=0.72]{logo-hochschule-bochum-cvh-text-v2.pdf}}\hfill + \makebox(0,0)[tr]{\includegraphics[scale=0.5]{logo-hochschule-bochum.pdf}} + \par\bigskip\bigskip + \begin{center} + \Large\textbf{Praktikumsversuch 4: Objektorientiertes Grafik-Programm} + \par\medskip + \normalsize Hardwarenahe Programmierung\sep + Wintersemester 2019/20\sep + Prof.~Dr.~Peter Gerwinski + \end{center} + + Aufgabe: Schreiben Sie ein GTK+-Programm, + mit dem man verschiedene Objekte (z.\,B.\ Rechtecke, Kreise, Dreiecke) + in eine Grafik einfügen und nachträglich verändern kann + (z.\,B.\ Position, Größe, Farbe). + + (Beispiel: Ich füge zunächst zwei Rechtecke und einen Kreis in eine Grafik ein, + wähle anschließend das erste Rechteck aus und ändere dessen Farbe.) + + \bigskip + + Hinweise: + \vspace*{-\medskipamount} + + \begin{itemize} + \item + Das Beispielprogramm \gitfile{hp}{20200109}{objects-5.c} zeigt, + wie man in C verschiedenartige Objekte + in einem Array von Zeigern verwaltet. + \item + Das Beispielprogramm \gitfile{hp}{20191205}{gtk-6.c} zeigt, + wie man mit Hilfe der GUI-Bibliothek GTK+ + verschiedene Objekte in ein Fenster zeichnet. + \item + Das Beispielprogramm \gitfile{hp}{20191205}{gtk-7.c} zeigt, + wie man in der GUI-Bibliothek GTK+ + Tastatur- und Maus-Eingaben entgegennimmt und verarbeitet. + \item + Das Auswählen eines bereits vorhandenen Objekts geht am einfachsten + mittels Tastatur-Eingaben (z.\,B.\ Ziffer 1 für das erste Objekt usw.). + Auswahl mit der Maus ist auch möglich, aber schwieriger. + \item + Mit Hilfe der Funktion \lstinline{gtk_widget_queue_draw()} + teilen Sie GTK+ mit, daß Sie ein \lstinline{GtkWidget} + neu zeichnen lassen möchten. + \item + Das Compilieren eines GTK+-Programms + (z.\,B.\ \gitfile{hp}{20190114}{gtk-7.c}) geschieht wie folgt: + \begin{lstlisting}[style=cmd,gobble=8] + gcc $(pkg-config --cflags gtk+-3.0) -Wall -O gtk-7.c \ + $(pkg-config --libs gtk+-3.0) -o gtk-7 + \end{lstlisting} + (Den Backslash am Ende der ersten Zeile entfällt, + wenn Sie den ganzen Befehl in eine einzige Zeile schreiben.) + \end{itemize} + + \bigskip + \textbf{GTK+ unter GNU/Linux} + \begin{itemize} + \item + Installieren Sie das Entwickler-Paket für GTK+-3,\\ + z.\,B.\ unter Debian GNU/Linux und darauf basierenden Systemen: + \begin{lstlisting}[style=cmd,gobble=8] + apt-get install libgtk-3-dev + \end{lstlisting} + \end{itemize} + + \bigskip + \goodbreak + \textbf{GTK+ unter MacOS X} + \begin{itemize} + \item + Zuerst den Paketmanager "`Homebrew"' installieren: + \begin{lstlisting}[style=cmd,gobble=8] + ruby -e "$(curl -fsSL https://raw.githubusercontent.com/ + Homebrew/install/master/install)" + \end{lstlisting} + (Die URL nicht trennen, sondern in einer Zeile schreiben.) + \item + Danach mit Hilfe von \lstinline[style=cmd]{brew} GTK+ installieren: + \begin{lstlisting}[style=cmd,gobble=8] + brew install gtk+3 + \end{lstlisting} + \end{itemize} + + \bigskip + \goodbreak + \textbf{GTK+ unter Microsoft Windows: Cygwin} + \begin{itemize} + \item + Im Cygwin-Setup-Programm die Pakete \file{libgtk3-devel}, + \file{xorg-server} und \file{dbus-x11} installieren. + \item + Bevor Sie GTK+-Programme starten können, + müssen Sie einmalig den X-Server starten: + \begin{lstlisting}[style=cmd,gobble=8] + XWin -multiwindow & + \end{lstlisting} + \item + Bevor Sie GTK+-Programme starten können, + müssen Sie einmalig pro Shell-Sitzung\\ + die \lstinline[style=cmd]{DISPLAY}-Variable setzen: + \begin{lstlisting}[style=cmd,gobble=8] + export DISPLAY=:0.0 + \end{lstlisting} + \end{itemize} + + \bigskip + \goodbreak + \textbf{GTK+ unter Microsoft Windows: MinGW} + \begin{itemize} + \item + Installieren Sie \file{MSYS2} (Installer). + \item + Installieren Sie von der MinGW-Shell aus GTK+ + und weitere Entwicklungswerkzeuge: + \begin{lstlisting}[style=cmd,gobble=8] + pacman -S mingw-w64-x86_64-gcc + pacman -S mingw-w64-x86_64-gtk3 + pacman -S mingw-w64-x86_64-pkg-config + \end{lstlisting} + \item + Falls nötig, ergänzen Sie in der MinGW-Shell + den Pfad zu den neu installierten Programmen: + \begin{lstlisting}[style=cmd,gobble=8] + export PATH=$PATH:/mingw64/bin + \end{lstlisting} + \end{itemize} + + \bigskip + + \strut\hfill\emph{Viel Erfolg!} + + \vfill + + \begingroup + + \small + + \setlength{\leftskip}{3cm} + + Stand: 9.\ Januar 2020 + +% Soweit nicht anders angegeben:\\ + Copyright \copyright\ 2014, 2015, 2016, 2018, 2019, 2020\quad Peter Gerwinski\\ + Lizenz: \mylicense + + Sie können diese Praktikumsunterlagen einschließlich Quelltext +% und Beispielprogramme\\ + herunterladen unter:\\ + \url{https://gitlab.cvh-server.de/pgerwinski/hp} + + \endgroup + +\end{document} diff --git a/20200109/hp-20200109.pdf b/20200109/hp-20200109.pdf new file mode 100644 index 0000000000000000000000000000000000000000..f85a40fc9c6567ec45374e947082fd739d37d011 Binary files /dev/null and b/20200109/hp-20200109.pdf differ diff --git a/20200109/hp-20200109.tex b/20200109/hp-20200109.tex new file mode 100644 index 0000000000000000000000000000000000000000..999bf9ef028b1041627dc22860e41e1e6b5f74f4 --- /dev/null +++ b/20200109/hp-20200109.tex @@ -0,0 +1,1265 @@ +% hp-20200109.pdf - Lecture Slides on Low-Level Programming +% Copyright (C) 2012, 2013, 2015, 2016, 2017, 2018, 2019, 2020 Peter Gerwinski +% +% This document is free software: you can redistribute it and/or +% modify it either under the terms of the Creative Commons +% Attribution-ShareAlike 3.0 License, or under the terms of the +% GNU General Public License as published by the Free Software +% Foundation, either version 3 of the License, or (at your option) +% any later version. +% +% This document is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this document. If not, see <http://www.gnu.org/licenses/>. +% +% You should have received a copy of the Creative Commons +% Attribution-ShareAlike 3.0 Unported License along with this +% document. If not, see <http://creativecommons.org/licenses/>. + +% README: Rekursion, Aufwandsabschätzungen, objektorientierte Programmierung + +\documentclass[10pt,t]{beamer} + +\usepackage{pgslides} +\usepackage{tikz} +\usepackage{rotating} + +\usefonttheme[onlymath]{serif} + +\definecolor{medcyan}{rgb}{0.0,0.5,0.7} + +\title{Hardwarenahe Programmierung} +\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski} +\date{9.\ Januar 2020} + +\begin{document} + +\maketitleframe + +\nosectionnonumber{\inserttitle} + +\begin{frame} + + \shownosectionnonumber + + \begin{itemize} + \item[\textbf{1}] \textbf{Einführung} + \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp}}} + \item[\textbf{2}] \textbf{Einführung in C} + \item[\textbf{3}] \textbf{Bibliotheken} + \item[\textbf{4}] \textbf{Hardwarenahe Programmierung} + \begin{itemize} + \vspace*{-0.1cm} + \item[\dots] +% \item[4.3] Interrupts + \item[4.4] volatile-Variable + \item[4.6] Byte-Reihenfolge -- Endianness + \color{medgreen} + \item[4.7] Binärdarstellung negativer Zahlen + \item[4.8] Speicherausrichtung -- Alignment + \end{itemize} + \item[\textbf{5}] \textbf{Algorithmen} + \begin{itemize} + \item[5.1] Differentialgleichungen + \color{medcyan} + \item[5.\hbox to 0.56em{\boldmath$\frac{1+i}{\sqrt2}$}]\hspace*{0.90em}Quantencomputer + \vspace*{1pt} + \color{red} + \item[5.2] Rekursion + \item[5.3] Aufwandsabschätzungen +% \vspace*{-0.1cm} + \item[\dots] + \end{itemize} + \vspace*{-\smallskipamount} + \item[\textbf{\dots}] + \end{itemize} + +\end{frame} + +\setcounter{section}{3} +\section{Hardwarenahe Programmierung} +\setcounter{subsection}{5} +\subsection{Byte-Reihenfolge -- Endianness} +\subsubsection{Konzept} + +\begin{frame}[fragile] + + \showsubsection + \showsubsubsection + + Eine Zahl geht über mehrere Speicherzellen.\\ + Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen + + \smallskip + + Welche Bits liegen wo? + +% \pause + \bigskip + + $1027 = 1024 + 2 + 1 = 0000\,0100\,0000\,0011_2 = 0403_{16}$ + +% \pause + \bigskip + Speicherzellen: + + \medskip + \begin{tabular}{|c|c|l}\cline{1-2} + \raisebox{-0.25ex}{04} & \raisebox{-0.25ex}{03} & \strut Big-Endian "`großes Ende zuerst"' \\\cline{1-2} + \multicolumn{2}{c}{} & für Menschen leichter lesbar \\ + \multicolumn{3}{c}{} \\[-5pt]\cline{1-2} + \raisebox{-0.25ex}{03} & \raisebox{-0.25ex}{04} & \strut Little-Endian "`kleines Ende zuerst"' \\\cline{1-2} + \multicolumn{2}{c}{} & bei Additionen effizienter + \end{tabular} + +% \pause + \medskip + \textarrow\ Geschmackssache +% \pause\\ + \quad\textbf{\dots\ außer bei Datenaustausch!} + +% \pause +% \bigskip +% +% Aber: nicht verwechseln! \qquad $0304_{16} = 772$ + +\end{frame} + +\iffalse + +\begin{frame} + + \showsubsection + \showsubsubsection + + Eine Zahl geht über mehrere Speicherzellen.\\ + Beispiel: 16-Bit-Zahl in 2 8-Bit-Speicherzellen + + \smallskip + + Welche Bits liegen wo? + + \medskip + + \textarrow\ Geschmackssache\\ + \textbf{\dots\ außer bei Datenaustausch!} + + \begin{itemize} + \item + Dateiformate + \item + Datenübertragung + \end{itemize} + +\end{frame} + +\subsubsection{Dateiformate} + +\begin{frame} + + \showsubsection + \showsubsubsection + + Audio-Formate: Reihenfolge der Bytes in 16- und 32-Bit-Zahlen + \begin{itemize} + \item + RIFF-WAVE-Dateien (\file{.wav}): Little-Endian + \item + Au-Dateien (\file{.au}): Big-Endian +% \pause + \item + ältere AIFF-Dateien (\file{.aiff}): Big-Endian + \item + neuere AIFF-Dateien (\file{.aiff}): Little-Endian + \end{itemize} + +% \pause + \bigskip + + Grafik-Formate: Reihenfolge der Bits in den Bytes + \begin{itemize} + \item + PBM-Dateien: Big-Endian\only<1->{, MSB first} + \item + XBM-Dateien: Little-Endian\only<1->{, LSB first} + \end{itemize} + \only<1->{MSB/LSB = most/least significant bit} + +\end{frame} + +\subsubsection{Datenübertragung} + +\begin{frame} + + \showsubsection + \showsubsubsection + + \begin{itemize} + \item + RS-232 (serielle Schnittstelle): LSB first + \item + I$^2$C: MSB first + \item + USB: beides +% \pause + \medskip + \item + Ethernet: LSB first + \item + TCP/IP (Internet): Big-Endian + \end{itemize} + +\end{frame} + +\fi + +\subsection{Binärdarstellung negativer Zahlen} + +\begin{frame}[fragile] + + \showsubsection + + Speicher ist begrenzt!\\ + \textarrow\ feste Anzahl von Bits + + \medskip + + 8-Bit-Zahlen ohne Vorzeichen: \lstinline{uint8_t}\\ + \textarrow\ Zahlenwerte von \lstinline{0x00} bis \lstinline{0xff} = 0 bis 255\\ +% \pause + \textarrow\ 255 + 1 = 0 + +% \pause + \medskip + + 8-Bit-Zahlen mit Vorzeichen: \lstinline{int8_t}\\ + \lstinline{0xff} = 255 ist die "`natürliche"' Schreibweise für $-1$.\\ +% \pause + \textarrow\ Zweierkomplement + +% \pause + \medskip + + Oberstes Bit = 1: negativ\\ + Oberstes Bit = 0: positiv\\ + \textarrow\ 127 + 1 = $-128$ + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Speicher ist begrenzt!\\ + \textarrow\ feste Anzahl von Bits + + \medskip + + 16-Bit-Zahlen ohne Vorzeichen: + \lstinline{uint16_t}\hfill\lstinline{uint8_t}\\ + \textarrow\ Zahlenwerte von \lstinline{0x0000} bis \lstinline{0xffff} + = 0 bis 65535\hfill 0 bis 255\\ + \textarrow\ 65535 + 1 = 0\hfill 255 + 1 = 0 + + \medskip + + 16-Bit-Zahlen mit Vorzeichen: + \lstinline{int16_t}\hfill\lstinline{int8_t}\\ + \lstinline{0xffff} = 66535 ist die "`natürliche"' Schreibweise für $-1$.\hfill + \lstinline{0xff} = 255 = $-1$\\ + \textarrow\ Zweierkomplement + + \medskip + + Oberstes Bit = 1: negativ\\ + Oberstes Bit = 0: positiv\\ + \textarrow\ 32767 + 1 = $-32768$ + + \bigskip + Literatur: \url{http://xkcd.com/571/} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Frage: \emph{Für welche Zahl steht der Speicherinhalt\, + \raisebox{2pt}{% + \tabcolsep0.25em + \begin{tabular}{|c|c|}\hline + \rule{0pt}{11pt}a3 & 90 \\\hline + \end{tabular}} + (hexadezimal)?} + +% \pause + \smallskip + Antwort: \emph{Das kommt darauf an.} ;--) + +% \pause + \medskip + Little-Endian: + + \smallskip + + \begin{tabular}{lrl} + als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\ + als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\ + als \lstinline,int16_t,: & $-28509$\\ + als \lstinline,uint16_t,: & $37027$\\ + \lstinline,int32_t, oder größer: & $37027$ + & (zusätzliche Bytes mit Nullen aufgefüllt) + \end{tabular} + +% \pause + \medskip + Big-Endian: + + \smallskip + + \begin{tabular}{lrl} + als \lstinline,int8_t,: & $-93$ & (nur erstes Byte)\\ + als \lstinline,uint8_t,: & $163$ & (nur erstes Byte)\\ + als \lstinline,int16_t,: & $-23664$\\ + als \lstinline,uint16_t,: & $41872$\\ + als \lstinline,int32_t,: & $-1550843904$ & (zusätzliche Bytes\\ + als \lstinline,uint32_t,: & $2744123392$ & mit Nullen aufgefüllt)\\ + als \lstinline,int64_t,: & $-6660823848880963584$\\ + als \lstinline,uint64_t,: & $11785920224828588032$\\ + \end{tabular} + + \vspace*{-1cm} + +\end{frame} + +\subsection{Speicherausrichtung -- Alignment} + +\begin{frame}[fragile] + + \showsubsection + + \begin{lstlisting} + #include <stdint.h> + + uint8_t a; + uint16_t b; + uint8_t c; + \end{lstlisting} + +% \pause + \bigskip + + Speicheradresse durch 2 teilbar -- "`16-Bit-Alignment"' + \begin{itemize} + \item + 2-Byte-Operation: effizienter +% \pause + \item + \dots\ oder sogar nur dann erlaubt +% \pause + \arrowitem + Compiler optimiert Speicherausrichtung + \end{itemize} + + \medskip + +% \pause + \begin{minipage}{3cm} + \begin{lstlisting}[gobble=6] + ¡uint8_t a; + uint8_t dummy; + uint16_t b; + uint8_t c;¿ + \end{lstlisting} + \end{minipage} +% \pause + \begin{minipage}{3cm} + \begin{lstlisting}[gobble=6] + ¡uint8_t a; + uint8_t c; + uint16_t b;¿ + \end{lstlisting} + \end{minipage} + +% \pause + \vspace{-1.75cm} + \strut\hfill + \begin{minipage}{6.5cm} + Fazit: + \begin{itemize} + \item + \textbf{Adressen von Variablen\\ + sind systemabhängig} + \item + Bei Definition von Datenformaten\\ + Alignment beachten \textarrow\ effizienter + \end{itemize} + \end{minipage} + +\end{frame} + +\section{Algorithmen} +\setcounter{subsection}{1} +\subsection{Rekursion} + +\begin{frame}[fragile] + + \showsubsection + + Vollständige Induktion: + \vspace*{-0.725cm} + \begin{displaymath} + \hspace*{4cm} + \left. + \begin{array}{r} + \mbox{Aussage gilt für $n = 1$}\\[2pt] + \mbox{Schluß von $n - 1$ auf $n$} + \end{array} + \right\} + \mbox{Aussage gilt für alle $n\in\mathbb{N}$} + \end{displaymath} + \vspace*{-0.5cm} + + \pause + + Türme von Hanoi + + \begin{onlyenv}<2> + \begin{center} + \includegraphics[width=12.2cm]{Tower_of_Hanoi.jpeg} + \end{center} + \end{onlyenv} + + \begin{onlyenv}<3-> + \begin{itemize} + \item + 64 Scheiben, 3 Plätze, + \only<3-4>{\hfill\makebox(0,0)[rt]{\includegraphics[width=6cm]{Tower_of_Hanoi.jpeg}}}\\ + immer 1 Scheibe verschieben + \item + Ziel: Turm verschieben + \item + Es dürfen nur kleinere Scheiben\\ + auf größeren liegen. + \bigskip + \pause + \pause + \item + $n = 1$ Scheibe: fertig + \item + Wenn $n - 1$ Scheiben verschiebbar:\\ + schiebe $n - 1$ Scheiben auf Hilfsplatz,\\ + verschiebe die darunterliegende,\\ + hole $n - 1$ Scheiben von Hilfsplatz + \end{itemize} + \begin{onlyenv}<5> + \vspace{-4.3cm} + \begin{lstlisting}[gobble=8,xleftmargin=6.4cm] + void move (int from, int to, int disks) + { + if (disks == 1) + move_one_disk (from, to); + else + { + int help = 0 + 1 + 2 - from - to; + move (from, help, disks - 1); + move (from, to, 1); + move (help, to, disks - 1); + } + } + \end{lstlisting} + \end{onlyenv} + \begin{onlyenv}<6-> + \vspace{-5.0cm} + \hspace*{7.4cm}\begin{minipage}[t]{5cm} + 32 Scheiben: + \begin{lstlisting}[gobble=10,style=terminal] + $ ¡time ./hanoi-9a¿ + ... + real 0m32,712s + user 0m32,708s + sys 0m0,000s + \end{lstlisting} + \pause[7] + \begin{itemize} + \arrowitem + etwas über 1 Minute\\ + für 64 Scheiben + \end{itemize} + \pause + \vspace*{-0.5cm} + \begin{picture}(0,0) + \color{red} + \put(0,0){\makebox(0,0)[bl]{\tikz[line width=1pt]{\draw(0,0)--(4,0.8);}}} + \put(0,0.8){\makebox(0,0)[tl]{\tikz[line width=1pt]{\draw(0,0)--(4,-0.8);}}} + \end{picture} + + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + \end{minipage} + \end{onlyenv} + \end{onlyenv} + +\end{frame} + +\subsection{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse} + +\begin{frame}[fragile] + +% \newcommand{\w}{\hspace*{0.75pt}} + + \showsubsection + + \begin{picture}(0,0) + \put(7.6,-0.5){% + \begin{minipage}[t]{5.3cm} +% \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf} + \vspace*{-1.0cm}\alt<6->{\includegraphics{landau-symbols-3.pdf}}% + {\alt<5->{\includegraphics{landau-symbols-2.pdf}}% + {\includegraphics{landau-symbols.pdf}}} + \small + \begin{description}\itemsep0pt\leftskip-0.5cm + \item[$n$:] Eingabedaten + \item[$g(n)$:] Rechenzeit + \end{description} + \end{minipage}} + \end{picture} + + \vspace*{-\bigskipamount} + + Wann ist ein Programm "`schnell"'? + + \medskip + + \begin{onlyenv}<1-2> + Türme von Hanoi: $\mathcal{O}(2^n)$ + \par\medskip + Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit! + % 32.712 * 2^32 / 3600 / 24 / 365.25 = 4452.08032888280477602859 + \begin{itemize} + \arrowitem + $\frac{32,712\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4452$ + Jahre\\[\smallskipamount] + für 64 Scheiben + \end{itemize} + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<2-> + Faustregel:\\Schachtelung der Schleifen zählen\\ + $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$ + + \bigskip + \end{onlyenv} + + \begin{onlyenv}<3> + \textbf{Beispiel: Sortieralgorithmen} + + \smallskip + + Anzahl der Vergleiche bei $n$ Strings + \begin{itemize} + \item + Maximum suchen mit Schummeln: $\mathcal{O}(1)$ + \item + Maximum suchen: $\mathcal{O}(n)$ + \item + Selection-Sort: $\mathcal{O}(n^2)$ + \item + Bubble-Sort: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$ + \item + Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$ + \end{itemize} + + \end{onlyenv} + + \begin{onlyenv}<4> + \textbf{Wie schnell ist RSA-Verschlüsselung?} + + \smallskip + + \begin{math} + c = m^e\,\%\,N + \end{math} + \quad + ("`$\%$"' = "`modulo"') + + \medskip + + \begin{lstlisting}[gobble=6,xleftmargin=2em] + int c = 1; + for (int i = 0; i < e; i++) + c = (c * m) % N; + \end{lstlisting} + + \smallskip + + \begin{itemize} + \item + $\mathcal{O}(e)$ Iterationen +% \item +% wenn $n$ die Anzahl der Binärziffern (Bits) von $e$ ist: +% $\mathcal{O}(2^n)$ Iterationen + \item + mit Trick: + $\mathcal{O}(\log e)$ Iterationen ($\log e$ = Anzahl der Ziffern von $e$) + \end{itemize} + + \smallskip + + Jede Iteration enthält eine Multiplikation und eine Division.\\ + Aufwand dafür: $\mathcal{O}(\log e)$\\ + \textarrow\ Gesamtaufwand: $\mathcal{O}\bigl((\log e)^2\bigr)$ + + \end{onlyenv} + + \begin{onlyenv}<5-> + + \textbf{Wie schnell ist RSA?}\\ + + \smallskip + + ($n$ = typische beteiligte Zahl, z.\,B. $e,p,q$) + + \begin{itemize} + \item + Ver- und Entschlüsselung (Exponentiation):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<6->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Schlüsselerzeugung (Berechnung von $d$):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\!\left((\log n)^2\right)$\hss} + \only<6->{{\color{magenta}$\mathcal{O}(n^2)$}} + \item + Verschlüsselung brechen (Primfaktorzerlegung):\\ + \strut\hbox to 3.5cm{\color{red}$\mathcal{O}\bigl(2^{\sqrt{\log n\,\cdot\,\log\log n}}\bigr)$\hss} + \only<6->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}} + \end{itemize} + + \vspace{0cm plus 1filll} + + \textbf{Die Sicherheit von RSA beruht darauf, + daß das Brechen der Verschlüsselung aufwendiger ist als + \boldmath$\mathcal{O}\bigl((\log n)^k\bigr)$ (für beliebiges $k$).} + + \vspace*{0.65cm} + + \end{onlyenv} + +\end{frame} + +\section{Objektorientierte Programmierung} + +\iffalse + +\addtocounter{subsection}{-1} +\subsection{Dynamische Speicherverwaltung} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \begin{itemize} + \item + Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen) + \item + Dynamisches Array: variable Anzahl von Elementen desselben Typs + \end{itemize} + + \bigskip + + \begin{lstlisting} + char *name[] = { "Anna", "Berthold", "Caesar" }; + + ... + + name[3] = "Dieter"; + \end{lstlisting} + + \begin{picture}(0,0) + \color{red} + \put(0,0){\line(3,1){3.5}} + \put(0,1){\line(3,-1){3.5}} + \end{picture} + +\end{frame} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \bigskip + + \begin{lstlisting} + #include <stdlib.h> + + ... + + char **name = malloc (3 * sizeof (char *)); + /* Speicherplatz für 3 Zeiger anfordern */ + + ... + + free (name) + /* Speicherplatz freigeben */ + + \end{lstlisting} + +\end{frame} + +\fi + +\subsection{Konzepte und Ziele} + +\begin{frame} + + \showsection + \showsubsection + + \begin{itemize} + \item +% Array: feste Anzahl von Elementen desselben Typs (z.\,B.\ 3 ganze Zahlen) + Array: Elemente desselben Typs (z.\,B.\ 3 ganze Zahlen) +% \item +% Dynamisches Array: variable Anzahl von Elementen desselben Typs + \item + Problem: Elemente unterschiedlichen Typs + \item + Lösung: den Typ des Elements zusätzlich speichern + \end{itemize} + \begin{itemize} + \item + Funktionen, die mit dem Objekt arbeiten: \newterm{Methoden} + \begin{onlyenv}<1> + \item + Was die Funktion bewirkt,\\ + hängt vom Typ des Objekts ab + \item + Realisierung über endlose \lstinline{if}-Ketten + \end{onlyenv} + \begin{onlyenv}<2> + \item + Was die Funktion bewirkt + \begin{picture}(0,0) + \color{red} + \put(-4.00,-0.10){\tikz{\draw[thick](0,0.25)--(3.75,-0.05);% + \draw[thick](-0.1,-0.05)--(3.75,0.3);}} + \end{picture}% + Welche Funktion aufgerufen wird,\\ + hängt vom Typ des Objekts ab: \newterm{virtuelle Methode} + \item + Realisierung über endlose \lstinline{if}-Ketten% + \begin{picture}(0,0) + \color{red} + \put(-2.75,-0.10){\tikz{\draw[thick](0,0.25)--(2.5,-0.05);% + \draw[thick](-0.1,-0.05)--(2.5,0.3);}} + \put(1.5,-1.1){\begin{rotate}{7}\large\bf\textarrow\ +% kommt gleich + nächste Woche + \end{rotate}} + \end{picture} + Zeiger, die im Objekt gespeichert sind\\ + (Genaugenommen: Tabelle von Zeigern) + \end{onlyenv} + \end{itemize} + +\end{frame} + +\begin{frame} + + \showsection + \showsubsection + + \begin{itemize} + \item + Problem: Elemente unterschiedlichen Typs + \item + Lösung: den Typ des Elements zusätzlich speichern + \item + \newterm{Methoden\/} und \newterm{virtuelle Methoden} + \end{itemize} + + \begin{itemize} + \item + Zeiger auf verschiedene Strukturen\\ + mit einem gemeinsamen Anteil von Datenfeldern\\ + \textarrow\ "`verwandte"' \newterm{Objekte}, \newterm{Klassen} von Objekten + \item + Struktur, die \emph{nur\/} den gemeinsamen Anteil enthält\\ + \textarrow\ "`Vorfahr"', \newterm{Basisklasse}, \newterm{Vererbung} + \item +% Explizite Typumwandlung eines Zeigers auf die Basisklasse\\ +% in einen Zeiger auf die \newterm{abgeleitete Klasse}\\ +% \textarrow\ Man kann ein Array unterschiedlicher Objekte\\ +% \strut\phantom{\textarrow} in einer Schleife abarbeiten.\\ + Zeiger auf die Basisklasse dürfen auf Objekte\\ + der \newterm{abgeleiteten Klasse} zeigen\\ + \textarrow\ \newterm{Polymorphie} + \end{itemize} + +\end{frame} + +\subsection{Beispiel: Zahlen und Buchstaben} + +\begin{frame}[fragile] + + \showsection + \showsubsection + + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + } t_base;¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\begin{frame}[fragile] + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + } t_base;¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + int type; + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage}\\[0.7cm] + \begin{onlyenv}<1> + \begin{minipage}{8cm} + \begin{lstlisting}[gobble=10] + ¡t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s };¿ + \end{lstlisting} + \end{minipage}% + \begin{picture}(0,0) + \color{red} + \put(-5.4,-0.8){\mbox{$\underbrace{\rule{1.45cm}{0pt}}_{\shortstack{\strut explizite\\Typumwandlung}}$}} + \end{picture} + \end{onlyenv} +% \begin{onlyenv}<2> +% \begin{minipage}{5cm} +% \begin{lstlisting}[gobble=10] +% ¡typedef union +% { +% t_base base; +% t_integer integer; +% t_string string; +% } t_object;¿ +% \end{lstlisting} +% \end{minipage} +% \end{onlyenv} + \end{center} + +\end{frame} + +\iffalse + +\subsection{Unions} + +\begin{frame}[fragile] + + \showsubsection + + Variable teilen sich denselben Speicherplatz. + + \medskip + + \begin{minipage}[t]{3.7cm} + \begin{lstlisting}[gobble=6] + ¡typedef union + { + int8_t i; + uint8_t u; + } num8_t;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{4.5cm} + \begin{lstlisting}[gobble=6] + ¡int main (void) + { + num8_t test; + test.i = -1; + printf ("%d\n", test.u); + return 0; + }¿ + \end{lstlisting} + \end{minipage} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Variable teilen sich denselben Speicherplatz. + + \medskip + + \begin{minipage}[t]{3.7cm} + \begin{lstlisting}[gobble=6] + ¡typedef union + { + char s[8]; + uint64_t x; + } num_char_t;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{4.5cm} + \begin{lstlisting}[gobble=6] + ¡int main (void) + { + num_char_t test = { "Hello!" }; + printf ("%lx\n", test.x); + return 0; + }¿ + \end{lstlisting} + \end{minipage} + +\end{frame} + +\begin{frame}[fragile] + + \showsubsection + + Variable teilen sich denselben Speicherplatz. + + \medskip + + \begin{minipage}[t]{3.7cm} + \begin{lstlisting}[gobble=6] + ¡typedef union + { + t_base base; + t_integer integer; + t_string string; + } t_object;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3.0cm} + \begin{lstlisting}[gobble=6] + + ¡typedef struct + { + int type; + } t_base;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3.0cm} + \begin{lstlisting}[gobble=6] + + ¡typedef struct + { + int type; + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage}% + \begin{minipage}[t]{3.0cm} + \begin{lstlisting}[gobble=6] + + ¡typedef struct + { + int type; + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage} + + \bigskip + + \begin{center} + \begin{minipage}{8.5cm} + \begin{lstlisting}[gobble=8] + ¡if (this->base.type == T_INTEGER) + printf ("Integer: %d\n", this->integer.content); + else if (this->base.type == T_STRING) + printf ("String: \"%s\"\n", this->string.content);¿ + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\subsection{Virtuelle Methoden} + +\begin{frame}[fragile] + \showsubsection + + \begin{lstlisting} + void print_object (t_object *this) + { + if (this->base.type == T_INTEGER) + printf ("Integer: %d\n", this->integer.content); + else if (this->base.type == T_STRING) + printf ("String: \"%s\"\n", this->string.content); + } + \end{lstlisting} + + \begin{picture}(0,0) + \color{red} + \put(9,1.7){\shortstack[l]{if-Kette:\\\strut wird unübersichtlich}} + \put(1,-2){\mbox{\textarrow}} + \put(0,-3){\mbox{Zeiger auf Funktionen}} + \end{picture} + + \begin{lstlisting}[xleftmargin=4cm] + void print_integer (t_object *this) + { + printf ("Integer: %d\n", this->integer.content); + } + + void print_string (t_object *this) + { + printf ("String: \"%s\"\n", this->string.content); + } + \end{lstlisting} + +\end{frame} + +\begin{frame}[fragile] + \showsubsection + + Zeiger auf Funktionen + + \medskip + + \begin{lstlisting} + void (* print) (t_object *this); + \end{lstlisting} + \begin{picture}(0,1.2)(0,-0.9) + \color{red} + \put(0.95,0.3){\mbox{$\underbrace{\rule{1cm}{0pt}}$}} + \put(0.2,-0.7){\shortstack{das, worauf print zeigt,\\ist eine Funktion}} + \end{picture} + + \begin{itemize} + \item + Objekt enthält Zeiger auf Funktion + \begin{onlyenv}<1> + \medskip + \begin{lstlisting}[gobble=10] + typedef struct + { + void (* print) (union t_object *this); + int content; + } t_integer; + \end{lstlisting} + \end{onlyenv} + \begin{onlyenv}<2-> + \vspace*{-3.5cm} % Why doesn't a picture environment work here??? :-( + \begin{lstlisting}[gobble=10,xleftmargin=5.5cm] + typedef struct + { + void (* print) (union t_object *this); + int content; + } t_integer; + \end{lstlisting} + \vspace*{0.85cm} + \bigskip + \smallskip + \end{onlyenv} + \pause + \item + Konstruktor initialisiert diesen Zeiger + \begin{onlyenv}<2> + \medskip + \begin{lstlisting}[gobble=10] + t_object *new_integer (int i) + { + t_object *p = malloc (sizeof (t_integer)); + p->integer.print = print_integer; + p->integer.content = i; + return p; + } + \end{lstlisting} + \vspace*{-2cm} + \end{onlyenv} + \pause + \item + Aufruf: "`automatisch"' die richtige Funktion + \begin{onlyenv}<3> + \medskip + \begin{lstlisting}[gobble=10] + for (int i = 0; object[i]; i++) + object[i]->base.print (object[i]); + \end{lstlisting} + \end{onlyenv} + \pause + \medskip + \item + in größeren Projekten:\\ + Objekt enthält Zeiger auf Tabelle von Funktionen + \end{itemize} +\end{frame} + +\subsection{Beispiel: Graphische Benutzeroberfläche (GUI)} + +\begin{frame}[fragile] + + \showsubsection + + \scriptsize + \begin{lstlisting} + #include <gtk/gtk.h> + + int main (int argc, char **argv) + { + gtk_init (&argc, &argv); + GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL); + gtk_window_set_title (GTK_WINDOW (window), "Hello"); + g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); + GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); + gtk_container_add (GTK_CONTAINER (window), vbox); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 10); + GtkWidget *label = gtk_label_new ("Hello, world!"); + gtk_container_add (GTK_CONTAINER (vbox), label); + GtkWidget *button = gtk_button_new_with_label ("Quit"); + g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); + gtk_container_add (GTK_CONTAINER (vbox), button); + gtk_widget_show (button); + gtk_widget_show (label); + gtk_widget_show (vbox); + gtk_widget_show (window); + gtk_main (); + return 0; + } + \end{lstlisting} + + \vspace*{-6cm}\strut\hfill + \includegraphics[scale=0.85]{hello-gtk.png}\\[2cm] + \begin{flushright} + \normalsize\bf Praktikumsversuch:\\ + Objektorientiertes Zeichenprogramm + \end{flushright} + +\end{frame} + +\subsection{Ausblick: C++} + +\begin{frame}[fragile] + \showsubsection + + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + void (* print) (union t_object *this); + } t_base;¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5.5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + void (* print) (...); + int content; + } t_integer;¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡typedef struct + { + void (* print) (union t_object *this); + char *content; + } t_string;¿ + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\begin{frame}[fragile] + \showsubsection + + \begin{center} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡struct TBase + { + virtual void print (void); + };¿ + \end{lstlisting} + \end{minipage}\\[0.5cm] + \begin{minipage}{5.5cm} + \begin{lstlisting}[gobble=8] + ¡struct TInteger: public TBase + { + virtual void print (void); + int content; + };¿ + \end{lstlisting} + \end{minipage} + \begin{minipage}{5cm} + \begin{lstlisting}[gobble=8] + ¡struct TString: public TBase + { + virtual void print (void); + char *content; + };¿ + \end{lstlisting} + \end{minipage} + \end{center} + +\end{frame} + +\fi + +\end{document} diff --git a/20200109/landau-symbols-2.pdf b/20200109/landau-symbols-2.pdf new file mode 120000 index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4 --- /dev/null +++ b/20200109/landau-symbols-2.pdf @@ -0,0 +1 @@ +../common/landau-symbols-2.pdf \ No newline at end of file diff --git a/20200109/landau-symbols-3.pdf b/20200109/landau-symbols-3.pdf new file mode 120000 index 0000000000000000000000000000000000000000..46efa409b35ff5df763c744a423599cba515d886 --- /dev/null +++ b/20200109/landau-symbols-3.pdf @@ -0,0 +1 @@ +../common/landau-symbols-3.pdf \ No newline at end of file diff --git a/20200109/landau-symbols.pdf b/20200109/landau-symbols.pdf new file mode 120000 index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565 --- /dev/null +++ b/20200109/landau-symbols.pdf @@ -0,0 +1 @@ +../common/landau-symbols.pdf \ No newline at end of file diff --git a/20200109/names.h b/20200109/names.h new file mode 100644 index 0000000000000000000000000000000000000000..a265ff4141a2cc578d3f6f402822a2dbbd5cea90 --- /dev/null +++ b/20200109/names.h @@ -0,0 +1,50 @@ +"Michael", "Laura", +"Elias", "Julia", +"Luca", "Anna", +"Liam", "Emma", +"Alexander", "Lena", +"Noah", "Vanessa", +"Jonas", "Lea", +"Marcel", "Mila", +"Daniel", "Lisa", +"David", "Lina", +"Milan", "Sarah", +"Julian", "Alina", +"Linus", "Emilia", +"Thomas", "Nina", +"Samuel", "Elena", +"Levin", "Lara", +"Levi", "Melanie", +"Jan", "Hannah", +"Lukas", "Sandra", +"Tim", "Leonie", +"Patrick", "Sophie", +"Marvin", "Mia", +"Andreas", "Amelie", +"Leon", "Selina", +"Tobias", "Luisa", +"Simon", "Maria", +"Valentin", "Jana", +"Robin", "Johanna", +"Paul", "Marie", +"Markus", "Milena", +"Benjamin", "Melina", +"Stefan", "Michelle", +"Felix", "Emily", +"Florian", "Renesmee", +"Fabian", "Aylin", +"Emil", "Jessica", +"Aaron", "Franziska", +"Manuel", "Jasmin", +"Christian", "Fiona", +"Dominik", "Sina", +"Joshua", "Jennifer", +"Moritz", "Claudia", +"Sebastian", "Nicole", +"Peter", "Annika", +"Philipp", "Sophia", +"Max", "Katharina", +"Johannes", "Isabella", +"Finn", "Nele", +"Adrian", "Elisabeth", +"Martin", "Pia", diff --git a/20200109/objects-1.c b/20200109/objects-1.c new file mode 100644 index 0000000000000000000000000000000000000000..1a628668fd7b8fb3a0d9886ac14e8e909bc23793 --- /dev/null +++ b/20200109/objects-1.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { &i, &s }; + + return 0; +} diff --git a/20200109/objects-2.c b/20200109/objects-2.c new file mode 100644 index 0000000000000000000000000000000000000000..a47cfb4276085399afb86795d04b1f6ae20c95bf --- /dev/null +++ b/20200109/objects-2.c @@ -0,0 +1,28 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + return 0; +} diff --git a/20200109/objects-3.c b/20200109/objects-3.c new file mode 100644 index 0000000000000000000000000000000000000000..ff9224c0767ccad39f5b1396720ee73b6a0455fb --- /dev/null +++ b/20200109/objects-3.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", object[i]->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", object[i]->content); + + return 0; +} diff --git a/20200109/objects-4.c b/20200109/objects-4.c new file mode 100644 index 0000000000000000000000000000000000000000..ef7bffe80471d4b014258824421dce0557fc41dd --- /dev/null +++ b/20200109/objects-4.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", (t_integer *) object[i]->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", (t_string *) object[i]->content); + + return 0; +} diff --git a/20200109/objects-5.c b/20200109/objects-5.c new file mode 100644 index 0000000000000000000000000000000000000000..820181d87e2a04b81cd2e03aa7980d970cd6c1a6 --- /dev/null +++ b/20200109/objects-5.c @@ -0,0 +1,34 @@ +#include <stdio.h> + +typedef struct +{ + int type; +} t_base; + +typedef struct +{ + int type; + int content; +} t_integer; + +typedef struct +{ + int type; + char *content; +} t_string; + +int main (void) +{ + t_integer i = { 1, 42 }; + t_string s = { 2, "Hello, world!" }; + + t_base *object[] = { (t_base *) &i, (t_base *) &s }; + + for (int i = 0; i < 2; i++) + if (object[i]->type == 1) + printf ("Integer: %d\n", ((t_integer *) object[i])->content); + else if (object[i]->type == 2) + printf ("String: \"%s\"\n", ((t_string *) object[i])->content); + + return 0; +} diff --git a/20200109/pgslides.sty b/20200109/pgslides.sty new file mode 120000 index 0000000000000000000000000000000000000000..da062f7454c898ca1bc89bc29f268d9f00b21e5b --- /dev/null +++ b/20200109/pgslides.sty @@ -0,0 +1 @@ +../20200102/pgslides.sty \ No newline at end of file diff --git a/20200109/qsort-1.c b/20200109/qsort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..c5431b853862e62812016f4fd3a031eeb0b5c9df --- /dev/null +++ b/20200109/qsort-1.c @@ -0,0 +1,70 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20200109/qsort-2.c b/20200109/qsort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..cfdc2ec11a92a4292c9443e01453cce818e9e73a --- /dev/null +++ b/20200109/qsort-2.c @@ -0,0 +1,72 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } + if (l < right) + quicksort (name, l, right); +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20200109/qsort-3.c b/20200109/qsort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..e6b7d9909473af6d8c13d3745dc6b07e8ea75699 --- /dev/null +++ b/20200109/qsort-3.c @@ -0,0 +1,74 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, char *pivot, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (name[i] == pivot) + printf (" <=="); + else if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, char *pivot, int left, int right) +{ + int result = strcmp (name[left], pivot); + comparisons++; + display (name, pivot, left, right); + usleep (200000); + return result; +} + +void quicksort (char **name, int left, int right) +{ + int p = (left + right) / 2; + char *pivot = name[p]; + int l = left; + int r = right; + while (l < r) + { + while (l < r && compare (name, pivot, l, r - 1) < 0) + l++; + while (l < r && compare (name, pivot, r - 1, l) > 0) + r--; + if (l < r) + { + char *temp = name[r - 1]; + name[r - 1] = name[l]; + name[l] = temp; + l++; + r--; + } + } + if (r > left) + quicksort (name, left, r); + if (l < right) + quicksort (name, l, right); +} + +void sort (char **name) +{ + int r = 0; + while (name[r]) + r++; + quicksort (name, 0, r); +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, NULL, -1, -1); + return 0; +} diff --git a/20200109/sort-0.c b/20200109/sort-0.c new file mode 100644 index 0000000000000000000000000000000000000000..70e0e717cbfd42a27bf90f419c216fa18b0783c7 --- /dev/null +++ b/20200109/sort-0.c @@ -0,0 +1,16 @@ +#include <stdio.h> + +int find_first (char **name) +{ + return 2; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + printf ("%s\n", name[first]); + return 0; +} diff --git a/20200109/sort-1.c b/20200109/sort-1.c new file mode 100644 index 0000000000000000000000000000000000000000..3f009d45657f84e462db48a67fa22821819216ad --- /dev/null +++ b/20200109/sort-1.c @@ -0,0 +1,21 @@ +#include <stdio.h> +#include <string.h> + +int find_first (char **name) +{ + int first = 0; + for (int i = 1; name[i]; i++) + if (strcmp (name[i], name[first]) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + printf ("%s\n", name[first]); + return 0; +} diff --git a/20200109/sort-2.c b/20200109/sort-2.c new file mode 100644 index 0000000000000000000000000000000000000000..638e6e2caa670ceace0a854d0827292dfcb59ca5 --- /dev/null +++ b/20200109/sort-2.c @@ -0,0 +1,46 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name) +{ + int first = 0; + for (int i = 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name); + display (name, first, -1); + return 0; +} diff --git a/20200109/sort-3.c b/20200109/sort-3.c new file mode 100644 index 0000000000000000000000000000000000000000..430a6fc0e95fcb9bc225e3572566c8d187016130 --- /dev/null +++ b/20200109/sort-3.c @@ -0,0 +1,46 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + int first = find_first (name, 0); + display (name, first, -1); + return 0; +} diff --git a/20200109/sort-4.c b/20200109/sort-4.c new file mode 100644 index 0000000000000000000000000000000000000000..19d4f416a2d30c5181ad289fe1d0dcba91ee81cf --- /dev/null +++ b/20200109/sort-4.c @@ -0,0 +1,59 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/sort-5.c b/20200109/sort-5.c new file mode 100644 index 0000000000000000000000000000000000000000..f0742bc8665d0b13edf4ad4ad3fe4790c1e6b929 --- /dev/null +++ b/20200109/sort-5.c @@ -0,0 +1,60 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { + #include "names.h" + NULL + }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/sort-6.c b/20200109/sort-6.c new file mode 100644 index 0000000000000000000000000000000000000000..94a1a16abfacda7bb728f8d3317cd00b4cf8ccde --- /dev/null +++ b/20200109/sort-6.c @@ -0,0 +1,60 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; +// display (name, left, right); +// usleep (200); + return result; +} + +int find_first (char **name, int i0) +{ + int first = i0; + for (int i = i0 + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + return first; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = find_first (name, sorted); + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { + #include "names.h" + NULL + }; + sort (name); + display (name, -1, -1); + return 0; +} diff --git a/20200109/sort-7.c b/20200109/sort-7.c new file mode 100644 index 0000000000000000000000000000000000000000..46132dd247a061dda0e5ebade9c5b818a1a74fcb --- /dev/null +++ b/20200109/sort-7.c @@ -0,0 +1,53 @@ +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +int comparisons = 0; + +void display (char **name, int left, int right) +{ + printf ("\e[H\e[J"); + for (int i = 0; name[i]; i++) + { + printf ("%s", name[i]); + if (i == left || i == right) + printf (" <--"); + printf ("\n"); + } + printf ("%d\n", comparisons); +} + +int compare (char **name, int left, int right) +{ + int result = strcmp (name[left], name[right]); + comparisons++; + display (name, left, right); + usleep (200000); + return result; +} + +void sort (char **name) +{ + int sorted = 0; + while (name[sorted]) + { + int first = sorted; + for (int i = sorted + 1; name[i]; i++) + if (compare (name, i, first) < 0) + first = i; + char *temp = name[sorted]; + name[sorted] = name[first]; + name[first] = temp; + sorted++; + } +} + +int main (void) +{ + char *name[] = { "Otto", "Lisa", "Anna", "Heinrich", "Siegfried", "Peter", + "Dieter", "Hugo", "Berta", "Maria", "Fritz", "Box", "Hans", + "Thomas", "Ulrich", "Zacharias", NULL }; + sort (name); + display (name, -1, -1); + return 0; +}