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