Hash Functions - Truncation and Division - c++

Question

So my problem was that I was trying to use a truncation hash function as a collision index increment/decrement... I had to use it as the first main function, and use a more uniform hash function as the second hash function in its place.
My corrected code is below:
// ============================ HASH FUNCTIONS ============================ \\
// Hash function 1 (Base-26)
int Hash_1(char *key2)
{
int index;
index = (int)((key2[0] - 'A' + 1) * pow(26, 3)) + ((key2[1] - 'A' + 1) * pow(26, 2)) + ((key2[2] - 'A' + 1) * 26) + ((key2[3] - 'A' + 1));
return (index % TABLESIZE);
}
// Hash function 2 (Folding)
int Hash_2(char *key2)
{
int index;
index = ((key2[0] - 'A' + 1) * (key2[1] - 'A' + 1)) + ((key2[2] - 'A' + 1) * (key2[3] - 'A' + 1));
return (index % TABLESIZE);
}
// Hash function 3 (Truncation)
int Hash_3(char *key2)
{
int index;
index = ((key2[1] - 'A' + 1) * (key2[2] - 'A' + 1));
return (index % TABLESIZE);
}
// ========================= DOUBLE HASH FUNCTIONS ========================= \\
// Double hash 1 (Linear Probing)
int ProbeDec_1(char *key2)
{
return 1;
}
// Double hash 2 (Middle Squaring)
int ProbeDec_2(char *key2)
{
int index;
index = (int)pow(((key2[1] - 'A' + 1) + (key2[2] - 'A' + 1)), 2);
return (index % TABLESIZE);
}
// Double hash 3 (Division)
int ProbeDec_3(char *key2)
{
int index;
int primeNum = 7;
index = max((key2[3] / primeNum), 1) % primeNum;
return (index % TABLESIZE);
}

Answer 1

You can create a perfect "hash" for 4-letter strings.
There are less than 32 letters in the latin alphabet, there are less than 64 letters in the latin alphabet if you distinguish between upper and lower case letters.
Why mention 32 and 64? Because they are fifth and sixth powers of two.
We can create a 32 bit integer that uniquely represents a 4-letter word (distinguishing between upper and lower letters) as follows:
bits 0 to 5 encode the first letter of the string
bits 6 to 11 encode the second
bits 12 to 17 encode the third
bits 18 to 23 encode the fourth
bits 24 to 31 are set to 0
By encode, I mean something like:
"A" is encoded as 000000
"a" is encoded as 000001
"B" is 000010
"b" is 000011
and so on. We know we can fit all the letters in whatever encoding you want because there are fewer letters than there are available bit arrangements.
You can even encode each letter as key - 'A' + 1, as you seem to prefer.
I would strongly suggest you create a function that takes a character and returns its encoded value. Generally, if you find yourself writing the same piece of code in more than 3 places, you should consider making it a function.
Equally important, since writing hash functions is mostly about bit-fiddling, you should learn how to use the shift operators < and > instead of pow.
You should also learn about integer operations.
What exactly do you thing 1 / (1 - (key2[2] - 'A' + 1)) can possibly return?
None of your functions can be called "hash functions".
If you want to use something like "truncation" or "division" you should first figure out what that means.