diff --git a/20230316/ad-20230316-1-array-und-pointer.png b/20230316/ad-20230316-1-array-und-pointer.png
new file mode 100644
index 0000000000000000000000000000000000000000..70aeab6c1ea28a91395a9ecfa47426167d2bdca7
Binary files /dev/null and b/20230316/ad-20230316-1-array-und-pointer.png differ
diff --git a/20230316/ad-20230316-2-pointer-auf-pointer.png b/20230316/ad-20230316-2-pointer-auf-pointer.png
new file mode 100644
index 0000000000000000000000000000000000000000..8452e136dd86586862f241fc392f91905102cb39
Binary files /dev/null and b/20230316/ad-20230316-2-pointer-auf-pointer.png differ
diff --git a/20230316/ad-20230316-3-array-von-arrays.png b/20230316/ad-20230316-3-array-von-arrays.png
new file mode 100644
index 0000000000000000000000000000000000000000..b65ce42996eb6c55d7c916b1961bf2810509d463
Binary files /dev/null and b/20230316/ad-20230316-3-array-von-arrays.png differ
diff --git a/20230316/ad-20230316.pdf b/20230316/ad-20230316.pdf
index c372fe296d1a3024f5f1a6fa76a403c6eb152996..671534a740818a59de6e48ac0a011f96bd46a2f6 100644
Binary files a/20230316/ad-20230316.pdf and b/20230316/ad-20230316.pdf differ
diff --git a/20230316/ad-20230316.tex b/20230316/ad-20230316.tex
index db1740fe61de5331fd8255326d451c62761b2761..f2eef8519d4546a8f81767412d6a00483ec7e7f4 100644
--- a/20230316/ad-20230316.tex
+++ b/20230316/ad-20230316.tex
@@ -150,7 +150,7 @@
   {\color{medgreen}\textbf{Differentialgleichungen}}
   \begin{itemize}
     \item Pendel
-    \item Basketball
+    \item Planetenbahnen
   \end{itemize}
 
   {\color{medgreen}\textbf{Rekursion}}
@@ -627,6 +627,10 @@
     \arrowitem
       Fazit:\\
       Ein Hoch auf \lstinline{typedef}!
+    \arrowitem
+      Trotzdem: {\color{red}Vorsicht!}\\
+      Ein \lstinline{p++} auf einen Zeiger vom Typ \lstinline{string5 *p}\\
+      ergibt anscheinend undefiniertes Verhalten!
   \end{itemize}
 
 \end{frame}
diff --git a/20230316/ad-20230316.xcf.gz b/20230316/ad-20230316.xcf.gz
new file mode 100644
index 0000000000000000000000000000000000000000..d65a1b6380d20ec9ef9383e6b492a67d8efdcb97
Binary files /dev/null and b/20230316/ad-20230316.xcf.gz differ
diff --git a/20230316/arrays-pointers-01.c b/20230316/arrays-pointers-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..808bf8f8f7a540e0dc44cd3d8d79e9a5011d9249
--- /dev/null
+++ b/20230316/arrays-pointers-01.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+
+char a[] = "Test";
+char *p = "Test";
+
+int main (void)
+{
+  char *q;
+  q = a;
+  printf ("%016zx: %s\n", q, q);
+  q = &a;
+  printf ("%016zx: %s\n", q, q);
+  q = p;
+  printf ("%016zx: %s\n", q, q);
+  q = &p;
+  printf ("%016zx: %s\n", q, q);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-02.c b/20230316/arrays-pointers-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..77568c6f42530fd66b1b0a0a907450e786c99da7
--- /dev/null
+++ b/20230316/arrays-pointers-02.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+char *a[] = { "Dies", "ist", "ein", "Test", NULL };
+
+int main (void)
+{
+  for (char **p = a; *p; p++)
+    printf ("%s\n", *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-03.c b/20230316/arrays-pointers-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d0aa3713602dd4d21813a9fbce0d0bfc170d81e
--- /dev/null
+++ b/20230316/arrays-pointers-03.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+char a[][] = { "Dies", "ist", "ein", "Test", NULL };
+
+int main (void)
+{
+  for (char **p = a; *p; p++)
+    printf ("%s\n", *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-04.c b/20230316/arrays-pointers-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..9152cb56f3c73a96a280d1012a5c77413435435e
--- /dev/null
+++ b/20230316/arrays-pointers-04.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", NULL };
+
+int main (void)
+{
+  for (char **p = a; *p; p++)
+    printf ("%s\n", *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-05.c b/20230316/arrays-pointers-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..fa9232e839af74f0c7624c7e193d7576be2f666a
--- /dev/null
+++ b/20230316/arrays-pointers-05.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", NULL };
+
+int main (void)
+{
+  for (char *p = a; *p; p++)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-06.c b/20230316/arrays-pointers-06.c
new file mode 100644
index 0000000000000000000000000000000000000000..91b20d7311fa81da7cbb628eb2f126e2a9cd2acd
--- /dev/null
+++ b/20230316/arrays-pointers-06.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", NULL };
+
+int main (void)
+{
+  for (char *p = a; *p; p += 5)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-07.c b/20230316/arrays-pointers-07.c
new file mode 100644
index 0000000000000000000000000000000000000000..87edda5aa010fe1ab2be5797eff126f062ee0ea9
--- /dev/null
+++ b/20230316/arrays-pointers-07.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", "" };
+
+                                 /* "NULL" ist ein Zeiger mit Wert 0
+                                    und wird hier uminterpretiert zu
+                                    einer Speicherzelle mit Wert 0,
+                                    also zu einem Leerstring. */
+int main (void)
+{
+  for (char *p = a; *p; p += 5)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-08.c b/20230316/arrays-pointers-08.c
new file mode 100644
index 0000000000000000000000000000000000000000..ce22f2b070a49b9875f7c09e0a93404f7058e624
--- /dev/null
+++ b/20230316/arrays-pointers-08.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", "" };
+
+                                 /* "NULL" ist ein Zeiger mit Wert 0
+                                    und wird hier uminterpretiert zu
+                                    einer Speicherzelle mit Wert 0,
+                                    also zu einem Leerstring. */
+int main (void)
+{
+  for (char *p = &a; *p; p += 5)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-09.c b/20230316/arrays-pointers-09.c
new file mode 100644
index 0000000000000000000000000000000000000000..ad3b23c87b18c3bd1159bba1e8da0c349ee4ff28
--- /dev/null
+++ b/20230316/arrays-pointers-09.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", "" };
+
+                                 /* "NULL" ist ein Zeiger mit Wert 0
+                                    und wird hier uminterpretiert zu
+                                    einer Speicherzelle mit Wert 0,
+                                    also zu einem Leerstring. */
+int main (void)
+{
+  for (char *p[5] = a; *p; p += 5)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-10.c b/20230316/arrays-pointers-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..37040df6f8f19b299d9275baf7bd7aa3f31e3457
--- /dev/null
+++ b/20230316/arrays-pointers-10.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+char a[][5] = { "Dies", "ist", "ein", "Test", "" };
+
+                                 /* "NULL" ist ein Zeiger mit Wert 0
+                                    und wird hier uminterpretiert zu
+                                    einer Speicherzelle mit Wert 0,
+                                    also zu einem Leerstring. */
+int main (void)
+{
+  for (char *p = a[0]; *p; p += 5)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-11.c b/20230316/arrays-pointers-11.c
new file mode 100644
index 0000000000000000000000000000000000000000..32c7fb6523161ebd44e455d589e1d5a56f0051bf
--- /dev/null
+++ b/20230316/arrays-pointers-11.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  for (short_string *p = a; *p; p++)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-12.c b/20230316/arrays-pointers-12.c
new file mode 100644
index 0000000000000000000000000000000000000000..82d54af5db5ef5c7982950f2bb16f31e06e8f48c
--- /dev/null
+++ b/20230316/arrays-pointers-12.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  for (short_string *p = a; p[0]; p++)
+    printf ("%s\n", p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-13.c b/20230316/arrays-pointers-13.c
new file mode 100644
index 0000000000000000000000000000000000000000..0eebcc7d69ef68a4c6e1498205f137a3326b7875
--- /dev/null
+++ b/20230316/arrays-pointers-13.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  for (short_string *p = a; p[0]; p++)
+    printf ("%s\n", *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-14.c b/20230316/arrays-pointers-14.c
new file mode 100644
index 0000000000000000000000000000000000000000..35eebc42020363d3421afa733e895f6cd035ee54
--- /dev/null
+++ b/20230316/arrays-pointers-14.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  for (short_string *p = a; p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-15.c b/20230316/arrays-pointers-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..a97e711c46ed901c53912dc067eaa33bf99322b4
--- /dev/null
+++ b/20230316/arrays-pointers-15.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  short_string *p = a;
+  for (; p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-16.c b/20230316/arrays-pointers-16.c
new file mode 100644
index 0000000000000000000000000000000000000000..f90570ae24cf8e34e9e6f2adab40187be4237eb0
--- /dev/null
+++ b/20230316/arrays-pointers-16.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  short_string *p = a;
+  for (; *p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-17.c b/20230316/arrays-pointers-17.c
new file mode 100644
index 0000000000000000000000000000000000000000..c359745c50cb018ecac9a0ef239ab3721d50e367
--- /dev/null
+++ b/20230316/arrays-pointers-17.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string a[] = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  volatile short_string *p = a;
+  for (; p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-17.s b/20230316/arrays-pointers-17.s
new file mode 100644
index 0000000000000000000000000000000000000000..351604705315a7758d588035c9e02683d7929861
--- /dev/null
+++ b/20230316/arrays-pointers-17.s
@@ -0,0 +1,46 @@
+	.file	"arrays-pointers-17.c"
+	.text
+	.section	.rodata.str1.1,"aMS",@progbits,1
+.LC0:
+	.string	"%016zx: %s\n"
+	.text
+	.globl	main
+	.type	main, @function
+main:
+.LFB11:
+	.cfi_startproc
+	subq	$8, %rsp
+	.cfi_def_cfa_offset 16
+	leaq	a(%rip), %rdx
+	movq	%rdx, %rsi
+	leaq	.LC0(%rip), %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %edx
+	movl	$0, %esi
+	leaq	.LC0(%rip), %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+	addq	$8, %rsp
+	.cfi_def_cfa_offset 8
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	main, .-main
+	.globl	a
+	.data
+	.align 16
+	.type	a, @object
+	.size	a, 25
+a:
+	.string	"Dies"
+	.string	"ist"
+	.zero	1
+	.string	"ein"
+	.zero	1
+	.string	"Test"
+	.string	""
+	.zero	4
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230316/arrays-pointers-18.c b/20230316/arrays-pointers-18.c
new file mode 100644
index 0000000000000000000000000000000000000000..58f04a4ec183be6837975eef1844b69129bd9d4f
--- /dev/null
+++ b/20230316/arrays-pointers-18.c
@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string *a = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  volatile short_string *p = a;
+  for (; *p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-19.c b/20230316/arrays-pointers-19.c
new file mode 100644
index 0000000000000000000000000000000000000000..d79a436e14e4736a7af0989ec12d18babd44626c
--- /dev/null
+++ b/20230316/arrays-pointers-19.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+typedef char short_string[5];
+
+short_string *p = { "Dies", "ist", "ein", "Test", "" };
+
+int main (void)
+{
+  for (; *p[0]; p++)
+    printf ("%016zx: %s\n", (size_t) p, *p);
+  printf ("%016zx: %s\n", (size_t) p, *p);
+  return 0;
+}
diff --git a/20230316/arrays-pointers-19.s b/20230316/arrays-pointers-19.s
new file mode 100644
index 0000000000000000000000000000000000000000..d5a0d378e2d3a996300f882b7b4ba991bec8119d
--- /dev/null
+++ b/20230316/arrays-pointers-19.s
@@ -0,0 +1,52 @@
+	.file	"arrays-pointers-19.c"
+	.text
+	.section	.rodata.str1.1,"aMS",@progbits,1
+.LC0:
+	.string	"%016zx: %s\n"
+	.text
+	.globl	main
+	.type	main, @function
+main:
+.LFB11:
+	.cfi_startproc
+	pushq	%rbx
+	.cfi_def_cfa_offset 16
+	.cfi_offset 3, -16
+	movq	p(%rip), %rsi
+	cmpb	$0, (%rsi)
+	je	.L2
+	leaq	.LC0(%rip), %rbx
+.L3:
+	movq	%rsi, %rdx
+	movq	%rbx, %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movq	p(%rip), %rax
+	leaq	5(%rax), %rsi
+	movq	%rsi, p(%rip)
+	cmpb	$0, 5(%rax)
+	jne	.L3
+.L2:
+	movq	%rsi, %rdx
+	leaq	.LC0(%rip), %rdi
+	movl	$0, %eax
+	call	printf@PLT
+	movl	$0, %eax
+	popq	%rbx
+	.cfi_def_cfa_offset 8
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	main, .-main
+	.globl	p
+	.section	.rodata.str1.1
+.LC1:
+	.string	"Dies"
+	.section	.data.rel.local,"aw"
+	.align 8
+	.type	p, @object
+	.size	p, 8
+p:
+	.quad	.LC1
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230316/aufgabe-4-gpt-pg-01.c b/20230316/aufgabe-4-gpt-pg-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ae7738ea18d4403b44fe3115dc80e96b162772c
--- /dev/null
+++ b/20230316/aufgabe-4-gpt-pg-01.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define XBM_WIDTH 14
+#define XBM_HEIGHT 14
+
+static unsigned char xbm_bits[] = {
+  0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+  0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+  0xf0, 0x03, 0x00, 0x00
+};
+
+int main(int argc, char **argv)
+{
+  // Öffne die Ausgabedatei
+  FILE *output_file = fopen("test.pbm", "w");
+  if (output_file == NULL) {
+    printf("Fehler beim Öffnen der Ausgabedatei\n");
+    return 1;
+  }
+
+  // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+  fprintf(output_file, "P1\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+  // Iteriere über jedes Byte im XBM-Array
+  for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) {  // Iteriere über jedes Bit im aktuellen Byte
+    for (int j = 7; j >= 0; j--) {
+      // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+      uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+      fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+    }
+  }
+
+  // Schließe die Ausgabedatei
+  fclose(output_file);
+
+  return 0;
+}
diff --git a/20230316/aufgabe-4-gpt-pg-02.c b/20230316/aufgabe-4-gpt-pg-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..5f12d5c4ca7fc64aac4b9aa6eccf90dcb0f7113b
--- /dev/null
+++ b/20230316/aufgabe-4-gpt-pg-02.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define XBM_WIDTH 14
+#define XBM_HEIGHT 14
+
+static unsigned char xbm_bits[] = {
+  0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+  0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+  0xf0, 0x03, 0x00, 0x00
+};
+
+int main(int argc, char **argv)
+{
+  // Öffne die Ausgabedatei
+  FILE *output_file = fopen("test.pbm", "w");
+  if (output_file == NULL) {
+    printf("Fehler beim Öffnen der Ausgabedatei\n");
+    return 1;
+  }
+
+  // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+  fprintf(output_file, "P1\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+  // Iteriere über jedes Byte im XBM-Array
+  for (int i = 0; i < XBM_HEIGHT * (XBM_WIDTH + 7) / 8; i++) {  // Iteriere über jedes Bit im aktuellen Byte
+    for (int j = 7; j >= 0; j--) {
+      // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+      uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+      fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+    }
+  }
+
+  // Schließe die Ausgabedatei
+  fclose(output_file);
+
+  return 0;
+}
diff --git a/20230316/aufgabe-4-gpt.c b/20230316/aufgabe-4-gpt.c
new file mode 100644
index 0000000000000000000000000000000000000000..e93f72b9e4ed5eab57f31156ae880ab466cb1a8a
--- /dev/null
+++ b/20230316/aufgabe-4-gpt.c
@@ -0,0 +1,38 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define XBM_WIDTH 14
+#define XBM_HEIGHT 14
+
+static unsigned char xbm_bits[] = {
+  0x00, 0x00, 0xf0, 0x03, 0x08, 0x04, 0x04, 0x08, 0x02, 0x10, 0x32, 0x13,
+  0x22, 0x12, 0x02, 0x10, 0x0a, 0x14, 0x12, 0x12, 0xe4, 0x09, 0x08, 0x04,
+  0xf0, 0x03, 0x00, 0x00
+};
+
+int main(int argc, char **argv)
+{
+  // Öffne die Ausgabedatei
+  FILE *output_file = fopen("test.pbm", "w");
+  if (output_file == NULL) {
+    printf("Fehler beim Öffnen der Ausgabedatei\n");
+    return 1;
+  }
+
+  // Schreibe die PBM-Dateikennung, Breite und Höhe in die Ausgabedatei
+  fprintf(output_file, "P4\n%d %d\n", XBM_WIDTH, XBM_HEIGHT);
+
+  // Iteriere über jedes Byte im XBM-Array
+  for (int i = 0; i < XBM_HEIGHT * XBM_WIDTH / 8; i++) {  // Iteriere über jedes Bit im aktuellen Byte
+    for (int j = 7; j >= 0; j--) {
+      // Lies das aktuelle Bit des XBM-Arrays und schreibe es in die Ausgabedatei
+      uint8_t xbm_bit = (xbm_bits[i] >> j) & 1;
+      fprintf(output_file, "%c", xbm_bit ? '1' : '0');
+    }
+  }
+
+  // Schließe die Ausgabedatei
+  fclose(output_file);
+
+  return 0;
+}
diff --git a/20230316/test.pbm b/20230316/test.pbm
new file mode 100644
index 0000000000000000000000000000000000000000..7980589686ea49a4f37217b36624d6515632de57
--- /dev/null
+++ b/20230316/test.pbm
@@ -0,0 +1,3 @@
+P1
+14 14
+000000000000000011110000000000110000100000000100000001000000100000000010000100000011001000010011001000100001001000000010000100000000101000010100000100100001001011100100000010010000100000000100111100000000001100000000000000000000000100011011000000110011101100111000000000000000000000000000
\ No newline at end of file
diff --git a/20230323/Zeichen_123.pdf b/20230323/Zeichen_123.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..fdbc897227df059cfda790a16555e6e417682116
--- /dev/null
+++ b/20230323/Zeichen_123.pdf
@@ -0,0 +1 @@
+../common/Zeichen_123.pdf
\ No newline at end of file
diff --git a/20230323/ad-20230323.pdf b/20230323/ad-20230323.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..6ecdfeb0c0151704df14f3a8ea5b018c89050ab8
Binary files /dev/null and b/20230323/ad-20230323.pdf differ
diff --git a/20230323/ad-20230323.tex b/20230323/ad-20230323.tex
new file mode 100644
index 0000000000000000000000000000000000000000..eb10a72ebae1bb319b7e9b83b32cabf566580bb5
--- /dev/null
+++ b/20230323/ad-20230323.tex
@@ -0,0 +1,1088 @@
+% ad-20230322.pdf - Lecture Slides on Algorithms and Data Structures in C/C++
+% Copyright (C) 2018, 2019, 2020, 2021, 2022, 2023  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: Einführung
+
+\documentclass[10pt,t]{beamer}
+
+\usepackage{pgslides}
+\usepackage{tikz}
+%\usepackage{rotating}
+
+\newcommand{\underconstruction}{%
+  \begin{picture}(0,0)
+    \color{black}
+    \put(6,-2.2){\makebox(0,0)[b]{\includegraphics[width=1.5cm]{Zeichen_123.pdf}}}
+    \put(6,-2.5){\makebox(0,0)[t]{\shortstack{Änderungen\\vorbehalten}}}
+  \end{picture}}
+
+\title{Algorithmen und Datenstrukturen in C/C++}
+\author{Prof.\ Dr.\ rer.\ nat.\ Peter Gerwinski}
+\date{22.\ März 2023}
+
+\begin{document}
+
+\maketitleframe
+
+% \sectionnonumber{Vorab: Online-Werkzeuge}
+% 
+% \begin{frame}
+% 
+%   \showsectionnonumber
+%   \begin{itemize}
+%     \item
+%       \textbf{Mumble}: Seminarraum 2\\
+%       Fragen: Mikrophon einschalten oder über den Chat\\
+%       Umfragen: über den Chat
+%     \smallskip
+%     \item
+%       \textbf{VNC}: Kanal 6, Passwort: \lstinline[style=cmd]{testcvh}\\
+%       Eigenen Bildschirm freigeben: per VNC-Server oder Web-Interface\\
+%       Kamerabild übertragen: Link zu Web-Interface auf Anfrage
+%     \smallskip
+%     \item
+%       Allgemeine Informationen:
+%       \url{https://www.cvh-server.de/online-werkzeuge/}
+%     \smallskip
+%     \item
+%       Notfall-Schnellzugang: \url{https://www.cvh-server.de/virtuelle-raeume/}\\
+%       Seminarraum 2, VNC-Passwort: \lstinline[style=cmd]{testcvh}
+%     \smallskip
+%     \item
+%       Bei Problemen: bitte notieren:\\
+%       Art des Problems, genaue Uhrzeit, JavaScript-Fehlermeldungen (F12)
+%     \bigskip
+%     \item
+%       GitLab: \url{https://gitlab.cvh-server.de/pgerwinski/ad}\\
+%       Links auf die Datei klicken, nicht mittig auf den Kommentar.
+%   \end{itemize}
+% 
+% \end{frame}
+
+\nosectionnonumber{Hardwarenahe Programmierung}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \color{gray}
+    \item[\textbf{1}] \textbf{Einführung}
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/hp.git}}}
+    \item[\textbf{2}] \textbf{Einführung in C}
+    \item[\textbf{3}] \textbf{Bibliotheken}
+    \item[\textbf{4}] \textbf{Hardwarenahe Programmierung}
+    \item[\textbf{5}] \textbf{\color{black}Algorithmen}
+      \begin{itemize}
+        \color{medgreen}
+        \item[5.1] Differentialgleichungen
+        \item[5.2] Rekursion
+        \item[5.3] Aufwandsabschätzungen
+      \end{itemize}
+    \item[\textbf{6}] \textbf{Objektorientierte Programmierung}
+    \item[\textbf{7}] \textbf{\color{black}Datenstrukturen}
+      \begin{itemize}
+        \color{medgreen}
+        \item[7.1] Stack und FIFO
+        \item[7.2] Verkettete Listen
+        \item[7.3] Bäume
+      \end{itemize}
+  \end{itemize}
+  \vspace*{-1cm}
+
+\end{frame}
+
+\nosectionnonumber{Algorithmen}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  {\color{medgreen}\textbf{Differentialgleichungen}}
+  \begin{itemize}
+    \item Pendel
+    \item Planetenbahnen
+  \end{itemize}
+
+  {\color{medgreen}\textbf{Rekursion}}
+  \begin{itemize}
+    \item Türme von Hanoi
+  \end{itemize}
+
+  \smallskip
+
+  \textarrow\ \emph{Wie rechnet man das überhaupt aus?}
+
+  \bigskip
+
+  {\color{medgreen}\textbf{Aufwandsabschätzungen}}
+  \begin{itemize}
+    \item Selectionsort
+    \item Bubblesort
+    \item Quicksort
+  \end{itemize}
+
+  \smallskip
+
+  \textarrow\ \emph{Wie rechnet man das möglichst effizient aus?}
+  \begin{itemize}
+    \item[\textbf{?}] möglichst schnell
+    \item[\textbf{?}] mit möglichst wenig Speicherplatzverbrauch
+    \item[\textbf{?}] unter Berücksichtigung gegebener Randbedingungen
+  \end{itemize}
+
+\end{frame}
+
+\nosectionnonumber{Datenstrukturen}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \addvspace{-3pt}
+
+  \begin{visibleenv}<1->
+    \textbf{Structs und Objekte}
+    \begin{itemize}
+      \item zusammengehörige Daten gemeinsam speichern
+    \end{itemize}
+  \end{visibleenv}
+
+  {\color{medgreen}\textbf{Stack und FIFO}}\only<1->{\textbf{ -- Arrays}}
+  \begin{itemize}
+    \item effizientes Anfügen und Entfernen vorne und hinten
+    \item effizienter direkter Zugriff auf Elemente in der Mitte
+    \item ineffizientes Einfügen und Entfernen in der Mitte
+  \end{itemize}
+
+  {\color{medgreen}\textbf{Verkettete Listen}}\only<1->{\textbf{ -- Structs mit Pointern}}
+  \begin{itemize}
+    \item effizientes Einfügen und Entfernen in der Mitte
+    \item ineffizienter direkter Zugriff auf Elemente in der Mitte
+  \end{itemize}
+
+  {\color{medgreen}\textbf{Bäume}}\only<1->{\textbf{ -- Structs mit Pointern}}
+  \begin{itemize}
+    \item Kompromiß
+  \end{itemize}
+
+  \smallskip
+
+  \textarrow\ \emph{Wie speichert man das möglichst effizient?}
+  \begin{itemize}
+    \item[\textbf{?}] möglichst schnell
+    \item[\textbf{?}] mit möglichst wenig Speicherplatzverbrauch
+    \item[\textbf{?}] unter Berücksichtigung gegebener Randbedingungen
+  \end{itemize}
+
+\end{frame}
+
+\nosectionnonumber{Aufwandsabschätzungen \protect\color{gray}-- Komplexitätsanalyse}
+
+\begin{frame}[fragile]
+
+%  \newcommand{\w}{\hspace*{0.75pt}}
+
+  \shownosectionnonumber
+
+  \begin{picture}(0,0)
+    \put(7.6,-0.5){%
+      \begin{minipage}[t]{5.3cm}
+%        \vspace*{-1.0cm}\includegraphics{landau-symbols.pdf}
+        \alt<3->{\vspace*{-0.93cm}\includegraphics{landau-symbols-3.pdf}}%
+                {\vspace*{-1.00cm}\includegraphics{landau-symbols.pdf}}
+        \small%\vspace*{-1.0cm}
+        \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>
+      Türme von Hanoi: $\mathcal{O}(2^n)$
+      \par\medskip
+      Für jede zusätzliche Scheibe\\verdoppelt sich die Rechenzeit!
+      \begin{itemize}
+        \arrowitem
+          $\frac{30,672\,\text{s}\,\cdot\,2^{32}}{3600\,\cdot\,24\,\cdot\,365,25} \approx 4174$
+          Jahre\\[\smallskipamount]
+          für 64 Scheiben
+      \end{itemize}
+
+      \bigskip
+  \end{onlyenv}
+
+  \begin{onlyenv}<1->
+    Faustregel:\\Schachtelung der Schleifen zählen\\
+    $k$ Schleifen ineinander \textarrow\ $\mathcal{O}(n^k)$
+
+    \bigskip
+  \end{onlyenv}
+
+  \begin{onlyenv}<2>
+    \textbf{Beispiel: Sortieralgorithmen}
+
+    \smallskip
+
+    Anzahl der Vergleiche bei $n$ Strings
+    \begin{itemize}
+      \item
+        Maximum suchen mit Schummeln: $\mathcal{O}(1)$
+%      \pause
+      \item
+        Maximum suchen: $\mathcal{O}(n)$
+%      \pause
+      \item
+        Selection-Sort: $\mathcal{O}(n^2)$
+%      \pause
+      \item
+        Bubble-Sort: $\mathcal{O}(n)$ bis $\mathcal{O}(n^2)$
+%      \pause
+      \item
+        Quicksort: $\mathcal{O}(n\log n)$ bis $\mathcal{O}(n^2)$
+    \end{itemize}
+
+  \end{onlyenv}
+
+%   \begin{onlyenv}<3>
+%     \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}<3->
+
+    \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<3->{{\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<3->{{\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<3->{{\color{magenta}$\mathcal{O}\bigl(2^{\sqrt{n\log n}}\bigr)$}}
+    \end{itemize}
+
+    \smallskip
+%    \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}
+
+\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/ad.git}}}
+    \item[\textbf{2}] \textbf{\dots}
+  \end{itemize}
+
+  \begin{picture}(0,0)(-2,-0.5)
+    \put(0.5,-1.0){\mbox{\Large$\mathcal{O}(n\log n)$}}
+    \put(0.6,-2.7){\mbox{\large\bf B-Baum}}
+    \put(-1.3,-3.4){\mbox{\small\it verkettete Liste}}
+    \put(1.5,-4.0){\mbox{\large Datenbanken}}
+    \put(-1.0,-1.9){\mbox{\large\tt struct}}
+    \put(3.0,-2.0){\mbox{\large Wegfindung}}
+    \put(4.0,-3.0){\mbox{Verschlüsseln}}
+    \put(5.7,-4.2){\mbox{\it Datenkompression}}
+    \put(6.0,-1.5){\mbox{CORDIC}}
+    \put(8.5,-2.0){\mbox{\small\bf FFT}}
+    \put(7.5,-2.9){\mbox{\small\tt pointer}}
+    \put(3.5,-0.5){\mbox{\it Rasterung}}
+    \put(7.7,-0.7){\mbox{\tt array}}
+    \put(-0.5,-5.0){\mbox{digitale Signatur}}
+    \put(3.5,-5.2){\mbox{\large Hash-Tabelle}}
+    \put(0.0,-6.3){\mbox{\small\bf kryptographische Hash-Funktion}}
+    \put(6.5,-6.0){\mbox{\it Prüfsumme}}
+%    \pause
+%    \put(4.0,-2.7){\begin{rotate}{18}
+%                     \makebox(0,0){\LARGE\color{red}\shortstack{%
+%                       Online-Werkzeuge für Home Office, Lehre\\
+%                       und Kommunikation mit Unterdrückten}}
+%                   \end{rotate}}
+  \end{picture}
+
+\end{frame}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+      \underconstruction
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/ad.git}}}
+%    \item[\textbf{\color{red}i}] {\color{red}Online-Werkzeuge für Home Office, Lehre\\
+%                                             und Kommunikation mit Unterdrückten}
+    \item[\textbf{2}] \textbf{Datenorganisation}
+    \item[\textbf{3}] \textbf{Optimierung}
+    \item[\textbf{4}] \textbf{Hardwarenahe Algorithmen}
+    \item[\textbf{5}] \textbf{Datenkodierung}
+    \color{gray}
+    \item[\textbf{6}] \textbf{Numerik}
+  \end{itemize}
+
+\end{frame}
+
+\subsectionnonumber{C: Arrays und Zeiger für Fortgeschrittene}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{minipage}[t]{6cm}
+    Array:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char a[] = "Test";
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{6cm}
+    Zeiger:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char *p = "Test";
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      In beiden Fällen wird ein Array von ganzen Zahlen\\
+      (5 \lstinline{char}-Variable mit den Werten 84, 101, 115, 116 und 0)\\
+      im Speicher angelegt.
+    \medskip
+    \item
+      Links heißt das Array \lstinline{a};
+      rechts ist es "`anonym"'.
+    \item
+      Rechts wird zusätzlich ein Zeiger \lstinline{p} im Speicher angelegt,\\
+      der auf das (anonyme) Array zeigt.
+    \medskip
+    \item
+      \lstinline{&a} ist dasselbe wie \lstinline{a},
+      nämlich die Adresse des Arrays.
+    \item
+      \lstinline{&p} ist die Adresse des Zeigers.
+    \item
+      \lstinline{p} ist der Wert des Zeigers,\\
+      momentan also die Adresse des (anonymen) Arrays.
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{minipage}[t]{6cm}
+    Array:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char a[] = "Test";
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{6cm}
+    Zeiger:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char *p = "Test";
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      In beiden Fällen wird ein Array von ganzen Zahlen\\
+      (5 \lstinline{char}-Variable mit den Werten 84, 101, 115, 116 und 0)\\
+      im Speicher angelegt.
+    \medskip
+    \item
+      Links heißt das Array \lstinline{a};
+      rechts ist es "`anonym"'.
+    \item
+      Rechts wird zusätzlich ein Zeiger \lstinline{p} im Speicher angelegt,\\
+      der auf das (anonyme) Array zeigt.
+    \medskip
+    \item
+      \lstinline{&a} ist {\color{red}fast} dasselbe wie \lstinline{a},\\
+      nämlich die Adresse des Arrays {\color{red}bzw.\ das Array selbst,\\
+      das zuweisungskompatibel zu einem Zeiger auf Elemente des Arrays ist.\\
+      \lstinline{&} bewirkt hier eine (nicht explizite!) Typumwandlung.}
+    \item
+      \lstinline{&p} ist die Adresse des Zeigers.
+    \item
+      \lstinline{p} ist der Wert des Zeigers,\\
+      momentan also die Adresse des (anonymen) Arrays.
+  \end{itemize}
+
+  \vspace*{-1cm}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{minipage}[t]{7cm}
+    Array:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char *a[] = { "Dies", "ist", "ein", "Test" };
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{5cm}
+    Zeiger:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char **p = a;
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      Array von Zeigern auf \lstinline{char}-Variable
+    \item
+      Zeiger auf das Array = Zeiger auf Zeiger auf \lstinline{char}-Variable
+    \item
+      Schleife durch äußeres Array mit \lstinline{p++} möglich
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{minipage}[t]{7cm}
+    Array:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char a[][5] = { "Dies", "ist", "ein", "Test" };
+    \end{lstlisting}
+  \end{minipage}\hfill
+  \begin{minipage}[t]{5cm}
+    Zeiger:
+    \smallskip
+    \begin{lstlisting}[gobble=6]
+      char *p = a[0];
+    \end{lstlisting}
+  \end{minipage}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      zweidimensionales Array von \lstinline{char}-Variablen
+    \item
+      Zeiger auf Array-Komponente\\
+      = Zeiger auf eindimensionales Array\\
+      = Zeiger auf \lstinline{char}-Variable
+    \item
+      Schleife durch äußeres Array mit Zeiger-Arithmetik nicht möglich
+  \end{itemize}
+
+  \begin{picture}(0,0)
+    \color{red}
+    \thicklines
+    \put(8.6,0.63){\line(1,0){0.85}}
+    \put(9.05,0.4){\makebox(0,0)[t]{$\overbrace{\mbox{nur mit Trick:
+                   \lstinline{p += 5}}}$}}
+  \end{picture}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{lstlisting}
+    typedef char string5[5];
+    string5 a[] = { "Dies", "ist", "ein", "Test" };
+    string5 *p = a;
+  \end{lstlisting}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      Array von Array von \lstinline{char}-Variablen\\
+      = zweidimensionales Array von \lstinline{char}-Variablen
+    \item
+      Zeiger auf zweidimensionales Array
+    \item
+      Schleife durch äußeres Array mit \lstinline{p++} möglich
+    \bigskip
+    \arrowitem
+      Fazit:\\
+      Ein Hoch auf \lstinline{typedef}!
+    \arrowitem
+      Trotzdem: {\color{red}Vorsicht!}\\
+      Ein \lstinline{p++} auf einen Zeiger vom Typ \lstinline{string5 *p}\\
+      ergibt anscheinend undefiniertes Verhalten!
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsectionnonumber
+
+  \begin{lstlisting}
+    typedef char string5[5];
+    string5 *p = { "Dies", "ist", "ein", "Test" };
+  \end{lstlisting}
+
+  \bigskip
+
+  \begin{itemize}
+    \item
+      anonymes Array von Array von \lstinline{char}-Variablen\\
+      = anonymes zweidimensionales Array von \lstinline{char}-Variablen
+    \item
+      Zeiger auf zweidimensionales Array
+    \item
+      Schleife durch äußeres Array mit \lstinline{p++} möglich
+  \end{itemize}
+
+%  \pause
+
+  \begin{picture}(0,0)(-2,-0.4)
+    \color{red}
+    \thicklines
+    \put(0,0){\line(2,1){4}}
+    \put(0,2){\line(2,-1){4}}
+  \end{picture}
+
+  Das Konstrukt \lstinline|{ "Dies", "ist", "ein", "Test" }|\\
+  steht für ein Array von 4 Zeigern auf \lstinline{char}-Variable.
+
+  \smallskip
+
+  \lstinline{string5 *p} hingegen erwartet einen Zeiger auf ein Array
+  von 5 \lstinline{char}-Variablen.
+
+  \smallskip
+
+  Es bekommt die Adresse von \lstinline{"Dies"} zugewiesen.
+
+  \smallskip
+
+  Durch das Erhöhen von \lstinline{p} (um 5) zeigt es danach
+  \emph{zufällig\/} auf das \lstinline{"ist"}.
+
+  Bei nochmaligem Erhöhen zeigt es auf das \lstinline{"in"} von \lstinline{"ein"}.
+
+  \smallskip
+
+  (Auch ohne Optimierung werden die Strings \lstinline{"ist"}, \lstinline{"ein"}
+  und \lstinline{"Test"}\\
+  u.\,U.\ wegoptimiert.)
+
+\end{frame}
+
+\nosectionnonumber{\large\bf Übungsaufgabe: Verkettete Listen}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{enumerate}[\quad(a)]
+    \item
+      Schreiben Sie eine Funktion, die eine verkettete Liste\\
+      in die umgekehrte Reihenfolge bringt.
+    \item
+      Schreiben Sie eine Funktion, die eine verkettete Liste\\
+      in eine doppelt verkettete Liste umwandelt.
+    \item
+      Wieviel Rechenzeit (Landau-Symbol) benötigen Ihre Funktionen?
+    \item
+      Wieviel Speicherplatz (Landau-Symbol) benötigen Ihre Funktionen?
+  \end{enumerate}
+
+\end{frame}
+
+\nosectionnonumber{\inserttitle}
+
+\begin{frame}
+
+  \shownosectionnonumber
+
+  \begin{itemize}
+    \item[\textbf{1}] \textbf{Einführung}
+      \underconstruction
+      \hfill\makebox(0,0)[br]{\raisebox{2.25ex}{\url{https://gitlab.cvh-server.de/pgerwinski/ad.git}}}
+%    \item[\textbf{i}] \textbf{Gesellschaftliche Auswirkungen\\
+%                              von Algorithmen und Datenstrukturen}
+    \item[\textbf{2}] \textbf{Datenorganisation}
+    \item[\textbf{3}] \textbf{Optimierung}
+    \item[\textbf{4}] \textbf{Hardwarenahe Algorithmen}
+    \item[\textbf{5}] \textbf{Datenkodierung}
+    \color{gray}
+    \item[\textbf{6}] \textbf{Numerik}
+  \end{itemize}
+
+\end{frame}
+
+\section{Einführung in C++}
+\addtocounter{subsection}{-1}
+\subsection{Was ist C?}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  Etabliertes Profi-Werkzeug
+  \begin{itemize}
+    \item
+      kleinster gemeinsamer Nenner für viele Plattformen\\
+      \begin{picture}(0,1)
+        \color{red}
+        \put(7.2,0.6){\tikz{\draw[-latex](0.0,0.0)--(0.0,0.4);}}
+        \put(7.2,0.5){\makebox(0,0)[t]{\color{black}Hardware und/oder Betriebssystem}}
+      \end{picture}
+    \item
+      Hardware direkt ansprechen und effizient einsetzen
+    \item
+      \dots\ bis hin zu komplexen Software-Projekten
+    \medskip
+    \arrowitem
+      Man kann Computer vollständig beherrschen.
+  \end{itemize}
+
+\end{frame}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{picture}(0,0)
+    \put(5.3,-2.5){\makebox(0,0)[tl]{\begin{minipage}{7cm}
+                     \emph{C makes it easy to shoot yourself in the foot.}
+                     \begin{flushright}
+                       Bjarne Stroustrup, ca.~1986\\
+                       \href{http://www.stroustrup.com/bs_faq.html\#really-say-that}%
+                            {\nolinkurl{http://www.stroustrup.com/bs_faq.html}\\
+                             \nolinkurl{\#really-say-that}}
+                     \end{flushright}
+                   \end{minipage}}}
+  \end{picture}%
+  Etabliertes Profi-Werkzeug
+  \begin{itemize}
+    \item
+      kleinster gemeinsamer Nenner für viele Plattformen
+    \item
+      Hardware direkt ansprechen und effizient einsetzen
+    \item
+      \dots\ bis hin zu komplexen Software-Projekten
+    \item
+      leistungsfähig, aber gefährlich
+  \end{itemize}
+
+  \medskip
+  "`High-Level-Assembler"'
+  \begin{itemize}
+    \item
+      kein "`Fallschirm"'
+    \item
+      kompakte Schreibweise
+  \end{itemize}
+
+  \medskip
+  Unix-Hintergrund
+  \begin{itemize}
+    \item
+      Baukastenprinzip
+    \item
+      konsequente Regeln
+    \item
+      kein "`Fallschirm"'
+  \end{itemize}
+
+\end{frame}
+
+\subsection{Was ist C++?}
+
+\begin{frame}
+
+  \showsection
+  \showsubsection
+
+  \begin{picture}(0,0)
+    \put(6.3,-0.2){\makebox(0,0)[tl]{\begin{minipage}{6cm}
+                     \emph{C++ is a better C.}
+                     \begin{flushright}
+                        Bjarne Stroustrup, Autor von C++\\
+                        \url{http://www.stroustrup.com/C++.html}
+                     \end{flushright}
+                   \end{minipage}}}
+    \put(5.3,-2.5){\makebox(0,0)[tl]{\begin{minipage}{7cm}
+                     \emph{C makes it easy to shoot yourself in the foot;\\
+                     C++ makes it harder, but when you do\\
+                     it blows your whole leg off.}
+                     \begin{flushright}
+                       Bjarne Stroustrup, Autor von C++, ca.~1986\\
+                       \href{http://www.stroustrup.com/bs_faq.html\#really-say-that}%
+                            {\nolinkurl{http://www.stroustrup.com/bs_faq.html}\\
+                             \nolinkurl{\#really-say-that}}
+                     \end{flushright}
+                   \end{minipage}}}
+  \end{picture}%
+  Etabliertes Profi-Werkzeug
+  \begin{itemize}
+    \item
+      kompatibel zu C
+  \end{itemize}
+
+  \medskip
+
+  C++ unterstützt
+  \begin{itemize}
+    \item
+      \newterm{objektorientierte\\
+      Programmierung}
+    \item
+      \newterm{Datenabstraktion}
+    \item
+      \newterm{generische\\
+      Programmierung}
+  \end{itemize}
+
+  \vspace{0cm plus 1 filll}
+
+  \textbf{Motivation:}\\[\smallskipamount]
+  Vermeidung unsicherer Techniken,\\
+  insbesondere von Präprozessor-Konstruktionen und Zeigern,\\
+  unter Beibehaltung der Effizienz
+
+\end{frame}
+
+\subsection{Elementare Neuerungen in C++ gegenüber C}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{itemize}
+    \pause
+    \item
+      Kommentare mit \lstinline{//}
+    \pause
+    \item
+      Konstante:
+%      \begin{onlyenv}<3>
+%        \begin{lstlisting}[gobble=10]
+%          const int answer = 42;
+%        \end{lstlisting}
+%      \end{onlyenv}
+      \begin{lstlisting}[gobble=8]
+        const int n = 5;
+        int prime[n] = { 2, 3, 5, 7, 11 };
+      \end{lstlisting}
+    \pause
+    \item
+      Ab C++11: \lstinline{constexpr}-Funktionen\\
+%      \only<1->{{\color{red}\dots\ anscheinend auch ohne "`constexpr"' \dots}\\}
+      C++11: darf nur aus einem einzigen \lstinline{return}-Statement bestehen\\
+      \textarrow\ \lstinline{?:} statt \lstinline{if}, Rekursion statt Schleife\\
+      C++-14: auch Verzweigungen und Schleifen erlaubt
+    \pause
+    \item
+      leere Parameterliste: \lstinline{void} optional\\
+      in C: ohne \lstinline{void} = Parameterliste wird nicht geprüft
+    \pause
+    \item
+      Operatoren \lstinline{new} und \lstinline{delete}\\
+      als Alternative zu den Funktionen \lstinline{malloc()} und \lstinline{free()}
+  \end{itemize}
+\end{frame}
+
+\subsection{Referenz-Typen}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{lstlisting}
+    void calc_answer (int &answer)
+    {
+      answer = 42;
+    }
+  \end{lstlisting}
+  \medskip
+  \dots\ als Alternative zu \dots
+  \medskip
+  \begin{lstlisting}
+    void calc_answer (int *answer)
+    {
+      *answer = 42;
+    }
+  \end{lstlisting}
+  \begin{itemize}
+    \item
+      Zeiger "`verborgen"', übersichtlicher und sicherer
+    \item
+      Es gibt keinen \lstinline{NULL}-Wert.\\
+      \textarrow\ Für verkettete Listen u.\,ä.: Tricks erforderlich
+  \end{itemize}
+\end{frame}
+
+\subsection{Überladbare Operatoren und Funktionen}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{lstlisting}
+    #include <iostream>
+
+    int main ()
+    {
+      std::cout << "Hello, world!" << std::endl;
+      return 0;
+    }
+  \end{lstlisting}
+
+  \pause
+  \bigskip
+
+  Bemerkungen:
+  \begin{itemize}
+    \item
+      Compilieren mit \lstinline[style=cmd]{g++}
+      statt \lstinline[style=cmd]{gcc}:\\
+      C++-Bibliotheken mit einbinden
+    \item
+      Der Operator \lstinline{<<} hat normalerweise keinen Seiteneffekt,
+      hier schon.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{lstlisting}
+    #include <iostream>
+
+    struct vector
+    {
+      double x, y, z;
+    };
+
+    vector operator + (vector u, vector v)
+    {
+      vector w = { u.x + v.x, u.y + v.y, u.z + v.z };
+      return w;
+    }
+  \end{lstlisting}
+
+  \begin{itemize}
+    \item
+      \lstinline{++} wird zum Präfix-Operator.
+    \item
+      \lstinline{++} mit zusätzlichem (ungenutzten) \lstinline{int}-Parameter\\
+      wird zum Postfix-Operator.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{lstlisting}
+    void print (const char *s)
+    {
+      printf ("%s", s);
+    }
+
+    void print (int i)
+    {
+      printf ("%d", i);
+    }
+  \end{lstlisting}
+  \pause
+  \bigskip
+  Optionale Parameter:
+  \medskip
+  \begin{lstlisting}
+    void print (const char *s = "\n")
+    {
+      printf ("%s", s);
+    }
+  \end{lstlisting}
+  \pause
+  \begin{picture}(0,0)
+    \color{red}
+    \put(5.50,5.40){\makebox(0,0)[br]{\tikz{\draw[-latex](0.0,0.0)--(-2.0,0.6);}}}
+    \put(5.50,4.85){\makebox(0,0)[tr]{\tikz{\draw[-latex](0.0,0.0)--(-2.0,-0.2);}}}
+    \put(5.6,5.0){\begin{minipage}{5cm}
+        Für den Linker:\\
+        veränderte, eindeutige Namen
+      \end{minipage}}
+    \put(5.50,1.55){\makebox(0,0)[tr]{\tikz{\draw[-latex](0.0,0.0)--(-0.6,0.4);}}}
+    \put(5.6,1.0){\begin{minipage}{5cm}
+        wird vom Compiler erledigt
+      \end{minipage}}
+    \pause
+    \put(7.0,3.6){\makebox(0,0)[b]{\tikz{\draw[-latex](0.0,0.0)--(0.0,0.9);}}}
+    \put(5.6,3.0){\begin{minipage}{5cm}
+        Wenn man das nicht will:\\
+        extern \char`"C\char`"\ \{ \dots \}
+      \end{minipage}}
+  \end{picture}
+\end{frame}
+
+\subsection{Namensräume}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{lstlisting}
+    #include <iostream>
+
+    using namespace std;
+
+    int main ()
+    {
+      cout << "Hello, world!" << endl;
+      return 0;
+    }
+  \end{lstlisting}
+
+  \pause
+  \bigskip
+
+  \begin{lstlisting}
+    namespace my_output
+    {
+      ...
+    }
+
+    using namespace my_output;
+  \end{lstlisting}
+\end{frame}
+
+\subsection{Objekte}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{center}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TBase
+        {
+        };¿
+      \end{lstlisting}
+    \end{minipage}\\[0.5cm]
+    \begin{minipage}{6cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TInteger: public TBase
+        {
+          int content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+    \begin{minipage}{5cm}
+      \begin{lstlisting}[gobble=8]
+        ¡struct TString: public TBase
+        {
+          char *content;
+        };¿
+      \end{lstlisting}
+    \end{minipage}
+  \end{center}
+\end{frame}
+
+\addtocounter{subsection}{-1}
+\subsection{Objekte: Zugriffsrechte}
+
+\begin{frame}[fragile]
+  \showsubsection
+  \begin{itemize}
+    \item
+      \lstinline{public}, \lstinline{private}, \lstinline{protected}\\[\smallskipamount]
+      nicht nur Bürokratie, sondern auch Kapselung\\
+      (Maßnahme gegen "`Namensraumverschmutzung"')
+    \medskip
+    \item
+      \lstinline{struct}: standardmäßig \lstinline{public}\\[\smallskipamount]
+      \lstinline{class}: standardmäßig \lstinline{private}
+    \medskip
+    \item
+      \dots
+  \end{itemize}
+\end{frame}
+
+\end{document}
diff --git a/20230323/landau-symbols-2.pdf b/20230323/landau-symbols-2.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..6b458b6efd8e274824a6dfcaabc4b9c27d196dc4
--- /dev/null
+++ b/20230323/landau-symbols-2.pdf
@@ -0,0 +1 @@
+../common/landau-symbols-2.pdf
\ No newline at end of file
diff --git a/20230323/landau-symbols-3.pdf b/20230323/landau-symbols-3.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..46efa409b35ff5df763c744a423599cba515d886
--- /dev/null
+++ b/20230323/landau-symbols-3.pdf
@@ -0,0 +1 @@
+../common/landau-symbols-3.pdf
\ No newline at end of file
diff --git a/20230323/landau-symbols.pdf b/20230323/landau-symbols.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..ca145425bf07439c680632aa0663f84be601a565
--- /dev/null
+++ b/20230323/landau-symbols.pdf
@@ -0,0 +1 @@
+../common/landau-symbols.pdf
\ No newline at end of file
diff --git a/20230323/logo-hochschule-bochum-cvh-text.pdf b/20230323/logo-hochschule-bochum-cvh-text.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..a05946126bc0ce6a2818740da2893f59eb0c659c
--- /dev/null
+++ b/20230323/logo-hochschule-bochum-cvh-text.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum-cvh-text.pdf
\ No newline at end of file
diff --git a/20230323/logo-hochschule-bochum.pdf b/20230323/logo-hochschule-bochum.pdf
new file mode 120000
index 0000000000000000000000000000000000000000..b6b9491e370e499c9276918182cdb82cb311bcd1
--- /dev/null
+++ b/20230323/logo-hochschule-bochum.pdf
@@ -0,0 +1 @@
+../common/logo-hochschule-bochum.pdf
\ No newline at end of file
diff --git a/20230323/pgslides.sty b/20230323/pgslides.sty
new file mode 120000
index 0000000000000000000000000000000000000000..5be1416f4216f076aa268901f52a15d775e43f64
--- /dev/null
+++ b/20230323/pgslides.sty
@@ -0,0 +1 @@
+../common/pgslides.sty
\ No newline at end of file