用Haskell将数字拆分为数字

Question

给定一个任意数字，我如何分别处理每个数字的数字？

编辑 我已经添加了Foo可能做的那种事情的基本示例。

例如，在C＃中我可能会做这样的事情：

static void Main(string[] args) 
{ 
    int number = 1234567890; 
    string numberAsString = number.ToString(); 

    foreach(char x in numberAsString) 
    { 
     string y = x.ToString(); 
     int z = int.Parse(y); 
     Foo(z); 
    } 
} 

void Foo(int n) 
{ 
    Console.WriteLine(n*n); 
} 

Answer 1

你有没有听说过的div and mod？

如果您想首先处理最重要的数字，您可能需要将数字列表反转。将该数字转换为字符串是一种受损的做事方式。

135 `div` 10 = 13 
135 `mod` 10 = 5 

一般化到一个函数：

digs :: Integral x => x -> [x] 
digs 0 = [] 
digs x = digs (x `div` 10) ++ [x `mod` 10] 

或反向：

digs :: Integral x => x -> [x] 
digs 0 = [] 
digs x = x `mod` 10 : digs (x `div` 10) 

这对待0为没有数字。如果你愿意，简单的包装函数可以处理这种特殊情况。

请注意，此解决方案不适用于负数（输入x必须是整数，即整数）。

Answer 2

使用在您的文章中使用相同的技术，你可以这样做：

digits :: Integer -> [Int] 
digits n = map (\x -> read [x] :: Int) (show n) 

看到它在行动：

Prelude> digits 123 
[1,2,3] 

这是否帮助？

Answer 3

digits :: Integer -> [Int] 
digits = map (read . (:[])) . show 

，或者你可以返回它变成[]：

digits :: Integer -> [Int] 
digits = map (read . return) . show 

，或者与Data.Char.digitToInt：

digits :: Integer -> [Int] 
digits = map digitToInt . show 

一样丹尼尔真的，但毫无意义，并使用诠释，因为一个数字不应该超过maxBound :: Int。

Answer 4

可以使用

digits = map (`mod` 10) . reverse . takeWhile (> 0) . iterate (`div` 10) 

或相反的顺序

rev_digits = map (`mod` 10) . takeWhile (> 0) . iterate (`div` 10) 

的迭代部分产生一个无限列表除以每一步10参数，所以12345变为[12345,1234,123 ，12,1,0,0 ..]。 takeWhile部分仅使用列表中有趣的非空部分。然后我们反转（如果我们想要）并拿出列表中每个数字的最后一位数字。

我在这里使用了无点风格，所以你可以想象在“等式”两边有一个看不见的参数。但是，如果你想要把它写这样一来，你必须$替代顶层.：

digits n = map(`mod` 10) $ reverse $ takeWhile (> 0) $ iterate (`div`10) n 

Answer 5

你也可以只重用Hackage digits。

Answer 6

教科书展开

import qualified Data.List as L 
digits = reverse . L.unfoldr (\x -> if x == 0 then Nothing else Just (mod x 10, div x 10)) 

Answer 7

回访[整数]列表

import Data.Char 
toDigits :: Integer -> [Integer] 
toDigits n = map (\x -> toInteger (digitToInt x)) (show n) 

Answer 8

接受的答案是伟大的，但未能在负数的情况下，因为mod (-1) 10计算结果为9.如果你想这可以正确处理负数......下面的代码可能不适用于此情况。

digs :: Int -> [Int] 
digs 0 = [] 
digs x 
    | x < 0 = digs ((-1) * x) 
    | x > 0 = digs (div x 10) ++ [mod x 10] 

Answer 9

通过列表理解：

import Data.Char 

digits :: Integer -> [Integer] 
digits n = [toInteger (digitToInt x) | x <- show n] 

输出：

> digits 1234567890 
[1,2,3,4,5,6,7,8,9,0] 

Answer 10

下面是关于上述答案的改善。这避免了开始处的额外0（例如：[0,1,0]为10，[0,1]为1）。使用模式匹配来处理案件，其中x < 10不同：

toDigits :: Integer -> [Integer] -- 12 -> [1,2], 0 -> [0], 10 -> [1,0] 
toDigits x 
    | x < 10 = [x] 
    | otherwise = toDigits (div x 10) ++ [mod x 10] 

我会到这个问题的答案的答复都提出这一点，但我没有必要的声誉分:(

Answer 11

digits = reverse . unfoldr go 
    where go = uncurry (*>) . (&&&) (guard . (>0)) (Just . swap . (`quotRem` 10)) 

Answer 12

我试着用尾递归

toDigits :: Integer -> [Integer] 
toDigits x = reverse $ toDigitsRev x 

toDigitsRev :: Integer -> [Integer] 
toDigitsRev x 
    | x <= 0 = [] 
    | otherwise = x `rem` 10 : toDigitsRev (x `quot` 10) 

Answer 13

接受的答案是不同的，它会在输入为0时输出空列表正确的保持，但是我相信输出应该是当输入为零时为。

而我认为它不处理输入为负数的情况。以下是我的实现，它解决了上述两个问题。

toDigits :: Integer -> [Integer] 
toDigits n 
| n >=0 && n < 10 = [n] 
| n >= 10 = toDigits (n`div`10) ++ [n`mod`10] 
| otherwise = error "make sure your input is greater than 0"