Error in installing memoize package

Haskell의 메모화(memoize) 패키지 설치시 다음과 같은 error가 난다.

$ cabal install memoize
Resolving dependencies...
Downloading memoize-0.6...
Configuring memoize-0.6...
Building memoize-0.6...
Preprocessing library memoize-0.6...
Data/Function/Memoize/TH.hs:5:6:
     error: invalid preprocessing directive
        #-}
         ^

#-}를 코드 윗줄로만 옮겨주면 된다. Mac에서만의 문제인 듯 하다.
이는 LLVM의 clang을 기본으로 사용하는 Xcode 때문인 것이라고 한다. 분명 신버전의 Haskell Platform은 clang과 gcc를 모두 지원한다고 하는데... 암튼 에러가 났다.

1. cabal install memoize 하면 ~/Library/Haskell에 memoize 폴더가 생성되어 있을 것임.
2. memoize 폴더로 이동해, memoize-0.6.tar.gz를 해동.
3. TH.hs를 열어 5번째 줄에 있는 #-}를 코드 4번째 줄 맨 뒤로 위치시킴.
4. 저장 & 수정된 파일로 memoize-0.6.tar.gz를 만들어줌.
5. cabal install memoize 실행.

Euler Project: Problem 31

In England the currency is made up of pound, £, and pence, p, and there are eight coins in general circulation:

1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p).

It is possible to make £2 in the following way:

1×£1 + 1×50p + 2×20p + 1×5p + 1×2p + 3×1p

How many different ways can £2 be made using any number of coins?

main = print $ length $ coinSum 200 

coinSum n = [ [oneP, twoP, fiveP, tenP, twentyP, fiftyP, oneL, twoL] |
    oneP    <- [0 .. n],
    twoP    <- [0, 2 .. n - oneP],
    fiveP   <- [0, 5 .. n - (oneP + twoP)],
    tenP    <- [0, 10 .. n - (oneP + twoP + fiveP)],
    twentyP <- [0, 20 .. n - (oneP + twoP + fiveP + tenP)],
    fiftyP  <- [0, 50 .. n - (oneP + twoP + fiveP + tenP + twentyP)],
    oneL    <- [0, 100 .. n - (oneP + twoP + fiveP + tenP + twentyP + fiftyP)],
    twoL    <- [0, 200 .. n - (oneP + twoP + fiveP + tenP + twentyP + fiftyP + oneL)],
    oneP + twoP + fiveP + tenP + twentyP + fiftyP + oneL + twoL == 200] 

*Main> main
73682

Euler Project: Problem 30

Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:

1634 = 1⁴ + 6⁴ + 3⁴ + 4⁴
8208 = 8⁴ + 2⁴ + 0⁴ + 8⁴
9474 = 9⁴ + 4⁴ + 7⁴ + 4⁴

As 1 = 1⁴ is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

import Data.Char 

main :: IO()
main = print $ sum $ map snd $ filter fst resultData 

resultData :: [(Bool, Int)]
resultData = map (\x -> (compareDigit $ show x, x)) inputData 

compareDigit :: String -> Bool
compareDigit s = s == digitPowerSum s 

digitPowerSum :: String -> String
digitPowerSum n = show . sum $ map (\x -> digitToInt x ^5) n 

inputData :: [Int]
inputData = [2..6*9^5] 

*Main> main
443839

Numerical type 사이의 변환 방법

Numerical Type 사이의 전환에 대해서 정리해 보았다.
여기(영어)와 여기(일어)의 정리가 잘 되어 있다.

고졸 수학실력에 알맞게 내가 알고 있는 숫자 형태, 예를 들면 정수, 분수, 소수, 부동소수로 분류하여 각각의 type 변환을 그림으로 정리해 보았다.

undefined 대신에 $notImplemented 또는 ($todo "주절주절")

Haskell code를 만들어갈 때 함수의 type만 작성하고 본체는 undefined로 두는 경우가 자주 있다. 예를 들면,

someFunction :: a -> b
someFunction = undefined

함수 본체 작성을 잊은 경우, 프로그램 실행시에 불친절한 error가 출력된다. compile시에는 문제없이 넘어간다.

shAegis:Haskell shaegis$ ghc myUtil.hs
[1 of 1] Compiling Main             ( myUtil.hs, myUtil.o )
Linking myUtil ...
shaegis$ ./myUtil
myUtil: Prelude.undefined

Development.Placeholders를 이용하면 compile시에도 error를 잡아주며 undefined된 위치까지 알려준다.

{-# LANGUAGE TemplateHaskell #-}
import Development.Placeholders 

someFunction :: a -> b
someFunction = $notImplemented 

Or 

someFunction = $(todo "주말까지 작성.")

compile을 하면 다음과 같이 error를 잡아준다.

shAegis:Haskell shaegis$ ghc myUtil.hs
[1 of 1] Compiling Main             ( myUtil.hs, myUtil.o )
myUtil.hs:24:17: Warning: Unimplemented feature
Linking myUtil ... 

Or 

myUtil.hs:24:19: Warning: TODO: 주말까지 작성.

Euler Project: Problem 29

Consider all integer combinations of a^b for 2  a  5 and 2  b  5:

2²=4, 2³=8, 2⁴=16, 2⁵=32
3²=9, 3³=27, 3⁴=81, 3⁵=243
4²=16, 4³=64, 4⁴=256, 4⁵=1024
5²=25, 5³=125, 5⁴=625, 5⁵=3125

If they are then placed in numerical order, with any repeats removed, we get the following sequence of 15 distinct terms:

4, 8, 9, 16, 25, 27, 32, 64, 81, 125, 243, 256, 625, 1024, 3125

How many distinct terms are in the sequence generated by a^b for 2  a  100 and 2  b  100?

Prelude Data.List> length $ nub $ [a^b | a <- [2..100], b <- [2..100]]
9183

Euler Project: Problem 28

Starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral is formed as follows:

21 22 23 24 25
20  7  8  9 10
19  6  1  2 11
18  5  4  3 12
17 16 15 14 13

It can be verified that the sum of the numbers on the diagonals is 101.

What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed in the same way?

main :: IO()
main = print $ 1 + sumOf2ndTo1001Diag 

sumOf2ndTo1001Diag :: Int
sumOf2ndTo1001Diag = sum $ map sumCurrDiag inputData 

--초항: 예를 들어 3x3은, prev인 1x1 + (3-1).
iniNum :: (Int, Int) -> Int
iniNum (prev, curr) = prev * prev + (curr - 1) 

--3x3에서는 iniNum에서 (3-1)의 등차수열.
sumCurrDiag :: (Int, Int) -> Int
sumCurrDiag (prev, curr) = 2 * ( 2 * iniNum (prev, curr) + 3 * (curr - 1))
--sumCurrDiag (prev, curr) = iniNum (prev, curr) * 4 + (curr - 1) * 6 

inputData :: [(Int, Int)]
inputData = zip baseData (tail baseData) 

baseData :: [Int]
baseData = [1,3..1001] 

*Main> main
669171001

Euler Project: Problem 27

Euler discovered the remarkable quadratic formula:

n² + n + 41

It turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. However, when n = 40, 40² + 40 + 41 = 40(40 + 1) + 41 is divisible by 41, and certainly when n = 41, 41² + 41 + 41 is clearly divisible by 41.

The incredible formula  n²  79n + 1601 was discovered, which produces 80 primes for the consecutive values n = 0 to 79. The product of the coefficients, 79 and 1601, is 126479.

Considering quadratics of the form:

n² + an + b, where |a|  1000 and |b|  1000

where |n| is the modulus/absolute value of n
e.g. |11| = 11 and |4| = 4

Find the product of the coefficients, a and b, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n = 0.

import Data.Numbers.Primes
import Data.List
import Data.Ord 

main :: IO()
main = print $ snd $ maximumBy (comparing fst) quadraticPair 

quadraticPair :: [(Int, Int)]
quadraticPair = [(quadraticLength a b, quadraticProduct a b) | a <- [(-1000)..1000], b <- [(-1000)..1000]] 

quadraticProduct :: Int -> Int -> Int
quadraticProduct a b = a*b 

quadraticLength :: Int -> Int -> Int
quadraticLength a b = length $ takeWhile (== True) $ map (isPrime . (\n -> n^2 + a*n +b)) [0..] 

*Main> main
-59231

Euler Project: Problem 26

A unit fraction contains 1 in the numerator. The decimal representation of the unit fractions with denominators 2 to 10 are given:

1/2	=	0.5
1/3	=	0.(3)
1/4	=	0.25
1/5	=	0.2
1/6	=	0.1(6)
1/7	=	0.(142857)
1/8	=	0.125
1/9	=	0.(1)
1/10	=	0.1

Where 0.1(6) means 0.166666..., and has a 1-digit recurring cycle. It can be seen that ¹/₇ has a 6-digit recurring cycle.

Find the value of d  1000 for which ¹/_d contains the longest recurring cycle in its decimal fraction part.

오랜 동안 고민했다. 마땅한 알고리듬이 떠오르지 않았다. 일반적인 방법론이 전혀...

한참을 고민 끝에 결국 구글신님께 계시를 받기로 하고 검색을 하였다.

순환소수에 대한 '정리'가 있음을 알게 되었다.

여기 자료가 매우 유용하였다. 여기(Japanese).

요점만 정리하면 다음과 같다.

#1. 기약분수(k/n)가 무한순환소수일때, 소숫점 첫째자리부터 길이 r의 순환구간이 반복되는 것과, 10^r == 1 (mod n)이 성립하는 것은 동치이다.

#2. 기약분수가 순수한 순환소수일때 분모는 반드시 10과 서로소 이다. 반대로 분모가 10과 서로소인 기약분수를 소수로 나타내면 반드시 순수한 순환소수가 된다. (순수한 순환소수란, 0.121212...같은 것. 0.3121212는 순수하지 않은 순환소수를 지칭.)

2와 5를 제거하는 이유는, reLen 알고리듬상 reLen이 무한루프에 빠져들기 때문임.

import Data.Numbers.Primes
import Data.List
import qualified Data.Set as Set
import Data.Ord 

main :: IO()
main = print $ fst $ maximumBy (comparing snd) $ zip [1..1000] $ map reciprocalLength [1..1000] 

reciprocalLength :: Integer -> Integer
reciprocalLength n = reLen $ remove2or5 n 

remove2or5 :: Integer -> Integer
remove2or5 n = product $ Set.toList $ Set.difference (Set.fromList $ primeFactors n) (Set.fromList [2,5])
--remove2or5 n = product $ delete 5 $ delete 2 $ nub $ primeFactors n 

reLen :: Integer -> Integer
reLen n
    | n == 0 || n == 1  = 0
    | otherwise         = head [ r | r <- [1..], 10^r `mod` n == 1] 

*Main> main
983

Haskell Numeric Class & Type

Euler Project: Problem 25

The Fibonacci sequence is defined by the recurrence relation:

F_n = F_n1 + F_n2, where F₁ = 1 and F₂ = 1.

Hence the first 12 terms will be:

F₁ = 1
F₂ = 1
F₃ = 2
F₄ = 3
F₅ = 5
F₆ = 8
F₇ = 13
F₈ = 21
F₉ = 34
F₁₀ = 55
F₁₁ = 89
F₁₂ = 144

The 12th term, F₁₂, is the first term to contain three digits.

What is the first term in the Fibonacci sequence to contain 1000 digits?

Prelude Data.List Factory.Math.Fibonacci> elemIndex (head $ filter (> 10^(1000-1)) $ fibonacci) fibonacci
Just 4782

Euler Project: Problem 24

A permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:

012   021   102   120   201   210

What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?

Prelude Data.List> (sort $ permutations "0123456789") !! (1000000 - 1)
"2783915460"

Euler Project: Problem 23

A perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of 28 would be 1 + 2 + 4 + 7 + 14 = 28, which means that 28 is a perfect number.

A number n is called deficient if the sum of its proper divisors is less than n and it is called abundant if this sum exceeds n.

As 12 is the smallest abundant number, 1 + 2 + 3 + 4 + 6 = 16, the smallest number that can be written as the sum of two abundant numbers is 24. By mathematical analysis, it can be shown that all integers greater than 28123 can be written as the sum of two abundant numbers. However, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit.

Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers.

import Data.Numbers
import qualified Data.Set as Set 

main :: IO()
main = print $ sum $ Set.toList $ Set.difference (Set.fromList [1..28123]) (Set.fromList abundantSumList) 

abundantSumList :: [Integer]
abundantSumList = [ x + y | x <- abundantList, y <- abundantList, x + y <= 28123] 

abundantList :: [Integer]
abundantList = [ x | x <- [12..(28123 - 12)], isAbundant x] 

isPerfect :: Integer -> Bool
isPerfect 1 = False
isPerfect x = x == (factorSum x - x) 

isDeficient :: Integer -> Bool
isDeficient 1 = True
isDeficient x = x > (factorSum x - x) 

isAbundant :: Integer -> Bool
isAbundant 1 = False
isAbundant x = x < (factorSum x - x) 

*Main> main
4179871

Euler Project: Problem 22

Using names.txt (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.

For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938  53 = 49714.

What is the total of all the name scores in the file?

import Data.List
import Data.List.Split
import Data.Char
import Data.Maybe 

main :: IO ()
main = do
    names <- readFile "names.txt"
    print $ sum $ map (\x -> getPosition names x * getScore x) $ sortedNamesList names 

getPosition :: String -> String -> Int
getPosition names x = fromMaybe 0 (elemIndex x $ sortedNamesList names) + 1 

getScore :: String -> Int
getScore xs = sum $ map (\x -> ord x - 64) xs 

sortedNamesList :: String -> [String]
sortedNamesList names = sort $ nameList names 

nameList :: String -> [String]
nameList = split (dropDelims . dropBlanks $ oneOf ",\"") 

*Main> main
871198282

Special thanks to Roel van Dijk.

cf) ghci에서 각 함수별로 let하여 실행하는 것, hs파일을 로드하여 실행하는 것 보다 더 빠르다. 원인은 잘 모르겠다.

Euler Project: Problem 21

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n).
If d(a) = b and d(b) = a, where a  b, then a and b are an amicable pair and each of a and b are called amicable numbers.

For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220.

Evaluate the sum of all the amicable numbers under 10000.

import Data.Numbers 

main :: IO()
main = print $ sum $ filter isAmicable [2..10000] 

isAmicable :: Integer -> Bool
isAmicable x = (x == d (d x)) && (x /= d x) 

d :: Integer -> Integer
d x = factorSum x - x 

*Main> main
31626

Euler Project: Problem 20

n! means n  (n  1)  ...  3  2  1

For example, 10! = 10  9  ...  3  2  1 = 3628800,
and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.

Find the sum of the digits in the number 100!

Prelude Data.List.Split> let factorial = product $ enumFromTo 1
Prelude Data.List.Split> sum $ map (\x -> read x :: Int) $ chunksOf 1 $ show $ factorial 100
Loading package split-0.2.2 ... linking ... done.
648

Euler Project: Problem 19

You are given the following information, but you may prefer to do some research for yourself.

• 1 Jan 1900 was a Monday.
• Thirty days has September,
  April, June and November.
  All the rest have thirty-one,
  Saving February alone,
  Which has twenty-eight, rain or shine.
  And on leap years, twenty-nine.
• A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.

How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?

이놈의 짧디 짧은 영어... (T_T)

import Data.Time.Calendar
import Data.Time.Calendar.WeekDate
import Data.Maybe 

main :: IO()
main = print $ length $ filter (== 1) $ sundayDateList $ sundayList diffdaysList 

sundayDateList :: [Integer] -> [Int]
sundayDateList = map (`calDay` toGregorian) 

sundayList :: [Integer] -> [Integer]
sundayList = mapMaybe (\x -> if calDay x toWeekDate == 7 then Just x else Nothing) 

calDay :: Integer -> (Day -> (Integer, Int, Int)) -> Int
calDay x myFn = take3rd $ myFn $ addDays x $ fromGregorian 1901 1 1 

take3rd :: (Integer, Int, Int) -> Int
take3rd (_, _, a) = a 

diffdaysList :: [Integer]
diffdaysList = [0..(diffDays (fromGregorian 2000 12 31) (fromGregorian 1901 1 1))] 

*Main> main
171

제멋대로 Functor, Monad & Arrow 개념

Monad에 대한 공포가 조금 없어지게 되어, 멋대로 이해해 본 functor, monad, arrow에 대해서 메모해 둔다.

먼저 그 유명하신 monad 먼저.

흔히 monad란 문맥을 고려한 value의 적용이라고도 말한다.

쉽게 말하면,

가령 Int형 데이터에 이용할 수 있는 연산(또는 함수)가 있다고 하자.

프로그래밍을 하다 보면, 이 함수를 String에도 이용하고 싶을 때가 있다(고 하자).

이를 가능하게 해 주는 것이 monad라고 생각할 수 있다.

조금더 정확(?)하게 말해 보면... (어짜피 내 이해가 수학적이지는 못하지만...)

monad는 value를 포장해 주는 것이다.

위의 예로 설명해 보면,

String을 Int형으로 포장해서 연산(또는 함수)에 적용시키는 것이다.

monad는 권론에서 그 어떤 추상화된 개념이라고 말을 하는데...

조금 수학적(?)으로 말해 본다면,

우리가 방정식을 풀 때, 모르는 수를 x라고 '말하면서' 방정식을 세우고 풀어간다. 즉, 우리가 몰라서 그렇지, x는 구체적인 어떤 숫자다. 이것도 일종의 추상화라고 할 수 있다. 숫자를 x라고 추상화하였듯이, 숫자 x를 추상화한 것이 monad라고 생각할 수 있겠다. 즉, Int Type, Char Type, String Type등등을 추상화한 그런 개념인 듯 하다. 다르게 말하면 '뭔가가 들어있는 정체불명의 value'.

monad와 functor는 유사하지만 다음과 같은 개념상의 차이가 있다.

Functor는 기존 문맥의 의미를 보존한다. 위의 예를 가지고 설명하자면, functor는 String형을 Int형으로 포장했으면, 결과도 Int형으로 된다. 다른 type으로 전환하지 못한다.

Functor

함수를 거친 value가 Int Type의 상자에 들어있는 String임을 기억하자. 함수의 입력값의 Type과 변화가 없다.

반면 Monad는 다른 type으로 전환할 수 있다. String형을 Int형으로 포장하여 연산(또는 함수)에 적용한 다음, Double형으로 결과물을 출력할 수 있다.

Monad

함수의 출력값이 Functor 그림과 달리 "?"으로 바뀌어 있다. 함수의 출력값은 그 어떤 Type도 가질 수 있다는 것을 나타낸다. 이것이 monad와 functor와의 차이이다.

변수에 대해서 작용하는 것이 Monad, Functor라면,

연산(또는 함수)에 대해서 작용하는 것이 Arrow라고 생각하면 된다.

Monad 보다 좀더 추상화된 개념이라고 한다.

Arrow에 대해서는 Wiki Book

Haskell/Understanding arrows(링크)에 있는 그림만이라도 보시면 개략을 알 수 있다.

여담: monad는 어떻게 보면, C에서 말하는 cast같은 역할을 한다고도 할 수 있다. 간단한 유틸이나 입력값이 제한적인 게임 프로그래밍에서는 그닥 중요하지 않으나, 실무 프로그램에서는 입력값에서 묻어오는 예상하지 못한 문자나 숫자로 인해서 엉뚱한 결과를 가져오는 경우가 있다. 특히 문자열을 처리하는 프로그램에서는 escape 문자처리에 종종 골머리를 앓게 된다.
지극히 개인적인 사견이지만...
C컴파일러를 구입할 돈이 없던 시절, 어셈블러로 프로그래밍을 했었다. 가장 짜증나는 것은 타인이 만든 라이브러리를 사용할 때 예상치 못한 결과값이 나오는 경우였다. 버그의 원인을 찾아보면, 거의 항상, 내가 의도한 data type과 다른 data type으로 라이브러리의 함수가 변수를 처리를 함으로서 생기는 문제들이었다. 특히 escape sequence가 묻어 들어가는 버그는 항상 생기는 것도 아니어서 찾기도 어려웠다. C와 같은 고급언어들은 data type을 강조함으로서, 메모리에서 읽어들이는 bit를 data type에 따라서 "강제"함으로서, 이러한 버그들을 회피했다. OOP라는 기법을 구조화 프로그래밍을 다른 관점으로 본다면, 계승등의 기법을 통해 함수에 적용되는 data type을 강제하는 방법이라고도 할 수 있다.
Haskell과 같은 Type theory의 첨병을 실험하고 있는 언어들은, 원천적으로 이러한 버그들을 배제한다. (Haskell이 순수 함수형 언어의 전형처럼 이야기 하지만, 많은 논문들은 type theory와 language의 표현력의 한계를 실험하는데 집중되는 것 처럼 보인다... 적어도 내게는...)
개인적으로는... Haskell은 변수에 얽매이지 않는 자유로운 프로그래밍이 가능하다는 것이 너무 매력적이다. 그래서 변수를 추상화 해주는 monad가 중요해지는 이유라고 생각한다.

Euler Project: Problem 18

By starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.

3
7 4
2 4 6
8 5 9 3

That is, 3 + 7 + 4 + 9 = 23.

Find the maximum total from top to bottom of the triangle below:

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

NOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)

main :: IO()
main = print $ foldr1 maxEleList rowData 

maxEleList :: [Int] -> [Int] -> [Int]
maxEleList xs ys = maxOfTwo upperList lowerList
                    where   upperList = zipWith (curry turpleSum) xs ys
                                 lowerList = zipWith (curry turpleSum) xs (tail ys)

maxOfTwo :: [Int] -> [Int] -> [Int]
maxOfTwo [] [] = []
maxOfTwo (x:xs) (y:ys) = max x y : maxOfTwo xs ys 

turpleSum :: (Int, Int) -> Int
turpleSum (x, y) = x + y 

rowData :: [[Int]]
rowData = map (map (\x -> read x :: Int) . words) [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15] 

r1 = "75"
r2 = "95 64"
r3 = "17 47 82"
r4 = "18 35 87 10"
r5 = "20 04 82 47 65"
r6 = "19 01 23 75 03 34"
r7 = "88 02 77 73 07 63 67"
r8 = "99 65 04 28 06 16 70 92"
r9 = "41 41 26 56 83 40 80 70 33"
r10 = "41 48 72 33 47 32 37 16 94 29"
r11 = "53 71 44 65 25 43 91 52 97 51 14"
r12 = "70 11 33 28 77 73 17 78 39 68 17 57"
r13 = "91 71 52 38 17 14 91 43 58 50 27 29 48"
r14 = "63 66 04 68 89 53 67 30 73 16 69 87 40 31"
r15 = "04 62 98 27 23 09 70 98 73 93 38 53 60 04 23" 

*Main> main
[1074]

Euler Project: Problem 17

If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.

If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?

NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of "and" when writing out numbers is in compliance with British usage.

import Data.List.Split 

main :: IO()
main = print $ sum $ map tellNoLength [1..1000] 

tellNoLength :: Int -> Int
tellNoLength n
| n `mod` 100 == 0 = findNoLength n
| n < 100 = findNoLength n
| n < 1000 = 3 + sum (map findNoLength $ seperate3Digit n)
| otherwise = error "Out of Range"
-- | otherwise = sum . map length . splitOneOf " -" "one thousand" -- error d/t type definition. 

findNoLength :: Int -> Int
findNoLength n = snd $ head $ dropWhile (\x -> fst x < n) matchTable 

seperate3Digit :: Int -> [Int]
seperate3Digit n = [n `div` 100 * 100, n `mod` 100] 

matchTable :: [(Int, Int)]
matchTable = zip rowNo lettNo 

lettNo :: [Int]
lettNo = map (sum . map length . splitOneOf " -") rowLetter 

rowNo :: [Int]
rowNo = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000] 

rowLetter :: [String]
rowLetter = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty", "twenty-one", "twenty-two", "twenty-three", "twenty-four", "twenty-five", "twenty-six", "twenty-seven", "twenty-eight", "twenty-nine", "thirty", "thirty-one", "thirty-two", "thirty-three", "thirty-four", "thirty-five", "thirty-six", "thirty-seven", "thirty-eight", "thirty-nine", "forty", "forty-one", "forty-two", "forty-three", "forty-four", "forty-five", "forty-six", "forty-seven", "forty-eight", "forty-nine", "fifty", "fifty-one", "fifty-two", "fifty-three", "fifty-four", "fifty-five", "fifty-six", "fifty-seven", "fifty-eight", "fifty-nine", "sixty", "sixty-one", "sixty-two", "sixty-three", "sixty-four", "sixty-five", "sixty-six", "sixty-seven", "sixty-eight", "sixty-nine", "seventy", "seventy-one", "seventy-two", "seventy-three", "seventy-four", "seventy-five", "seventy-six", "seventy-seven", "seventy-eight", "seventy-nine", "eighty", "eighty-one", "eighty-two", "eighty-three", "eighty-four", "eighty-five", "eighty-six", "eighty-seven", "eighty-eight", "eighty-nine", "ninety", "ninety-one", "ninety-two", "ninety-three", "ninety-four", "ninety-five", "ninety-six", "ninety-seven", "ninety-eight", "ninety-nine", "one hundred", "two hundred", "three hundred", "four hundred", "five hundred", "six hundred", "seven hundred", "eight hundred", "nine hundred", "one thousand"] 

*Main> main
21124

cf) I find "rowLetter" elements in Kid Math related web.

Euler Project: Problem 16

2¹⁵ = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

What is the sum of the digits of the number 2¹⁰⁰⁰?

Prelude Data.List.Split> sum $ map (\x -> read x :: Int) $ chunksOf 1 $ show $ 2^1000
1366

Euler Project: Problem 15

Starting in the top left corner of a 22 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.

How many such routes are there through a 2020 grid?

Prelude> :m Math.Combinat.Numbers
Prelude Math.Combinat.Numbers> 21 * catalan 20
137846528820

My first code is ... calculate so long long time.

latticeNo (x, 2) = x
latticeNo (2, y) = y
latticeNo (x, 3) = latticeNo (x - 1, 3) + x
latticeNo (3, y) = latticeNo (y - 1, 3) + y
latticeNo (x, y) = latticeNo (x - 1, y) + latticeNo (x, y - 1)

Second code is ... use combination. I'll try to know more general method.
Google tell me about Catalan number. See カタラン数

Euler Project: Problem 14

The following iterative sequence is defined for the set of positive integers:

n  n/2 (n is even)
n  3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

13  40  20  10  5  16  8  4  2  1

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one million.

main :: IO()
main = print $ maximum makeColSeqList 

makeColSeqList :: [(Int, Int)]
makeColSeqList = map (seqLenColNo . collatzSequence) [13..1000000] 

seqLenColNo :: [Int] -> (Int, Int)
seqLenColNo xs = (length xs, head xs) 

collatzSequence :: Int -> [Int]
collatzSequence n
| n == 1 = [1]
| otherwise = n : collatzSequence (collatz n) 

collatz :: Int -> Int
collatz n
| even n = n `div` 2
| odd n = 3 * n + 1 

*Main> main
(525,837799)

Euler Project: Problem 13

Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690

main :: IO()
main = print $ calLargeSum xss 

calLargeSum :: [String] -> String
calLargeSum xs = take 10 $ show . sum $ map ((\x -> read x :: Int) . take 13) xs 

xss = [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20, r21, r22, r23, r24, r25, r26, r27, r28, r29, r30, r31, r32, r33, r34, r35, r36, r37, r38, r39, r40, r41, r42, r43, r44, r45, r46, r47, r48, r49, r50, r51, r52, r53, r54, r55, r56, r57, r58, r59, r60, r61, r62, r63, r64, r65, r66, r67, r68, r69, r70, r71, r72, r73, r74, r75, r76, r77, r78, r79, r80, r81, r82, r83, r84, r85, r86, r87, r88, r89, r90, r91, r92, r93, r94, r95, r96, r97, r98, r99, r100] 

r1 = "37107287533902102798797998220837590246510135740250"
r2 = "46376937677490009712648124896970078050417018260538"
r3 = "74324986199524741059474233309513058123726617309629"
r4 = "91942213363574161572522430563301811072406154908250"
r5 = "23067588207539346171171980310421047513778063246676"
r6 = "89261670696623633820136378418383684178734361726757"
r7 = "28112879812849979408065481931592621691275889832738"
r8 = "44274228917432520321923589422876796487670272189318"
r9 = "47451445736001306439091167216856844588711603153276"
r10 = "70386486105843025439939619828917593665686757934951"
r11 = "62176457141856560629502157223196586755079324193331"
r12 = "64906352462741904929101432445813822663347944758178"
r13 = "92575867718337217661963751590579239728245598838407"
r14 = "58203565325359399008402633568948830189458628227828"
r15 = "80181199384826282014278194139940567587151170094390"
r16 = "35398664372827112653829987240784473053190104293586"
r17 = "86515506006295864861532075273371959191420517255829"
r18 = "71693888707715466499115593487603532921714970056938"
r19 = "54370070576826684624621495650076471787294438377604"
r20 = "53282654108756828443191190634694037855217779295145"
r21 = "36123272525000296071075082563815656710885258350721"
r22 = "45876576172410976447339110607218265236877223636045"
r23 = "17423706905851860660448207621209813287860733969412"
r24 = "81142660418086830619328460811191061556940512689692"
r25 = "51934325451728388641918047049293215058642563049483"
r26 = "62467221648435076201727918039944693004732956340691"
r27 = "15732444386908125794514089057706229429197107928209"
r28 = "55037687525678773091862540744969844508330393682126"
r29 = "18336384825330154686196124348767681297534375946515"
r30 = "80386287592878490201521685554828717201219257766954"
r31 = "78182833757993103614740356856449095527097864797581"
r32 = "16726320100436897842553539920931837441497806860984"
r33 = "48403098129077791799088218795327364475675590848030"
r34 = "87086987551392711854517078544161852424320693150332"
r35 = "59959406895756536782107074926966537676326235447210"
r36 = "69793950679652694742597709739166693763042633987085"
r37 = "41052684708299085211399427365734116182760315001271"
r38 = "65378607361501080857009149939512557028198746004375"
r39 = "35829035317434717326932123578154982629742552737307"
r40 = "94953759765105305946966067683156574377167401875275"
r41 = "88902802571733229619176668713819931811048770190271"
r42 = "25267680276078003013678680992525463401061632866526"
r43 = "36270218540497705585629946580636237993140746255962"
r44 = "24074486908231174977792365466257246923322810917141"
r45 = "91430288197103288597806669760892938638285025333403"
r46 = "34413065578016127815921815005561868836468420090470"
r47 = "23053081172816430487623791969842487255036638784583"
r48 = "11487696932154902810424020138335124462181441773470"
r49 = "63783299490636259666498587618221225225512486764533"
r50 = "67720186971698544312419572409913959008952310058822"
r51 = "95548255300263520781532296796249481641953868218774"
r52 = "76085327132285723110424803456124867697064507995236"
r53 = "37774242535411291684276865538926205024910326572967"
r54 = "23701913275725675285653248258265463092207058596522"
r55 = "29798860272258331913126375147341994889534765745501"
r56 = "18495701454879288984856827726077713721403798879715"
r57 = "38298203783031473527721580348144513491373226651381"
r58 = "34829543829199918180278916522431027392251122869539"
r59 = "40957953066405232632538044100059654939159879593635"
r60 = "29746152185502371307642255121183693803580388584903"
r61 = "41698116222072977186158236678424689157993532961922"
r62 = "62467957194401269043877107275048102390895523597457"
r63 = "23189706772547915061505504953922979530901129967519"
r64 = "86188088225875314529584099251203829009407770775672"
r65 = "11306739708304724483816533873502340845647058077308"
r66 = "82959174767140363198008187129011875491310547126581"
r67 = "97623331044818386269515456334926366572897563400500"
r68 = "42846280183517070527831839425882145521227251250327"
r69 = "55121603546981200581762165212827652751691296897789"
r70 = "32238195734329339946437501907836945765883352399886"
r71 = "75506164965184775180738168837861091527357929701337"
r72 = "62177842752192623401942399639168044983993173312731"
r73 = "32924185707147349566916674687634660915035914677504"
r74 = "99518671430235219628894890102423325116913619626622"
r75 = "73267460800591547471830798392868535206946944540724"
r76 = "76841822524674417161514036427982273348055556214818"
r77 = "97142617910342598647204516893989422179826088076852"
r78 = "87783646182799346313767754307809363333018982642090"
r79 = "10848802521674670883215120185883543223812876952786"
r80 = "71329612474782464538636993009049310363619763878039"
r81 = "62184073572399794223406235393808339651327408011116"
r82 = "66627891981488087797941876876144230030984490851411"
r83 = "60661826293682836764744779239180335110989069790714"
r84 = "85786944089552990653640447425576083659976645795096"
r85 = "66024396409905389607120198219976047599490197230297"
r86 = "64913982680032973156037120041377903785566085089252"
r87 = "16730939319872750275468906903707539413042652315011"
r88 = "94809377245048795150954100921645863754710598436791"
r89 = "78639167021187492431995700641917969777599028300699"
r90 = "15368713711936614952811305876380278410754449733078"
r91 = "40789923115535562561142322423255033685442488917353"
r92 = "44889911501440648020369068063960672322193204149535"
r93 = "41503128880339536053299340368006977710650566631954"
r94 = "81234880673210146739058568557934581403627822703280"
r95 = "82616570773948327592232845941706525094512325230608"
r96 = "22918802058777319719839450180888072429661980811197"
r97 = "77158542502016545090413245809786882778948721859617"
r98 = "72107838435069186155435662884062257473692284509516"
r99 = "20849603980134001723930671666823555245252804609722"
r100 = "53503534226472524250874054075591789781264330331690" 

*Main> main
"5537376230"

cf) It is very useful that multiline editing function of SublimeText.
See this and this

Convert "If Sentence" to Functional

foo x = case x of
   Just x     -> ...
   Nothing -> ...

is same to

foo (Just x)     = ...
foo (Nothing) = ...

case mbx of
   Just x
      | x > 10      -> ...
      | x < 0        -> ...
      | otherwise -> ...
   Nothing        -> ...

is same to

foo (Just x)
   | x > 10        = ...
   | x < 0          = ...
   | otherwise   = ...
foo (Nothing) = ...

Euler Project: Problem 12

The sequence of triangle numbers is generated by adding the natural numbers. So the 7^th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...

Let us list the factors of the first seven triangle numbers:

 1: 1
 3: 1,3
 6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

We can see that 28 is the first triangle number to have over five divisors.

What is the value of the first triangle number to have over five hundred divisors?

import Data.Numbers.Primes -- Must primes-0.2.1.0
import Data.List
import Data.Maybe 

main :: IO()
main = print $ head $ mapMaybe (tellAbove 500) $ zipFn tagNo 

tagNo :: [Int]
tagNo = [sum [1..n] | n <- [1..]] 

tellAbove :: Int -> (Int, Int) -> Maybe Int
tellAbove x (a, b)
| b >= x = Just a
| otherwise = Nothing 

zipFn :: [Int] -> [(Int, Int)]
zipFn xs = zip xs (facLength xs) 

facLength :: [Int] -> [Int]
facLength = map (length . getFactors) 

getFactors :: Int -> [Int]
getFactors x = map product . nub . subsequences $ primeFactors x

*Main> main
76576500

Euler Project: Problem 11

In the 2020 grid below, four numbers along a diagonal line have been marked in red.

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

The product of these numbers is 26  63  78  14 = 1788696.

What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 2020 grid?

import Data.List
import Data.List.Split 

main = print maxNum 

maxNum :: Int
maxNum = maximum (product4Row ++ product4Colum ++ product4DiagLtToRt ++ product4DiagRtToLt) 

product4Row :: [Int]
product4Row = concatMap rc4Digit rowData 

product4Colum :: [Int]
product4Colum = concatMap rc4Digit columData 

product4DiagLtToRt :: [Int]
product4DiagLtToRt = [diag4LtToRt (makeGridPos !! a) rowData | a <- [0..(length makeGridPos - 1)]] 

product4DiagRtToLt :: [Int]
product4DiagRtToLt = [diag4LtToRt (makeGridPos !! a) rowRevData | a <- [0..(length makeGridPos - 1)]] 

--
rc4Digit :: [Int] -> [Int]
rc4Digit xs
| length xs < 5 = []
| otherwise = product (take 4 xs) : rc4Digit (tail xs) 

diag4LtToRt :: (Int, Int) -> [[Int]] -> Int
diag4LtToRt (x, y) xs =
product $ map takeDigit [(x, y), (x+1, y+1), (x+2, y+2), (x+3, y+3)]
where takeDigit (a, b) = head $ drop (a - 1) $ xs !! (b - 1) 

--
makeGridPos :: [(Int, Int)]
makeGridPos = concatMap (zip [1..17] . replicate 17) [1..17] 

readToInt :: String -> [Int]
readToInt x = map (\xs -> read xs :: Int) $ splitOn " " x 

-- Grid Data
rowData = [r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, r20]
rowRevData = map reverse rowData -- Rt. To Lt. 방향 Diagonal 4 digit 곱셈.
columData = transpose rowData -- for 상하방향 4숫자 곱셈. 

r1  = readToInt "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08"
r2  = readToInt "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00"
r3  = readToInt "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65"
r4  = readToInt "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91"
r5  = readToInt "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80"
r6  = readToInt "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50"
r7  = readToInt "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70"
r8  = readToInt "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21"
r9  = readToInt "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72"
r10 = readToInt "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95"
r11 = readToInt "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92"
r12 = readToInt "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57"
r13 = readToInt "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58"
r14 = readToInt "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40"
r15 = readToInt "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66"
r16 = readToInt "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69"
r17 = readToInt "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36"
r18 = readToInt "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16"
r19 = readToInt "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54"
r20 = readToInt "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"

*Main> main
Loading package split-0.2.2 ... linking ... done.
70600674