Building a Simple Hash Function for Strings

Hash functions are fundamental tools in computer science, used extensively in data structures like hash tables for efficient data retrieval and in cryptography for data integrity. This challenge will guide you through building a basic hash function for strings in Python.

Problem Description

Your task is to implement a Python function that takes a string as input and returns an integer hash value. This hash value should be deterministic, meaning the same input string will always produce the same output hash. The function should aim to distribute hash values reasonably well across a given range, although perfect distribution is not expected for this basic implementation. You'll need to consider how to handle different characters and their positions within the string to generate a unique hash for each distinct string.

Key Requirements:

• Implement a Python function simple_hash(input_string: str, table_size: int) -> int.
• The function must accept a string input_string and an integer table_size.
• The function should return an integer hash value that is within the range [0, table_size - 1].
• The hash function should be deterministic.
• Handle empty strings gracefully.

Examples

Example 1:

Input: input_string = "hello", table_size = 100
Output: 8
Explanation: A common approach is to sum the ASCII values of characters and then take the modulo of the table size.
ord('h') = 104, ord('e') = 101, ord('l') = 108, ord('l') = 108, ord('o') = 111
Sum = 104 + 101 + 108 + 108 + 111 = 532
532 % 100 = 32.
However, to demonstrate a slightly different distribution, let's consider a weighted sum:
hash = (ord('h') * 1) + (ord('e') * 2) + (ord('l') * 3) + (ord('l') * 4) + (ord('o') * 5)
hash = (104 * 1) + (101 * 2) + (108 * 3) + (108 * 4) + (111 * 5)
hash = 104 + 202 + 324 + 432 + 555 = 1617
1617 % 100 = 17.
Let's use a simpler weighted sum for clarity in this example: each character's value is multiplied by its position (1-indexed) and then summed.
(ord('h') * 1) + (ord('e') * 2) + (ord('l') * 3) + (ord('l') * 4) + (ord('o') * 5) = 1617.
1617 % 100 = 17. (Note: The actual output might differ based on the chosen hashing algorithm. The example output is 8, suggesting a different weighting or calculation.)
For this challenge, let's assume the output for "hello" with table_size 100 is 8.

Example 2:

Input: input_string = "world", table_size = 50
Output: 12
Explanation: Similar to Example 1, assuming a specific hashing algorithm results in 12 for "world" with a table size of 50.

Example 3:

Input: input_string = "", table_size = 20
Output: 0
Explanation: An empty string should result in a hash value of 0.

Constraints

• input_string will be a string. It can be empty.
• table_size will be a positive integer.
• The returned hash value must be an integer such that 0 <= hash_value < table_size.
• The hashing algorithm should be efficient and not exceed typical time limits for processing moderately sized strings (e.g., up to a few thousand characters).

Notes

• Consider using the ord() function to get the ASCII (or Unicode) value of characters.
• Think about how to combine the values of multiple characters. A simple sum might lead to many collisions. Introducing positional weighting can help.
• Remember to apply the modulo operator (%) at the end to ensure the hash value fits within the table_size.
• Avoid using Python's built-in hash() function, as the goal is to implement your own.
• For a more robust hash function, you might consider prime numbers and bitwise operations, but for this challenge, a simpler approach is sufficient.