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;
+}