class SimpleHashSet:

    def __init__(self, size=100):

        self.size = size

        self.buckets = [[] for _ in range(size)]  # A list of buckets, each is a list (to handle collisions)

​

    def hash_function(self, value):

        # Simple hash function: sum of character codes modulo the number of buckets

        return sum(ord(char) for char in value) % self.size

​

    def add(self, value):

        # Add a value if it's not already present

        index = self.hash_function(value)

        bucket = self.buckets[index]

        if value not in bucket:

            bucket.append(value)

​

    def contains(self, value):

        # Check if a value exists in the set

        index = self.hash_function(value)

        bucket = self.buckets[index]

        return value in bucket

​

    def remove(self, value):

        # Remove a value

        index = self.hash_function(value)

        bucket = self.buckets[index]

        if value in bucket:

            bucket.remove(value)

​

    def print_set(self):

        # Print all elements in the hash set

        print("Hash Set Contents:")

        for index, bucket in enumerate(self.buckets):

            print(f"Bucket {index}: {bucket}")

​

# Creating the Hash Set from the simulation

hash_set = SimpleHashSet(size=10)

​

hash_set.add("Charlotte")

hash_set.add("Thomas")

hash_set.add("Jens")

hash_set.add("Peter")

hash_set.add("Lisa")

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

​

#define BUCKET_COUNT 10

#define MAX_STRING_LENGTH 256 // Define a maximum string length

​

typedef struct Node {

    char value[MAX_STRING_LENGTH]; // Use a fixed-size array for values

    struct Node* next;

} Node;

​

typedef struct {

    Node* buckets[BUCKET_COUNT];

} SimpleHashSet;

​

unsigned int hashFunction(const char* value) {

    unsigned int hash = 0;

    while (*value) {

        hash = (hash + *value++) % BUCKET_COUNT;

    }

    return hash;

}

​

void initHashSet(SimpleHashSet* set) {

    for (int i = 0; i < BUCKET_COUNT; i++) {

        set->buckets[i] = NULL;

    }

}

​

int contains(SimpleHashSet *set, const char *value) {

    unsigned int index = hashFunction(value);

    Node *node = set->buckets[index];

    while (node != NULL) {

        if (strcmp(node->value, value) == 0) {

            return 1; // Found

        }

        node = node->next;

    }

    return 0; // Not found

}

​

void removeValue(SimpleHashSet *set, const char *value) {

    unsigned int index = hashFunction(value);

    Node **node = &(set->buckets[index]);

import java.util.ArrayList;

import java.util.List;

​

public class Main {

    public static void main(String[] args) {

        SimpleHashSet hashSet = new SimpleHashSet(10);

​

        hashSet.add("Charlotte");

        hashSet.add("Thomas");

        hashSet.add("Jens");

        hashSet.add("Peter");

        hashSet.add("Lisa");

        hashSet.add("Adele");

        hashSet.add("Michaela");

        hashSet.add("Bob");

​

        hashSet.printSet();

​

        System.out.println("\n'Peter' is in the set: " + hashSet.contains("Peter"));

        System.out.println("Removing 'Peter'");

        hashSet.remove("Peter");

        System.out.println("'Peter' is in the set: " + hashSet.contains("Peter"));

        System.out.println("'Adele' has hash code: " + hashSet.hashFunction("Adele"));

    }

​

    static class SimpleHashSet {

        private final int size;

        private final List<List<String>> buckets;

​

        public SimpleHashSet(int size) {

            this.size = size;

            this.buckets = new ArrayList<>(size);

            for (int i = 0; i < size; i++) {

                buckets.add(new ArrayList<>()); // Use ArrayList for the buckets

            }

        }

​

        private int hashFunction(String value) {

            return value.chars().reduce(0, Integer::sum) % size;

        }

​

        public void add(String value) {