CareerCup

The input can be combined with the reverse input by summing their ascii values. this string can then be hashed with a standard hash function. in python:

import hashlib

def reversable_hash(s):
    tmp = []
    for i in range(len(s)):
        tmp += [chr((ord(s[i]) + ord(s[len(s) -i -1])) % 255)]
    tmp = ''.join(tmp)
    return hashlib.md5(tmp.encode('utf8')).hexdigest()

yields:

% reversable_hash("banana")
3210b46e29e61d8865edf62e65929b76
% reversable_hash("ananab")
3210b46e29e61d8865edf62e65929b76
% reversable_hash("anaaab")
9009f73b1797b4c5f6851cf4865c5895
% reversable_hash("élève")
7b27c8eb83ab0aaa267352caaf0bea41
% reversable_hash("evèlé")
7b27c8eb83ab0aaa267352caaf0bea41
% reversable_hash("012")
08f8e0260c64418510cefb2b06eee5cd
% reversable_hash("210")
08f8e0260c64418510cefb2b06eee5cd

What if we restrict equality to only the reverse strings?

E.g.

hash("baaann") != hash("banana")

In general, different permutations will have different hashes.
E.g hash("baaann") != hash("banana")

however, there are indeed corner cases such as
hash ("baanna") == hash ("banana")

btw - edited the code to ensure we modulo the sum, not the last term

Create hash using hash(givenString + reverse(givenString)).

Well if we are just looking for same hashes for anagrams, and security is not a priority, then just sort both strings.

Well if security is not a priority and we are just looking at anagrams, just sort both strings.

with +, do you mean string concatination ? That would yield different hash values.

% hashlib.md5("bananaananab".encode('utf8')).hexdigest()
4a7c040bad14e734e3aa0a430c7de397
% hashlib.md5("ananabbanana".encode('utf8')).hexdigest()
5743eb3309a43451ec8a253923437c37

string ReverseHash(string s) {
    string hash_str;
    int first = 0;
    int last = s.length()-1;

    while(first <= last) {
        if(first != last) {
            if(s[first] <= s[last]) {
                hash_str.push_back(s[first]);
                hash_str.push_back(s[last]);
            } else {
                hash_str.push_back(s[last]);
                hash_str.push_back(s[first]);
            }
        } else {
            hash_str.push_back(s[first]);
        }
        first++;
        last--;
    }
    return hash_str;
}

string ReverseHash(string s) {
    string hash_str;
    int first = 0;
    int last = s.length()-1;

    while(first <= last) {
        if(first != last) {
            if(s[first] <= s[last]) {
                hash_str.push_back(s[first]);
                hash_str.push_back(s[last]);
            } else {
                hash_str.push_back(s[last]);
                hash_str.push_back(s[first]);
            }
        } else {
            hash_str.push_back(s[first]);
        }
        first++;
        last--;
    }
    return hash_str;
}

public int hash(String any) {
        int hash = 23;//any intial value
        hash += any.charAt(0);
        for(int i = 1;i<any.length();i++) {
            hash += any.charAt(i)+Math.abs(any.charAt(i) - any.charAt(i-1));
        }

        return hash;
    }

public static int hash(String any) {
        int hash = 23;//any intial value
        hash += any.charAt(0);
        for(int i = 1;i<any.length();i++) {
            hash += any.charAt(i)+Math.abs(any.charAt(i) - any.charAt(i-1));
        }

        return hash;
    }

public static int hash(String any) {
int hash = 23;//any intial value
hash += any.charAt(0);
for(int i = 1;i<any.length();i++) {
hash += any.charAt(i)+Math.abs(any.charAt(i) - any.charAt(i-1));
}

return hash;
}

{{int reverseHash(string s)
{
string rev = s;
string toHash = "";
reverse(rev.begin(),rev.end());
hash<string> h;
toHash += s < rev ? s+rev : rev+s;
return h(toHash);
}}}

{{int reverseHash(string s)
{
string rev = s;
string toHash = "";
reverse(rev.begin(),rev.end());
hash<string> h;
toHash += s < rev ? s+rev : rev+s;
return h(toHash);
}}}

In Swift,

func Hash(_ string: String) -> String {
    let array = string.map({ $0 })
    let reversedArray = string.reversed().map({ $0 })
    var hashSeed = [UInt32]()
    for (chara1, chara2) in zip(array, reversedArray) {
        let val1 = chara1.unicodeScalars.reduce(0, { (result, scalar) -> UInt32 in
            scalar.value
        })
        let val2 = chara2.unicodeScalars.reduce(0, { (result, scalar) -> UInt32 in
            scalar.value
        })
        hashSeed.append(val1 + val2)
    }
    print("\(string) = \(hashSeed)")

    return hashSeed.reduce("", { $0 + String($1) })
}

Hash("banana") == Hash("ananab")
Hash("banana") == Hash("banaaa")

public static String revHash(String arr) throws NoSuchAlgorithmException {

        StringBuilder stringBuilder = new StringBuilder();
        int N = arr.length();
        for (int i = 0; i < N / 2; i++) {
            int numericValue = (int) (arr.charAt(i));
            numericValue += (int) (arr.charAt(N - i - 1));
            stringBuilder.append((char) numericValue);
        }

        MessageDigest messageDigest = MessageDigest.getInstance("MD5");
        return printHexBinary(messageDigest.digest(stringBuilder.toString().getBytes()));
    }

The Pearson hashing function fails to create a unique key for anagrams. It also is one of the simplest. Pseudo: foreach char c in string, key = key xor c