fsharp.fs

open System

let letters = "acdegilmnoprstuw"
let hash : string -> int64 = Seq.fold (fun acc ch -> acc * 37L + int64 (Seq.findIndex ((=) ch) letters)) 7L
let unhash : int64 -> string =
    Seq.unfold (function 
        | n when n <= 7L -> None 
        | n -> let idx = n % 37L |> int
               (letters.[idx], n / 37L) |> Some)
    >> (fun chars -> new String(chars |> Seq.toArray |> Array.rev))

// usage
hash "leepadg"
unhash 910897038977002L

hash_folds.hs

-- Using folds version
import Data.List
import Data.Maybe

letters = "acdegilmnoprstuw"

getIndexOf :: Char -> String -> Int
getIndexOf x xs = fromMaybe (-1) (elemIndex x xs)

hashacc :: Int -> Char -> Int
hashacc acc x = acc * 37 + (getIndexOf x (letters))

hash :: String -> Int
hash s = foldl hashacc 7 s

decrypt :: Int -> (Maybe (Char, Int))
decrypt n
    | n <= 7    = Nothing
    | otherwise = Just(char, n')
    where char = (letters) !! (n `mod` 37)
          n' = n `quot` 37

unhash :: Int -> String
unhash n = reverse $ unfoldr decrypt n

main = do
    print $ hash "leepadg"
    print $ unhash 910897038977002

hash_py.py

LETTERS = "acdegilmnoprstuw"
LETTERSDICT = {x:i for i, x in enumerate(LETTERS)}

def hash(s):
    h = 7
    for c in s:
        h = h * 37 + LETTERSDICT[c]
    return h

def unhash(n):
    s = []
    while n > 7:
        char = LETTERS[n % 37]
        s.append(char)
        n = n // 37
    return "".join(reversed(s))

print hash("leepadg")
print unhash(910897038977002)

hash_recurisve.hs

import Data.List
import Data.Maybe

letters = "acdegilmnoprstuw"

hash' :: String -> Int -> Int
hash' [] h = h
hash' (x:xs) h = let hh = h * 37 + (head $ elemIndices x (letters))
                  in hash' xs hh

hash :: String -> Int
hash xs = hash' xs 7

decrypt :: Int -> String
decrypt n
    | n <= 7    = ""
    | otherwise = decrypt n' ++ [char]
    where n' = n `quot` 37
          char = (letters) !! (n `mod` 37)

main = do
    print $ hash "leepadg"
    print $ decrypt 910897038977002