99-problems/Haskell.org

#+TITLE: 99 Haskell Problems
#+Author: Joseph Ferano

https://wiki.haskell.org/H-99:_Ninety-Nine_Haskell_Problems

*** #1 Find the last element of a list.

#+begin_src haskell
λ> myLast [1,2,3,4]
4
λ> myLast ['x','y','z']
'z'
#+end_src


**** Solution
#+begin_src haskell
myLast [] = error "Cannot accept an empty list"
myLast [x] = x
myLast (_:xs) = myLast xs

myLast [1..5]
#+end_src


*** #2 Find the last but one element of a list.

#+begin_src haskell
λ> myButLast [1,2,3,4]
3
λ> myButLast ['a'..'z']
'y'
#+end_src


**** Solution
#+begin_src haskell
myButLast x
  | length x < 2 = error "Cannot accept an empty list"
  | otherwise = case x of
                  [x,y] -> x
                  (x:xs) -> myButLast xs
#+end_src


*** #3 Find the K'th element of a list.

The first element in the list is number 1.

#+begin_src haskell
λ> elementAt [1,2,3] 2
2
λ> elementAt "haskell" 5
'e'
#+end_src


**** Solution
#+begin_src haskell
elementAt (x:xs) i = if i == 1 then x else elementAt xs (i - 1)
#+end_src


*** #4 Find the number of elements of a list.

#+begin_src haskell
λ> myLength [123, 456, 789]
3
λ> myLength "Hello, world!"
13
#+end_src


**** Solution

#+begin_src haskell
myLength [] = 0
myLength xs = foldl (\acc _ -> acc + 1) 0 xs
-- or
myLength' [] = 0
myLength' [x] = 1
myLength' (_:xs) = 1 + myLength xs
#+end_src

*** #5 Reverse a list.

#+begin_src haskell
λ> myReverse "A man, a plan, a canal, panama!"
"!amanap ,lanac a ,nalp a ,nam A"
λ> myReverse [1,2,3,4]
[4,3,2,1]
#+end_src


**** Solution

#+begin_src haskell
myReverse = go []
  where go acc [] = acc
        go acc (x:xs) = go (x:acc) xs
#+end_src

*** #6 Find out whether a list is a palindrome

#+begin_src haskell
λ> isPalindrome [1,2,3]
False
λ> isPalindrome "madamimadam"
True
λ> isPalindrome [1,2,4,8,16,8,4,2,1]
True
#+end_src

**** Solution
#+begin_src haskell
isPalindrome xs = xs == reverse xs
#+end_src
*** #7 Flatten a nested list structure.
Transform a list, possibly holding lists as elements into a `flat' list by replacing each list with its elements (recursively).

Example:
#+begin_src haskell
,* (my-flatten '(a (b (c d) e)))
(A B C D E)
#+end_src

Example in Haskell:

We have to define a new data type, because lists in Haskell are homogeneous.

#+begin_src haskell
data NestedList a = Elem a | List [NestedList a]
#+end_src

#+begin_src haskell
λ> flatten (Elem 5)
[5]
λ> flatten (List [Elem 1, List [Elem 2, List [Elem 3, Elem 4], Elem 5]])
[1,2,3,4,5]
λ> flatten (List [])
[]
#+end_src

**** Solution
#+begin_src haskell
flatten = reverse . go []
  where go acc (List []) = acc
        go acc (Elem x) = x:acc
        go acc (List (x:xs)) = go (go acc x) (List xs)
#+end_src
*** #8 Eliminate consecutive duplicates of list elements

If a list contains repeated elements they should be replaced with a single copy of the element. The order of the elements should not be changed.

Example:

#+begin_src haskell
,* (compress '(a a a a b c c a a d e e e e))
(A B C A D E)
#+end_src

Example in Haskell:

#+begin_src haskell
λ> compress "aaaabccaadeeee"
"abcade"
#+end_src
**** Solution

This is not great...

#+begin_src haskell
compress xs = reverse $ go [] xs
  where go acc [] = acc
        go [] (x:xs) = go [x] xs
        go [a] [x]
            | a == x = [a]
            | otherwise = [x,a]
        go (a:as) [x]
            | a == x = a:as
            | otherwise = x:a:as
        go [a] (x:xs)
            | a == x = go [a] xs
            | otherwise = go [x,a] xs
        go (a:as) (x:xs)
            | a == x = go (a:as) xs
            | otherwise = go (x:a:as) xs
#+end_src

Especially when one of the solutions is the following;

#+begin_src haskell
import Data.List

compress :: Eq a => [a] -> [a]
compress = map head . group
#+end_src
*** #9 Pack consecutive duplicates of list elements into sublists

If a list contains repeated elements they should be placed in separate sublists.

Example:

#+begin_src haskell
,* (pack '(a a a a b c c a a d e e e e))
((A A A A) (B) (C C) (A A) (D) (E E E E))
#+end_src

Example in Haskell:

#+begin_src haskell
λ> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 'a', 'd', 'e', 'e', 'e', 'e']
["aaaa","b","cc","aa","d","eeee"]
#+end_src
**** Solution
In python you can use ~Counter~
#+begin_src python
from collections import Counter
def pack(arr):
    return [[key] * val for key,val in Counter(arr).items()]
#+end_src

In Haskell, this is just ~group~

#+begin_src haskell
pack :: [a] -> [[a]]
pack = group
#+end_src

Here's my naive implementation

#+begin_src haskell
pack :: Eq a => [a] -> [[a]]
pack xs = reverse $ go [[]] xs
  where
    go acc [] = acc
    go ([]:acc) (x:xs) = go ([x]:acc) xs
    go ((a:as):acc) (x:xs)
       | a == x = go ((x:a:as):acc) xs
       | otherwise = go ([x]:(a:as):acc) xs
#+end_src