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

【问题标题】：Haskell: recursively convert hex string to integer?Haskell：递归地将十六进制字符串转换为整数？
【发布时间】：2013-02-02 11:28:57
【问题描述】：

对于我的家庭作业，我需要使用递归函数（使用尽可能多的辅助方法）将十六进制字符串转换为以 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

但是，这不会产生正确的结果。有谁知道这样做的正确方法吗？

【问题讨论】：

提示：尝试使用输入“10”的函数并使用（错误的）结果，尝试找出错误所在。
我差了一个字符。现在乘以 16，函数 100% 工作:)
顺便说一句，你不需要那么多括号，这应该可以正常工作：| length hxStr /= 0 = hexChar (last hxStr) + 16*parseHex (init hxStr)
尝试使用not (null hxStr) 而不是length hxStr /= 0。这更好，因为它只是检查hxStr 中是否有任何元素。 Haskell 字符串被实现为链表，所以length hxStr 花费的时间与hxStr 的长度成正比。相比之下，not (null hxStr) 需要恒定的时间来计算。

标签： haskell recursion hex type-conversion

【解决方案1】：

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

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

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

【讨论】：

【解决方案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))

很遗憾，您无法立即对hStr 进行模式匹配，因为您需要init 和last 而不是head 和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?

【讨论】：

【解决方案3】：

问题解决后，这里写一个更简洁的方式：

import Data.List
import Data.Maybe

hexChar ch = fromMaybe (error $ "illegal char " ++ [ch]) $ 
    elemIndex ch "0123456789ABCDEF"

parseHex hex = foldl' f 0 hex where
    f n c = 16*n + hexChar c

【讨论】：

好吧，我的意思是，如果你要允许库函数，为什么不去straight to readHex？
当然是为了学习。如果禁止导入，您可以使用foldl 编写parseHex（具有众所周知的缺点），并保留原来的hexChar 实现。