解释Vat数递归函数不能正确工作的原因

Question

我试图使一个函数，如果收到的数字是一个有效的增值税号码，返回true，否则False。

为了使数字有效，算法是：

设s为第8位数字乘以2，第7位数字乘以3，第6位数字乘以4，第5位数字乘以5，第4位数字乘以6，第3位数字乘以7，第2位数字乘以8，第1位数字乘以9的乘积之和。设r为s除以11的整数的余数。否则，最后一位数字必须从r中减去11

所以我做了这个函数：

verify :: Int -> Bool
verify x
    | r (s (x`div`10) 2 0) == 0 && x `mod` 10 == 0 = True
    | r (s (x`div`10) 2 0) == 1 && x `mod` 10 == 0 = True
    | x `mod` 10 == (s (x`div`10) 2 0) - 11 = True
    | otherwise = False

s :: Int -> Int -> Int -> Int
s x y acc
    | x `div`10 == x = (acc + x*y)
    | otherwise = ((x `mod` 10)*y + s (x`div`10) (y+1) acc+((x `mod` 10)*y))

r :: Int -> Int
r x = x `mod` 11

但是当我运行验证502618418它应该返回 True 时，但该函数始终返回 False（对于任何数字）。我不明白为什么？

Answer 1

正如保罗·约翰逊在评论中提到的，当前的第一项任务是从增值税号中获取十进制数字列表。

也许将计算数字的逻辑与计算 r 和 s 的逻辑交织在一起不是一个好主意。生成的代码可能难以调试。

让我们尝试使用ghci解释器以交互方式开发代码。

为此，我们可以先作弊一点，只需对整数使用 Show 实例即可。

$ ghci
 GHCi, version 8.8.4: https://www.haskell.org/ghc/  :? for help
 λ> 
 λ> vat1 = 502618411
 λ> 
 λ> vat1
 502618411
 λ> 
 λ> show vat1
"502618411"
 λ> 

但是在Haskell中，< code>String只是< code>Char的列表，所以这与:< code>['5 '，' 0 '，' 2 '，' 6 '，' 1 '，' 8 '，' 4 '，' 1']是一回事。

 λ> 
 λ> show vat1 == ['5', '0', '2', '6', '1', '8', '4', '1', '1']
 True
 λ> 

我们可以使用 Data.Char 模块中的 ord 函数从字符中获取数字 ASCII 代码：

 λ> 
 λ> import qualified Data.Char as Ch
 λ> :type Ch.ord
 Ch.ord :: Char -> Int
 λ> 
 λ> map Ch.ord (show vat1)
 [53,48,50,54,49,56,52,49,49]
 λ> 

由于从0到9的数字连续出现在ASCII序列中(从48开始)，我们通过减去字符“0”的代码得到这些数字:

 λ> 
 λ> map  (\c -> (Ch.ord c) - (Ch.ord '0'))  (show vat1)
 [5,0,2,6,1,8,4,1,1]
 λ> 

所以我们有了数字列表。让我们定义函数：

 λ> 
 λ> getDigits vat = map  (\ch -> (Ch.ord ch) - (Ch.ord '0'))  (show vat)
 λ>
 λ> getDigits vat1
 [5,0,2,6,1,8,4,1,1]
 λ> 

但是如果我们不想使用Show实例呢？

然后我们可以使用纯数值递归函数。让我们将已经生成的数字列表，例如＜code＞dgs＜/code＞，作为累加器。在ghci中使用多行工具：

 λ> 
 λ> :{
|λ>  getDigitsR dgs n = let  (q,r) = (divMod n 10)
|λ>                     in   if (q==0) then (r : dgs)
|λ>                                    else getDigitsR (r : dgs) q
|λ> 
|λ>  :}
 λ> 

测试：

 λ> 
 λ> getDigitsR [9,9,9] vat1
 [5,0,2,6,1,8,4,1,1,9,9,9]
 λ> 
 λ> getDigitsR [] vat1
 [5,0,2,6,1,8,4,1,1]
 λ> 

因此，我们可以编写getDigits的替代定义：

 λ> 
 λ> getDigits vat = getDigitsR [] vat
 λ> 

根据规范，一个数字的权重从9开始，每一步递减1。重量低于2时，求和停止。这导致根据vat号的数字计算< code>s的递归定义如下:

 λ> 
 λ> :{
|λ> getSr w [] = 0
|λ> getSr w (dg:dgs) = if (w < 2) then  0  else  (w*dg + getSr (w-1) dgs)
|λ> :}
 λ>
 λ> 
 λ> digits1
 [5,0,2,6,1,8,4,1,1]
 λ> 
 λ> getSr 9 digits1
 146
 λ> 

这导致了计算s的这个简单函数：

 λ> 
 λ> getS vat = getSr 9 (getDigits vat)
 λ> 

但是如果使用库的风格是首选呢？

人们普遍认为，随着Haskell程序员获得更多的经验，他们倾向于使用更少的直接手动递归，而更多的是内部递归库函数。

如果我们想在这里这样做，我们需要用数字压缩权重：

 λ> 
 λ> ws = [9,8,7,6,5,4,3,2]
 λ> digits = getDigits vat1
 λ> 
 λ> zip ws digits
 [(9,5),(8,0),(7,2),(6,6),(5,1),(4,8),(3,4),(2,1)]
 λ> 

在这一点上，我们可以做乘法并求和它们的结果：

 λ> 
 λ> map (\(w,d) -> w*d) (zip ws digits)
 [45,0,14,36,5,32,12,2]
 λ> 
 λ> sum $ map (\(w,d) -> w*d) (zip ws digits)
 146
 λ> 

库函数zipwith使简化成为可能：

 λ> 
 λ> sum $ zipWith (*) ws digits
 146
 λ> 

因此，我们可以编写< code>getS函数的替代版本:

 λ> 
 λ> :{
|λ> getS vat = let  ws     = [9,8,7,6,5,4,3,2] 
|λ>                 digits = getDigits vat
|λ>            in   sum $ zipWith (*) ws digits
|λ> :}
 λ> 
 λ> getS vat1
 146
 λ> 

注意，这种样式使处理任意权重变得更容易。

因此，我们的工作基本上已经完成:

 λ> 
 λ> vat1
 502618411
 λ> getS vat1
 146
 λ> r = mod 146 11
 λ> r
 3
 λ> 

通过选择样式和提供类型签名，将代码变成最终形状，这是留给读者的练习。