From 76b93330fe8e4775c82faca58cc13619f88be344 Mon Sep 17 00:00:00 2001
From: Peter Gerwinski <peter.gerwinski@hs-bochum.de>
Date: Thu, 5 May 2022 12:52:14 +0200
Subject: [PATCH] Beispiele 5.5.2022: Hash-Map mit Cantor-Pairing

---
 20220505/hash-map-cantor-01.c | 61 ++++++++++++++++++++++++++++
 20220505/hash-map-cantor-02.c | 61 ++++++++++++++++++++++++++++
 20220505/hash-map-cantor-03.c | 68 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-04.c | 71 +++++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-05.c | 75 +++++++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-06.c | 71 +++++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-07.c | 73 ++++++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-08.c | 58 +++++++++++++++++++++++++++
 20220505/hash-map-cantor-09.c | 63 +++++++++++++++++++++++++++++
 20220505/hash-map-cantor-10.c | 66 ++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-11.c | 68 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-12.c | 67 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-13.c | 68 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-14.c | 68 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-15.c | 68 +++++++++++++++++++++++++++++++
 20220505/hash-map-cantor-16.c | 68 +++++++++++++++++++++++++++++++
 16 files changed, 1074 insertions(+)
 create mode 100644 20220505/hash-map-cantor-01.c
 create mode 100644 20220505/hash-map-cantor-02.c
 create mode 100644 20220505/hash-map-cantor-03.c
 create mode 100644 20220505/hash-map-cantor-04.c
 create mode 100644 20220505/hash-map-cantor-05.c
 create mode 100644 20220505/hash-map-cantor-06.c
 create mode 100644 20220505/hash-map-cantor-07.c
 create mode 100644 20220505/hash-map-cantor-08.c
 create mode 100644 20220505/hash-map-cantor-09.c
 create mode 100644 20220505/hash-map-cantor-10.c
 create mode 100644 20220505/hash-map-cantor-11.c
 create mode 100644 20220505/hash-map-cantor-12.c
 create mode 100644 20220505/hash-map-cantor-13.c
 create mode 100644 20220505/hash-map-cantor-14.c
 create mode 100644 20220505/hash-map-cantor-15.c
 create mode 100644 20220505/hash-map-cantor-16.c

diff --git a/20220505/hash-map-cantor-01.c b/20220505/hash-map-cantor-01.c
new file mode 100644
index 0000000..923829e
--- /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 0000000..bec75d6
--- /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 0000000..5d3518e
--- /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 0000000..3e5db8a
--- /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 0000000..2e6eb22
--- /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 0000000..3bbfdfe
--- /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 0000000..03bf3da
--- /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 0000000..0f9582f
--- /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 0000000..162620a
--- /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 0000000..894965c
--- /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 0000000..0c52f2e
--- /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 0000000..b35bb86
--- /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 0000000..a2a79ba
--- /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 0000000..3075caa
--- /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 0000000..09a6332
--- /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 0000000..5bbab24
--- /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;
+}
-- 
GitLab