Haskell Int 列表：[123] 到 [1,2,3]

Question

Problem

i have list of int as [123,123] which i required to be as [1,2,3,1,2,3]

Current Code

i tried out the following code using recursion

fat::[Int]->[Int]
fat [] = []
fat (a,b,c:xs) = a : b : c : fat xs

Conclusions

i have no idea how to acess values as '1', '2, '3 in a list [123,123] separetly

Answer 1

I suggest to use the digs function given in this answer on each element of your list. It splits an Int into a list of digits ( [Int] ). Then you just need to concatenate the resulting lists. This 'map and concatenate results' requirement is a perfect job for concatMap

fat :: [Int] -> [Int]
fat = concatMap digs

This gives:

*Main> fat [123,123]
[1,2,3,1,2,3]

Which is what you want, if I understood correctly.

Answer 2

splitNum :: Int -> [Int]
splitNum n | n <= 9     = [n]
           | otherwise  = (splitNum (n `div` 10)) ++ [n `mod` 10]

fat :: [Int] -> [Int]
fat x = concatMap splitNum x

splitNum is used to convert an Int to a [Int] by splitting it into the division by ten reminders and appending the resulting Int to the splitted rest (recursion!)

Now, having a function that converts numbers into lists, go through input, apply splitNum to any Number in the inner list and concat all resulting lists (list comprehension!)

Answer 3

As a new Haskell programmer I will give you my thoughts of this problem. Just because I think it's good to have many alternatives, especially from different people with different experience.

Here's my take on the problem:

• For each item in the list, convert that item to a char list using read.
• Send that char list into a function which converts each item of that list into an int, then return an list of ints.
• Concat that list of ints into the main list.

To clarify:

• [123, 234]
• 123 turns into ['1', '2', '3']
• ['1', '2', '3'] turns into [1, 2, 3]
• [1, 2, 3] gets concat in the main list
• the cycle repeats for 234.

The util function would look something like this:

import Char

charsToInts :: [Char] -> [Int]
charsToInts [] = []
charsToInts (x:xs) = digitToInt x : charsToInts xs

Coming from a imperative background that's how I would have solved it. Probably slower than just splitting the number mathematically, but I thought it would be interesting to show a alternative.

Answer 4

To pinpoint the problem bluntly, you have no idea how to access the digits separately because you do not understand Haskell types and pattern matching. Let me try to help dispel some of your misconceptions.

Let's look at your list:

[123, 123]

What is its type ? It is clearly a list of ints, or [Int] . With lists, you can pattern match on the constructor : , known to lispers as "cons", or "list constructor". You put a single element on the left side of the : , and another list on the right side. The list on the right side can be the empty list [] , which basically indicates the end of the list. Haskell provides "syntactic sugar" to make lists easier to write, but [123,456] actually gets desugared into 123:(456:[]) . So when you pattern match (x:y:z) , you can now see that x will be assigned 123 and y will be assigned 456 . z will be the rest of the list after x and y ; in this case only [] is left.

Now then, pattern matching with : works for lists . Int s are not lists, so you can't use : to pattern match on the digits of an Int . However, String s are lists, because String is the same as [Char] . So if you turn your Int into a String then you can pattern match on each character.

map show [123, 123]

map applies a function to all elements of a list. show can take an Int and turn it into a String . So we map show over the list of Int s to get a list of String s.

["123", "123"]

Now let's turn those Strings into lists of Int s. Since String is simply [Char] , we will again make use of map .

map digitToInt "123" -- this requires that you import Data.Char (digitToInt)

This will give us [1,2,3] ; each Char in the list is turned into an Int . This is what we want to do to each String in our list ["123", "123"] . We want to map digitToInt to each String. But we have a list of String s. So what do we do? We map it!

map (map digitToInt) ["123", "123"]

This will give us [[1,2,3], [1,2,3]] . Almost what we wanted. Now we just have to flatten the list of list of Int s ( [[Int]] ) into just a list of Int ( [Int] ). How can we do that? Stop...Hoogle time! Hoogling [[a]] -> [a] we find the very first hit, concat , is exactly what we wanted.

Let's put it all together. First we do map show to get from [Int] to [String] . Then we do map (map digitToInt) to get from [String] to [[Int]] . Then we do concat to get from [[Int]] to [Int] . Then we'll just print it out!

import Data.Char (digitToInt)
main = print $ concat $ map (map digitToInt) $ map show $ [123, 123]

Now let's pull most of that out into a function fat

import Data.Char (digitToInt)
main = print $ fat [123, 123]
fat :: [Int] -> [Int]
fat xs = concat $ map (map digitToInt) $ map show $ xs

From here you could make it prettier in a few different ways. concat $ map is the same as concatMap , and since we map both (map digitToInt) and show in sequence, we can merge those. Also making it pointfree, we can end up with quite a terse definition:

fat = concatMap (map digitToInt . show)

Answer 5

For the sake of completeness, I wrote it as suggested by @Ancide

Implementation

fat' :: [Int] -> [Int]
fat' l = map (read) [[z] | z <- [x | k <- (map (show) l), x <- k]]         

Explanation :

{- last result -} stands for the result of the last code explained.

map (show) l

This takes every element inside l and converts it to [String] .

[x | k <- {- last result -}, x <- k]

While k goes through all elements inside the last result , x enumerates all character in each k . All those are added to a list. Now you have a String , respectively a [Char] with all digits next to each others.

[[z] | z <- {- last result -}]

This part takes each Char from the String and puts it into an empty String . Notice the [z] part! This make a list around z , which is (see above) the same as String . Now you have a list of String with a String for each digit.

map (read) {- last result -}

This takes every item in the last result and converts it back to Int and joins them to [Int] . Now you have a list of type [Int] of the wanted result.

Resumé

Although this implementation is possible, it's neither fast, due to all the type conversions, nor readable.

Answer 6

Playing around with the list monad I came up with this. Pretty much the same @Ankur's solution, except using the list monad:

fat :: [Int] -> [Int]
fat is = is >>= show >>= return . digitToInt

Answer 7

If you had two numbers, a and b then you could turn them into a single number by doing 10*a + b. The same principles apply for three.

It sounds like one way of doing this would be to splitEvery into lumps of three and then map a function to turn a list of three into a single number.

Does that help?

Answer 8

You need a function to convert Integer to string... which is obviously Show function Another function to convert a Char to Integer which is "digitToInt" in module Char

And here we go:

fat::[Int]->[Int]
fat [] = []
fat ls = concat $ map (map digitToInt) (map show ls)

Please let me know if it works:)