Haskell：递归地将十六进制字符串转换为整数？

Question

对于我的家庭作业，我需要使用递归函数（根据需要使用尽可能多的辅助方法）将十六进制字符串转换为基数为 10 的整数。

这是我到目前为止所得到的：

-- Question 1, part (c):
hexChar :: Char -> Integer
hexChar ch
    | ch == '0' = 0
    | ch == '1' = 1
    | ch == '2' = 2
    | ch == '3' = 3
    | ch == '4' = 4
    | ch == '5' = 5
    | ch == '6' = 6
    | ch == '7' = 7
    | ch == '8' = 8
    | ch == '9' = 9
    | ch == 'A' = 10
    | ch == 'B' = 11
    | ch == 'C' = 12
    | ch == 'D' = 13
    | ch == 'E' = 14
    | ch == 'F' = 15
    | otherwise     = 0

parseHex :: String -> Integer
parseHex hxStr 
    | length hxStr /= 0 = (hexChar(last(hxStr)))+(10*parseHex(init(hxStr)))
    | otherwise         = 0  

但是，这不会产生正确的结果。有谁知道正确的方法来做到这一点？

Answer 1

你真的很亲近。你的错误在这一行：

    | length hxStr /= 0 = (hexChar(last(hxStr)))+(10*parseHex(init(hxStr)))

想想你为什么要乘以 10。记住......十六进制是以 16 为底的。

Answer 2

既然你得到了正确的答案，你应该考虑风格。使用模式匹配，这看起来已经更清楚了：

parseHex :: String -> Integer
parseHex [] = 0
parseHex hxStr = (hexChar(last(hxStr)))+(16*parseHex(init(hxStr)))

而且它也更高效，因为您不需要length hxStr在每次递归调用时进行评估（即 O(N)）来决定适用哪种情况。总运行时间从 O(N**2) 变为 O(N)。

当你删除一些括号时，它看起来会更好，正如 groovy 建议的那样：

parseHex :: String -> Integer
parseHex [] = 0
parseHex hxStr = hexChar (last hxStr) + 16 * parseHex (init hxStr))

不幸的是，您无法hxStr立即进行模式匹配，因为您需要initandlast而不是headand tail。但你可以使用reverse和一个助手来缓解这种情况：

parseHex :: String -> Integer
parseHex hxStr = go (reverse hxStr)
    where go []     = 0
          go (x:xs) = hexChar x + 16 * parseHex xs

不过，最后一个可能只是一个品味问题。hexChar也变得更短：

hexChar '0' = 0
hexChar '1' = 1
...                  -- other cases here
hexChar _ = 0        -- 'otherwise' case; maybe throw an error instead?