diff --git a/20220505/hash-map-cantor-01.c b/20220505/hash-map-cantor-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..923829ee9840248cdd0f1dacdcdc3ac8b40acd5a
--- /dev/null
+++ b/20220505/hash-map-cantor-01.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <string.h>
+
+int n[65536];  /* zunächst: alle 0 */
+const char *check[65536];  /* zunächst: alle NULL */
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = 0.5*(name[0]+name[1])*(name[0]+name[1]+1)+name[2];
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = 0.5*(name[0]+name[1])*(name[0]+name[1]+1)+name[2];
+
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-02.c b/20220505/hash-map-cantor-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..bec75d681582ba633c4e6735ee5c7aca422a6c38
--- /dev/null
+++ b/20220505/hash-map-cantor-02.c
@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <string.h>
+
+int n[65536];  /* zunächst: alle 0 */
+const char *check[65536];  /* zunächst: alle NULL */
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = (name[0]+name[1])/2*(name[0]+name[1]+1)+name[2];
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = (name[0]+name[1])/2*(name[0]+name[1]+1)+name[2];
+
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-03.c b/20220505/hash-map-cantor-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d3518e93d20454f663f246c5034fc66736a7bce
--- /dev/null
+++ b/20220505/hash-map-cantor-03.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+
+constexpr int hash (const char *name)
+{
+  return (name[0]+name[1])/2*(name[0]+name[1]+1)+name[2];
+}
+
+const int size = hash ("\xff\xff\xff");
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = hash (name);
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = hash (name);
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  printf ("size = %d\n", size);
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-04.c b/20220505/hash-map-cantor-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e5db8aef4d52c449ac413a0fbe275b7a0efde1b
--- /dev/null
+++ b/20220505/hash-map-cantor-04.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <string.h>
+
+constexpr int hash (const char *name)
+{
+  return (name[0]+name[1])/2*(name[0]+name[1]+1)+name[2];
+}
+
+#define max_str "\xff\xff\xff"
+
+const int size = hash (max_str);
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = hash (name);
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = hash (name);
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  printf ("max_str = %d %d %d\n", max_str[0], max_str[1], max_str[2]);
+  printf ("size = %d\n", size);
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-05.c b/20220505/hash-map-cantor-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..2e6eb2265fc60548851f183539bea8fc77d11071
--- /dev/null
+++ b/20220505/hash-map-cantor-05.c
@@ -0,0 +1,75 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+constexpr int hash (const char *name)
+{
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return (n0+n1)/2*(n0+n1+1)+n2;
+}
+
+#define max_str "\xff\xff\xff"
+
+const int size = hash (max_str);
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = hash (name);
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 130559.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = hash (name);
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  printf ("max_str = %d %d %d\n", max_str[0], max_str[1], max_str[2]);
+  printf ("size = %d\n", size);
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-06.c b/20220505/hash-map-cantor-06.c
new file mode 100644
index 0000000000000000000000000000000000000000..3bbfdfe480d46ca0026d8e872280cc5595906da5
--- /dev/null
+++ b/20220505/hash-map-cantor-06.c
@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis size -  1.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = hash (name);
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)  // nicht mehr geschummelt, O(1), nicht mehr
+{                                  // Speicher-ineffizient, aber: Kollisionen!
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis size -  1.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = hash (name);
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  printf ("%d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-07.c b/20220505/hash-map-cantor-07.c
new file mode 100644
index 0000000000000000000000000000000000000000..03bf3dad336eaeb1a827ebfe5383b239aa57fed6
--- /dev/null
+++ b/20220505/hash-map-cantor-07.c
@@ -0,0 +1,73 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis size -  1.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+  // mehrfach Kombination möglich z+e und v+i
+  //int idx = name[0]+name[1];
+
+  // Cantor pairing function
+  int idx = hash (name);
+
+  check[idx] = name;
+  n[idx] = value;  
+
+}
+
+int get_number (const char *name)
+{
+  int value = -1;
+  /* Nimm die ersten 3 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis size -  1.
+   * Dort entnimm die Zahl "value".
+   */
+  
+  // Cantor pairing function
+  int idx = hash (name);
+
+  value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int vierundzwanzig = get_number ("vierundzwanzig");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, vierundzwanzig);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-08.c b/20220505/hash-map-cantor-08.c
new file mode 100644
index 0000000000000000000000000000000000000000..0f9582f06b113c87c3e2232dc2499147f1b7e579
--- /dev/null
+++ b/20220505/hash-map-cantor-08.c
@@ -0,0 +1,58 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  check[idx] = name;
+  n[idx] = value;  
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int vierundzwanzig = get_number ("vierundzwanzig");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, vierundzwanzig);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-09.c b/20220505/hash-map-cantor-09.c
new file mode 100644
index 0000000000000000000000000000000000000000..162620a3e909af8820fb92caca1c88a24d48e29f
--- /dev/null
+++ b/20220505/hash-map-cantor-09.c
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx])
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int vierundzwanzig = get_number ("vierundzwanzig");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, vierundzwanzig);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-10.c b/20220505/hash-map-cantor-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..894965cef08a420e2879f020771990e02e0ae0f3
--- /dev/null
+++ b/20220505/hash-map-cantor-10.c
@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int vierundzwanzig = get_number ("vierundzwanzig");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, vierundzwanzig);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-11.c b/20220505/hash-map-cantor-11.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c52f2e3da9d8d05ff79602bd3e28fbcb84864f3
--- /dev/null
+++ b/20220505/hash-map-cantor-11.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  put_number (NULL, 0);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int vierundzwanzig = get_number ("vierundzwanzig");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, vierundzwanzig);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-12.c b/20220505/hash-map-cantor-12.c
new file mode 100644
index 0000000000000000000000000000000000000000..b35bb86c720d9a6534707eaa59004978d0315ba1
--- /dev/null
+++ b/20220505/hash-map-cantor-12.c
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  int x = get_number ("x");
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, x);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-13.c b/20220505/hash-map-cantor-13.c
new file mode 100644
index 0000000000000000000000000000000000000000..a2a79ba409484db06ef45b3df09a2562dac49578
--- /dev/null
+++ b/20220505/hash-map-cantor-13.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  char x_str[2] = "x";
+  int x = get_number (x_str);
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, x);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-14.c b/20220505/hash-map-cantor-14.c
new file mode 100644
index 0000000000000000000000000000000000000000..3075caa659fc4ea480ae2c329a46436ca77897b4
--- /dev/null
+++ b/20220505/hash-map-cantor-14.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (check[idx], strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  char x_str[2] = "x";
+  int x = get_number (x_str);
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, x);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-15.c b/20220505/hash-map-cantor-15.c
new file mode 100644
index 0000000000000000000000000000000000000000..09a6332d823c51cce756509667c8ef9fea3a6707
--- /dev/null
+++ b/20220505/hash-map-cantor-15.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name[0];
+  uint8_t n1 = name[1];
+  uint8_t n2 = name[2];
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  char x_str[2] = "x";
+  int x = get_number (x_str);
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, x);
+  return 0;
+}
diff --git a/20220505/hash-map-cantor-16.c b/20220505/hash-map-cantor-16.c
new file mode 100644
index 0000000000000000000000000000000000000000..5bbab2440717b418ef96fd9521da7ac655e53894
--- /dev/null
+++ b/20220505/hash-map-cantor-16.c
@@ -0,0 +1,68 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+const int size = 1117;
+
+int n[size];  /* zunächst: alle 0 */
+const char *check[size];  /* zunächst: alle NULL */
+
+constexpr int hash (const char *name)
+{
+  // Cantor pairing function
+  uint8_t n0 = name ? name[0] : 0;
+  uint8_t n1 = n0 ? name[1] : 0;
+  uint8_t n2 = n1 ? name[2] : 0;
+  return ((n0+n1)/2*(n0+n1+1)+n2) % size;
+}
+
+void put_number (const char *name, int value)
+{
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) != 0)
+    fprintf (stderr, "occupied: %s = %d\n", name, value);
+  else
+    {
+      check[idx] = name;
+      n[idx] = value;  
+    }
+}
+
+int get_number (const char *name)
+{
+  int value = -1;  // Fehler-Code
+  int idx = hash (name);
+  if (check[idx] && strcmp (check[idx], name) == 0)
+    value = n[idx];
+  else
+    fprintf (stderr, "not found: %s\n", name);
+  return value;
+}
+
+int main (void)
+{
+  put_number ("eins", 1);
+  put_number ("zwei", 2);
+  put_number ("drei", 3);
+  put_number ("vier", 4);
+  put_number ("fünf", 5);
+  put_number ("sechs", 6);
+  put_number ("sieben", 7);
+  put_number ("acht", 8);
+  put_number ("neun", 9);
+  put_number ("zehn", 10);
+  put_number ("vierundzwanzig", 24);
+  put_number ("sieben", 7);
+  put_number ("x", 42);
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  int fuenf = get_number ("fünf");
+  int sechs = get_number ("sechs");
+  int sieben = get_number ("sieben");
+  char x_str[2] = "x";
+  int x = get_number (x_str);
+  printf ("%d %d %d %d %d %d %d %d\n", eins, zwei, drei, vier, fuenf, sechs, sieben, x);
+  return 0;
+}