2日目。1日目のほうが難しかった印象。
foldlや、遅延評価など。
あらためて見るとfoldlもfoldrもつかってないな。1問くらい利用すればよかった。この中でいうと、きっとQ3で使うべきだったんだろう。

Q1. Write a sort that takes a list and returns a sorted list.

qsort :: [Integer] -> [Integer]
qsort [] = []
qsort (x:xs) = (qsort smaller) ++ [x] ++ (qsort bigger)
               where
                 smaller = [a| a <- xs ,a <= x]
                 bigger = [b| b <- xs, b > x]

Q2. Write a sort that takes a list and a function that compares its two arguments and then returns a sorted list.

バブルソートのことかな。
haskellでのバブルソートはめんどいので省略。

Q3. Write a Haskell function to convert a string to a number. The string should be in the form of $2,345,678.99 and can possibly have leading zeros.

toNumber :: [Char] -> Float
toNumber xs = read (parseStr xs) ::Float

parseStr :: String -> String
parseStr [] = []
parseStr (x:xs) | (x == '$' || x == ',') = parseStr xs
                | otherwise = [x] ++ (parseStr xs)

Q4. Write a function that takes an argument x and returns a lazy sequence that has every third number, starting with x. Then, write a function that includes every fifth number, beginning with y. Combine these functions through composition to return every eighth number, beginning with x + y.

every3 x = x:(every3 (x + 3))
every5 x = x:(every5 (x + 5))
every8 x y = [a + b | (a,b) <- (zip (every3 x) (every5 y))]

Q5. Use a partially applied function to define a function that will return half of a number and another that will append \n to the end of any string.

divi x y = y / x
half = divi 2

putsString x y = y ++ x
puts = putsString "\n"

ずいぶんやってなかったんだけど、最近haskell勉強しはじめたので、つづきをやっていく。
英語版なので、問題文の意味をとりちがえてる部分もあるかもしれない。

問題1.How many different ways can you find to write allEven?
ぱっと考えて4つ。がんばればfoldlや、モナドつかってもできそうだけど、気
力なかった。

allEven1 :: [Integer] -> [Integer]
allEven1 [] = []
allEven1 (x:xs) = if even x then x:allEven1 xs else allEven1 xs

allEven2 :: [Integer] -> [Integer]
allEven2 xs = [x| x <- xs, even x]

allEven3 :: [Integer] -> [Integer]
allEven3 xs = foldr (\ y ys -> if even y then (y:ys) else ys ) [] xs

allEven4 :: [Integer] -> [Integer]
allEven4 xs = filter even xs

問題2. Write a function that takes a list and reverses the same list
in reverse.
これは1種類でいいようだけど、いちおう2つ。

reverse1 :: [a] -> [a]
reverse1 [] = []
reverse1 (x:xs) = reverse1 xs ++ [x]

reverse2 :: [a] -> [a]
reverse2 xs = foldl (\ ys y -> y:ys) [] xs

問題3. Write a function that builds two-tuples with all possible combina-tions of two of the colors black, white, blue, yellow, and red. Note that you should include only one of (black, blue) and (blue, black).

makeCombinations :: [String] -> [(String,String)]
makeCombinations xs = [(x,y)| x <- xs, y <- xs, (x < y)]

問題4.Write a list comprehension to build a childhood multiplication table. The table would be a list of three-tuples where the first two are integers from 1-12 and the third is the product of the first two.
ふふ、よゆうだ。

makeTable :: [(Integer,Integer,Integer)]
makeTable = [(a,b,a*b)| a <- [1..12], b <- [1..12], (a < b)]

問題5.Solve the map-coloring problem (Section 4.2, Map Coloring, on page 101) using Haskell.
えっ、むずかしいんすけど。1日目でこのレベルか。
ずいぶん冗長な表現になったので、もっといい解答あればおしえてください。

bannedCombination = [("Mississippi", "Tennessee"),
                    ("Mississippi", "Alabama"),
                    ("Alabama", "Tennessee"),
                    ("Alabama", "Mississippi"),
                    ("Alabama", "Georgia"),
                    ("Alabama", "Florida"),
                    ("Georgia", "Florida"),
                    ("Georgia", "Tennessee")]
mapNames = ["Tennessee","Florida","Mississippi","Georgia","Alabama"]
colorNames = ["red","blue","green"]

-- 地名の数まで、[色,色...]の組み合わせをつくる。
colorList = rcomb colorNames (length mapNames)

rcomb :: [String] -> Int -> [[String]]
rcomb [] _ = []
rcomb xs 0 = [[]]
rcomb xs 1 = [[x] | x <- xs]
rcomb xxs@(x:xs) n = map (x:) (rcomb xxs (n-1)) ++ rcomb xs n

-- zipをつかって、[(地名,色)] の組み合わせをつくる。
mapColoringCombination :: [String] -> [[String]] -> [[(String,String)]]
mapColoringCombination map colors = [zip map c|c<- colors]
allMapColoringCombinations = mapColoringCombination mapNames colorList

-- 上でつくった組み合わせをふるいにかける。
allowCombination :: [(String,String)] -> [[(String,String)]] -> [[(String,String)]]
allowCombination xs ys = [y|y<-ys,scan xs y]

findValue :: Eq a => a -> [(a,b)] -> [b]
findValue key list = [value|(key',value) <- list,key == key']

scan :: [(String,String)] -> [(String,String)] -> Bool
scan [] ys = True
scan ((a,b):xs) ys | (findValue a ys) == (findValue b ys) = False
                   | otherwise = scan xs ys

allows = allowCombination bannedCombination allMapColoringCombinations