Beispiele 28.4.2022: Hash-Tabelle

20220428/hash-map-1.c

+#include <stdio.h>
+#include <string.h>
+
+int get_number (const char *name)  /* geschummelt, aber trotzdem schlechter als die */
+{                                  /* richtige Lösung: O(n) statt O(1)              */
+  if (!strcmp (name, "eins"))
+    return 1;
+  else if (!strcmp (name, "zwei"))
+    return 2;
+  else if (!strcmp (name, "drei"))
+    return 3;
+  else
+    return 0;
+}
+
+int main (void)
+{
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  printf ("%d %d %d\n", eins, zwei, drei);
+  return 0;
+}

20220428/hash-map-2.c

+#include <stdio.h>
+#include <string.h>
+
+int get_number (const char *name)  /* geschummelt, aber trotzdem schlechter als die */
+{                                  /* richtige Lösung: O(n) statt O(1)              */
+  static const char *n[] = { "null", "eins", "zwei", "drei", "vier", NULL };
+  for (int i = 0; n[i]; i++)
+    if (!strcmp (name, n[i]))
+      return i;
+  return -1;
+}
+
+int main (void)
+{
+  int eins = get_number ("eins");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  printf ("%d %d %d\n", eins, zwei, drei);
+  return 0;
+}

20220428/hash-map-3.c

+#include <stdio.h>
+#include <string.h>
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber: */
+{                                  /*  - Speicher-ineffizient             */
+  static const int n[26] =         /*  - unvollständig: "sechs", "sieben" */
+    {                              /*  - unzuverlässig: "egon" = "eins"   */
+       8, /* a */
+      -1, /* b */
+      -1, /* c */
+       3, /* d */
+       1, /* e */
+       5, /* f */
+      -1, /* g */
+      -1, /* h */
+      -1, /* i */
+      -1, /* j */
+      -1, /* k */
+      -1, /* l */
+      -1, /* m */
+       0, /* n */
+      -1, /* o */
+      -1, /* p */
+      -1, /* q */
+      -1, /* r */
+       6, /* s */
+      -1, /* t */
+      -1, /* u */
+       4, /* v */
+      -1, /* w */
+      -1, /* x */
+      -1, /* y */
+       2  /* z */
+    };
+  int value = -1;
+  if (name && name[0] >= 'a' && name[0] <= 'z')
+    value = n[name[0] - 'a'];
+  return value;
+}
+
+int main (void)
+{
+  int eins = get_number ("egon");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  printf ("%d %d %d %d\n", eins, zwei, drei, vier);
+  return 0;
+}

20220428/hash-map-4.c

+#include <stdio.h>
+#include <string.h>
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber: */
+{                                  /*  - Speicher-ineffizient             */
+  static const int n[26] =         /*  - unvollständig: "sechs", "sieben" */
+    {                              /* :) zuverlässig: "egon" != "eins"    */
+       8, /* a */
+      -1, /* b */
+      -1, /* c */
+       3, /* d */
+       1, /* e */
+       5, /* f */
+      -1, /* g */
+      -1, /* h */
+      -1, /* i */
+      -1, /* j */
+      -1, /* k */
+      -1, /* l */
+      -1, /* m */
+       0, /* n */
+      -1, /* o */
+      -1, /* p */
+      -1, /* q */
+      -1, /* r */
+       6, /* s */
+      -1, /* t */
+      -1, /* u */
+       4, /* v */
+      -1, /* w */
+      -1, /* x */
+      -1, /* y */
+       2  /* z */
+    };
+  static const char *check[26] =
+    {
+       "acht",
+       NULL, /* b */
+       NULL, /* c */
+       "drei",
+       "eins",
+       "fünf",
+       NULL, /* g */
+       NULL, /* h */
+       NULL, /* i */
+       NULL, /* j */
+       NULL, /* k */
+       NULL, /* l */
+       NULL, /* m */
+       "null",
+       NULL, /* o */
+       NULL, /* p */
+       NULL, /* q */
+       NULL, /* r */
+       "sechs",
+       NULL, /* t */
+       NULL, /* u */
+       "vier",
+       NULL, /* w */
+       NULL, /* x */
+       NULL, /* y */
+       "zwei"
+    };
+  int value = -1;
+  if (name && name[0] >= 'a' && name[0] <= 'z')
+    {
+      int i = name[0] - 'a';
+      if (!strcmp (name, check[i]))
+        value = n[i];
+    }
+  return value;
+}
+
+int main (void)
+{
+  int eins = get_number ("egon");
+  int zwei = get_number ("zwei");
+  int drei = get_number ("drei");
+  int vier = get_number ("vier");
+  printf ("%d %d %d %d\n", eins, zwei, drei, vier);
+  return 0;
+}

20220428/hash-map-5.c

+#include <stdio.h>
+#include <string.h>
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  static const int n[26] =         /* :] vollständig: "sechs" != "sieben", aber unschön */
+    {                              /* :) zuverlässig: "egon" != "eins"                  */
+       8, /* a */
+      -1, /* b */
+      -1, /* c */
+       3, /* d */
+       1, /* e */
+       5, /* f */
+      -1, /* g */
+      -1, /* h */
+      -1, /* i */
+      -1, /* j */
+      -1, /* k */
+      -1, /* l */
+      -1, /* m */
+       0, /* n */
+      -1, /* o */
+      -1, /* p */
+      -1, /* q */
+      -1, /* r */
+       6, /* s */
+      -1, /* t */
+      -1, /* u */
+       4, /* v */
+      -1, /* w */
+      -1, /* x */
+      -1, /* y */
+       2  /* z */
+    };
+  static const char *check[26] =
+    {
+       "acht",
+       NULL, /* b */
+       NULL, /* c */
+       "drei",
+       "eins",
+       "fünf",
+       NULL, /* g */
+       NULL, /* h */
+       NULL, /* i */
+       NULL, /* j */
+       NULL, /* k */
+       NULL, /* l */
+       NULL, /* m */
+       "null",
+       NULL, /* o */
+       NULL, /* p */
+       NULL, /* q */
+       NULL, /* r */
+       "sechs",
+       NULL, /* t */
+       NULL, /* u */
+       "vier",
+       NULL, /* w */
+       NULL, /* x */
+       NULL, /* y */
+       "zwei"
+    };
+  int value = -1;
+  if (name && name[0] >= 'a' && name[0] <= 'z')
+    {
+      if (name[0] == 's' && !strcmp (name, "sieben"))
+        value = 7;
+      else
+        {
+          int i = name[0] - 'a';
+          if (!strcmp (name, check[i]))
+            value = n[i];
+        }
+    }
+  return value;
+}
+
+int main (void)
+{
+  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;
+}

20220428/hash-map-6.c

+#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 2 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 65535.
+   * Dort hinterlege die Zahl "value" im Array.
+   */
+}
+
+int get_number (const char *name)  /* nicht mehr geschummelt, O(1), aber:               */
+{                                  /*  - Speicher-ineffizient                           */
+  int value = -1;
+  /* Nimm die ersten 2 Zeichen des Strings,
+   * berechne daraus einen Array-Index von 0 bis 65535.
+   * Dort entnimm die Zahl "value".
+   */
+  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;
+}