file:the-99-problems/haskell.org

last [1, 2, 3, 4]

4

last . init $ [1,2,3,4]

3

[1,2,3,4,5] !! 2

3

length [1,2,3,4,5]

5

reverse [1,2,3,4,5]

let isPalindrome a = reverse a == a
isPalindrome [1,2,3,2,1]

True

:set +m
data NestedList a = Elem a | List [NestedList a]

let flatten (List []) = []
    flatten (Elem a) = [a]
    flatten (List (x:xs)) = flatten x ++ flatten (List xs)

flatten (List [Elem 1, List [Elem 2, List [Elem 3, Elem 4], Elem 5]])

Prelude> [1,2,3,4,5]

import Data.List
map head $ group "aaaabccaadeeee"

abcade

group ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 'a', 'd', 'e', 'e', 'e', 'e']

Prelude Data.List| ["aaaa","b","cc","aa","d","eeee"]

map (\n -> (head n, length n)) $ group "aaaabccaadeeee"

:set +m
import Data.List
data Modified a b = Single b | Multiple a b deriving Show
let encode = map (\n -> (head n, length n)) . group 
let encodeModified = map modify . encode where
      modify (b, 1) = Single b
      modify (c, d) = Multiple d c

encodeModified "aaaabccaadeeee"

Prelude Data.List> Prelude Data.List> Prelude Data.List> Prelude Data.List| Prelude Data.List| Prelude Data.List| Prelude Data.List> [Multiple 4 'a',Single 'b',Multiple 2 'c',Multiple 2 'a',Single 'd',Multiple 4 'e']

let decodeModified [] = []
    decodeModified (x:xs) = decode x ++ decodeModified xs where
      decode (Multiple a b) = replicate a b  
      decode (Single a) = [a]

decodeModified [Multiple 4 'a',Single 'b',Multiple 2 'c', Multiple 2 'a',Single 'd',Multiple 4 'e']

Prelude Data.List> "aaaabccaadeeee"

encodeModified "aaaabccaadeeee"

let dupli = concatMap (replicate 2)

dupli [1,2,3,4]

Prelude Data.List| Prelude Data.List> [1,1,2,2,3,3,4,4]

let dupli a b = concatMap (replicate b) a

dupli [1,2,3,4] 3

Prelude Data.List| Prelude Data.List> [1,1,1,2,2,2,3,3,3,4,4,4]

let dropEvery a n = map fst $ filter (\(d, i) -> i `mod` n /= 0) $ zip a [1..]

dropEvery "abcdefghik" 3

Prelude Data.List| Prelude Data.List> "abdeghk"

splitAt 3 "abcdefghik"

let slice c a b = take (b-a+1) $ drop (a-1) c

slice ['a','b','c','d','e','f','g','h','i','k'] 3 7

Prelude Data.List| Prelude Data.List> "cdefg"

let rotate a n = drop (c n) a ++ take (c n) a where
      c d = ((length a) + d) `mod` (length a)

rotate ['a','b','c','d','e','f','g','h'] 3
rotate ['a','b','c','d','e','f','g','h'] (-2)

ghabcdef

let removeAt n a = (a !! (n-1), take (n-1) a ++ drop (n) a)

removeAt 3 "abcd"

let insertAt x a n = fst b ++ [x] ++ snd b where
      b = splitAt (n-1) a

insertAt 'X' "abcd" 2

Prelude| Prelude| Prelude> "aXbcd"

range a b= [a..b]
range 4 9

import System.Random
let rnd_select xs n = do
    gen <- getStdGen
    return $ take n [ xs !! x | x <- randomRs (0, (length xs) - 1) gen]

rnd_select "abcdefgh" 3

Prelude System.Random| Prelude System.Random| Prelude System.Random| Prelude System.Random> dbc

let diffSelect xs n = do
    gen <- getStdGen
    return $ (take n . nub) [ xs !! x | x <- randomRs (0, (length xs) - 1) gen]


diffSelect 6 43

Prelude System.Random> [41,13,4,36,3,33]

import Data.List
let permu xs = do
    gen <- getStdGen
    return $ take 10 [ xs !! x | x <- randomRs (0, (length xs) - 1) gen]

permu "asdfasdf"

Prelude System.Random Data.List| Prelude System.Random Data.List| Prelude System.Random Data.List| 
<interactive>:172:1: error:
    parse error (possibly incorrect indentation or mismatched brackets)

import Data.List
permutations "asd"

let combinations _ [] = []
    combinations 0 _ = [[]]
    combinations n (x:xs) = map (x:) (combinations (n-1) xs) ++ combinations n xs

combinations 3 "abcdef"

Prelude| Prelude| Prelude| Prelude> ["abc","abd","abe","acd","ace","ade","bcd","bce","bde","cde"]

filter (\x -> ((length x)==3)) $ subsequences "abcdef"

combinations n = filter (\x -> ((length x)==n)) $ subsequences
group ns xs = map ($ xs) $ map combinations ns

group [2,3,4] ["aldo","beat","carla","david","evi","flip","gary","hugo","ida"]

sortOn length ["abc","de","fgh","de","ijkl","mn","o"]