尝试检查在haskell中划分原始数字的数字

Question

Haskell Code Problem Description: Code is supposed to return how many digits in the number divide the number as a whole. For example, 12 has two digits [1, 2], both of which divide 2 (12%2 and 12%1 are both 0) so 2 is returned as there are two digits that divide the number. For 102, 2 is returned as 1 and 2 both divide 102, division by 0 is undefined.

However, with this code I get errors with numbers containing 0s in the middle of the number (eg 1001020) I get "Program Error: Prelude.read: no parse"

Any help will be greatly appreciated. Many thanks.

import Control.Monad
import Data.Array
import Data.Bits
import Data.Char
import Data.List
import Data.Set
import Debug.Trace
import System.Environment
import System.IO
import System.IO.Unsafe

findDigits :: Int -> Int
findDigits n = digits n n 0 (lengths n)
    where
        digits n on count endCheck
            | endCheck == 0 = count
            | header n == 0 = digits (tailer n) on count (endCheck-1)
            | on `mod` header n == 0 = digits (tailer n) on (count+1) (endCheck-1)
            | otherwise = digits (tailer n) on count (endCheck-1)

header :: Int -> Int
header x = digitToInt . head . show $ x

tailer :: Int -> Int
tailer x = read . tail . show $ x

lengths :: Int -> Int
lengths x = length . show $ x

Answer 1

I think you are trying to do too much in a function. Uually it is better to work with small functions that each solve a simple task, and then combine these in functions that are small as well, and perform a (slightly) more sophisticated task.

For example we can make a function digits :: Int -> [Int] that returns a list of digits:

digits :: Int -> [Int]
digits x | x >= 10 = r : digits q
         | otherwise = [x]
    where (q,r) = quotRem x 10

For example:

Prelude> digits 102
[2,0,1]

We can then filter these digits to check that the digits are not zero (since then it is not dividable), and that the number is dividable by that digit:

dividableDigits :: Int -> [Int]
dividableDigits n = filter (\x -> x /= 0 && mod n x == 0) (digits n)

Now it is a matter of counting the numbers that match. I leave that as an exercise.