Difference between revisions of "99 questions/1 to 10"

From HaskellWiki
Jump to navigation Jump to search
(Moved solutions to first 5 problems to new subpages of 99 problems/Solutions)
(6 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 
__NOTOC__
  
__NOTOC__
   
−
This is part of [[H-99:_Ninety-Nine_Haskell_Problems|Ninety-Nine Haskell Problems]], based on [https://prof.ti.bfh.ch/hew1/informatik3/prolog/p-99/ Ninety-Nine Prolog Problems] and [http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html Ninety-Nine Lisp Problems].
 +
This is part of [[H-99:_Ninety-Nine_Haskell_Problems|Ninety-Nine Haskell Problems]], based on [https://sites.google.com/site/prologsite/prolog-problems Ninety-Nine Prolog Problems] and [http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html Ninety-Nine Lisp Problems].
−  
−
If you want to work on one of these, put your name in the block so we know someone's working on it. Then, change n in your block to the appropriate problem number, and fill in the <Problem description>,<example in lisp>,<example in Haskell>,<solution in haskell> and <description of implementation> fields.
 
   
 
== Problem 1 ==
  
== Problem 1 ==
Line 38: Line 36:
 
</haskell>
  
</haskell>
   
−
[[99 problems/Solutions/2 | Solutions]]
 +
[[99 questions/Solutions/2 | Solutions]]
   
   
Line 49: Line 47:
 
<pre>
  
<pre>
 
* (element-at '(a b c d e) 3)
  
* (element-at '(a b c d e) 3)
  +
c
−
C
  
 
</pre>
  
</pre>
   
Line 61: Line 59:
 
</haskell>
  
</haskell>
   
−
[[99 problems/Solutions/3 | Solutions]]
 +
[[99 questions/Solutions/3 | Solutions]]
   
   
Line 77: Line 75:
 
</haskell>
  
</haskell>
   
−
[[99 problems/Solutions/4 | Solutions]]
 +
[[99 questions/Solutions/4 | Solutions]]
   
   
Line 93: Line 91:
 
</haskell>
  
</haskell>
   
−
[[99 problems/Solutions/5 | Solutions]]
 +
[[99 questions/Solutions/5 | Solutions]]
   
   
Line 111: Line 109:
 
</haskell>
  
</haskell>
   
  +
[[99 questions/Solutions/6 | Solutions]]
−
Solution:
  
   
−
<haskell>
  
−
isPalindrome :: (Eq a) => [a] -> Bool
  
−
isPalindrome xs = xs == (reverse xs)
  
−
</haskell>
  
   
 
== Problem 7 ==
  
== Problem 7 ==
Line 132: Line 126:
   
 
Example in Haskell:
  
Example in Haskell:
  +
  +
We have to define a new data type, because lists in Haskell are homogeneous.
  +
<haskell>
  +
data NestedList a = Elem a | List [NestedList a]
  +
</haskell>
   
 
<haskell>
  
<haskell>
Line 142: Line 141:
 
</haskell>
  
</haskell>
   
−
Solution:
  
   
−
<haskell>
  
−
data NestedList a = Elem a | List [NestedList a]
  
   
  +
[[99 questions/Solutions/7 | Solutions]]
−
flatten :: NestedList a -> [a]
  
−
flatten (Elem x) = [x]
  
−
flatten (List x) = concatMap flatten x
  
−
</haskell>
  
−  
−
We have to define a new data type, because lists in Haskell are homogeneous.
  
−
[1, [2, [3, 4], 5]] is a type error. Therefore, we must have a way of
  
−
representing a list that may (or may not) be nested.
  
−  
−
Our NestedList datatype is either a single element of some type (Elem a), or a
  
−
list of NestedLists of the same type. (List [NestedList a]).
 
   
 
== Problem 8 ==
  
== Problem 8 ==
Line 164: Line 150:
   
 
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.
  
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:
   
 
<pre>
  
<pre>
−
Example:
  
 
* (compress '(a a a a b c c a a d e e e e))
  
* (compress '(a a a a b c c a a d e e e e))
 
(A B C A D E)
  
(A B C A D E)
  +
</pre>
   
 
Example in Haskell:
  
Example in Haskell:
−
*Main> compress ['a','a','a','a','b','c','c','a','a','d','e','e','e','e']
  
−
['a','b','c','a','d','e']
  
−
</pre>
  
   
−
Solution:
  
 
<haskell>
  
<haskell>
  +
> compress ["a","a","a","a","b","c","c","a","a","d","e","e","e","e"]
−
compress :: Eq a => [a] -> [a]
  
  +
["a","b","c","a","d","e"]
−
compress = map head . group
  
 
</haskell>
  
</haskell>
   
  +
[[99 questions/Solutions/8 | Solutions]]
−
We simply group equal values together (group), then take the head of each.
 
−
Note that (with GHC) we must give an explicit type to ''compress'' otherwise we get:
  
−  
−
<haskell>
  
−
Ambiguous type variable `a' in the constraint:
  
−
`Eq a'
  
−
arising from use of `group'
 
−
Possible cause: the monomorphism restriction applied to the following:
  
−
compress :: [a] -> [a]
  
−
Probable fix: give these definition(s) an explicit type signature
  
−
or use -fno-monomorphism-restriction
  
−
</haskell>
  
−  
−
We can circumvent the monomorphism restriction by writing ''compress'' this way (See: section 4.5.4 of [http://haskell.org/onlinereport the report]):
  
−  
−
<haskell>compress xs = map head $ group xs</haskell>
  
−  
−
An alternative solution is
  
−  
−
<haskell>
  
−
compress [] = []
  
−
compress [a] = [a]
  
−
compress (x : y : xs) = (if x == y then [] else [x]) ++ compress (y : xs)
  
−
</haskell>
  
   
 
== Problem 9 ==
  
== Problem 9 ==
Line 210: Line 171:
 
(**) Pack consecutive duplicates of list elements into sublists.
  
(**) Pack consecutive duplicates of list elements into sublists.
 
If a list contains repeated elements they should be placed in separate sublists.
  
If a list contains repeated elements they should be placed in separate sublists.
  +
  +
Example:
   
 
<pre>
  
<pre>
−
Example:
  
 
* (pack '(a a a a b c c a a d e e e e))
  
* (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))
  
((A A A A) (B) (C C) (A A) (D) (E E E E))
  +
</pre>
−
<example in lisp>
  
   
 
Example in Haskell:
  
Example in Haskell:
−
*Main> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 'a', 'd', 'e', 'e', 'e', 'e']
  
−
["aaaa","b","cc","aa","d","eeee"]
  
−
</pre>
  
   
−
Solution:
  
 
<haskell>
  
<haskell>
−
pack (x:xs) = let (first,rest) = span (==x) xs
 +
*Main> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a',
−
in (x:first) : pack rest
 +
'a', 'd', 'e', 'e', 'e', 'e']
  +
["aaaa","b","cc","aa","d","eeee"]
−
pack [] = []
  
 
</haskell>
  
</haskell>
   
  +
[[99 questions/Solutions/9 | Solutions]]
−
A more verbose solution is
  
−
<haskell>
  
−
pack :: Eq a => [a] -> [[a]]
  
−
pack [] = []
  
−
pack (x:xs) = (x:first) : pack rest
  
−
where
  
−
getReps [] = ([], [])
  
−
getReps (y:ys)
  
−
| y == x = let (f,r) = getReps ys in (y:f, r)
  
−
| otherwise = ([], (y:ys))
  
−
(first,rest) = getReps xs
  
−
</haskell>
  
−  
−
This is implemented as <hask>group</hask> in <hask>Data.List</hask>.
  
   
 
== Problem 10 ==
  
== Problem 10 ==
Line 251: Line 196:
 
Example:
  
Example:
 
<pre>
  
<pre>
−
* (encode '(a a a a b c c a a d e e e e))
 +
* (encode '(a a a a b c c a a d e e e e))
−
((4 A) (1 B) (2 C) (2 A) (1 D)(4 E))
 +
((4 A) (1 B) (2 C) (2 A) (1 D)(4 E))
 
</pre>
  
</pre>
   
 
Example in Haskell:
  
Example in Haskell:
−
<pre>
 +
<haskell>
 
encode "aaaabccaadeeee"
  
encode "aaaabccaadeeee"
 
[(4,'a'),(1,'b'),(2,'c'),(2,'a'),(1,'d'),(4,'e')]
  
[(4,'a'),(1,'b'),(2,'c'),(2,'a'),(1,'d'),(4,'e')]
−
</pre>
  
−  
−
Solution:
  
−
<haskell>
  
−
encode xs = map (\x -> (length x,head x)) (group xs)
  
 
</haskell>
  
</haskell>
   
  +
[[99 questions/Solutions/10 | Solutions]]
−
which can also be expressed as a list comprehension:
  
   
−
<haskell>
  
−
[(length x, head x) | x <- group xs]
  
−
</haskell>
  
   
−
Or writing it [[Pointfree]]:
  
−  
−
<haskell>
  
−
encode :: Eq a => [a] -> [(Int, a)]
  
−
encode = map (\x -> (length x, head x)) . group
  
−
</haskell>
  
−  
−
Or (ab)using the "&&&" arrow operator for tuples:
  
−  
−
<haskell>
  
−
encode :: Eq a => [a] -> [(Int, a)]
  
−
encode xs = map (length &&& head) $ group xs
  
−
</haskell>
  
 
[[Category:Tutorials]]
  
[[Category:Tutorials]]

Revision as of 16:10, 5 October 2012


This is part of Ninety-Nine Haskell Problems, based on Ninety-Nine Prolog Problems and Ninety-Nine Lisp Problems.

Problem 1

(*) Find the last element of a list.

(Note that the Lisp transcription of this problem is incorrect.)

Example in Haskell: 

Prelude> myLast [1,2,3,4]
4
Prelude> myLast ['x','y','z']
'z'

Solutions


Problem 2

(*) Find the last but one element of a list.

(Note that the Lisp transcription of this problem is incorrect.)

Example in Haskell: 

Prelude> myButLast [1,2,3,4]
3
Prelude> myButLast ['a'..'z']
'y'

Solutions


Problem 3

(*) Find the K'th element of a list. The first element in the list is number 1.

Example: 

* (element-at '(a b c d e) 3)
c

Example in Haskell: 

Prelude> elementAt [1,2,3] 2
2
Prelude> elementAt "haskell" 5
'e'

Solutions


Problem 4

(*) Find the number of elements of a list.

Example in Haskell: 

Prelude> myLength [123, 456, 789]
3
Prelude> myLength "Hello, world!"
13

Solutions


Problem 5

(*) Reverse a list.

Example in Haskell: 

Prelude> reverse "A man, a plan, a canal, panama!"
"!amanap ,lanac a ,nalp a ,nam A"
Prelude> reverse [1,2,3,4]
[4,3,2,1]

Solutions


Problem 6

(*) Find out whether a list is a palindrome. A palindrome can be read forward or backward; e.g. (x a m a x).

Example in Haskell: 

*Main> isPalindrome [1,2,3]
False
*Main> isPalindrome "madamimadam"
True
*Main> isPalindrome [1,2,4,8,16,8,4,2,1]
True

Solutions


Problem 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: 

* (my-flatten '(a (b (c d) e)))
(A B C D E)

Example in Haskell:

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

 data NestedList a = Elem a | List [NestedList a]

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


Solutions

Problem 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: 

* (compress '(a a a a b c c a a d e e e e))
(A B C A D E)

Example in Haskell: 

> compress ["a","a","a","a","b","c","c","a","a","d","e","e","e","e"]
["a","b","c","a","d","e"]

Solutions

Problem 9

(**) Pack consecutive duplicates of list elements into sublists. If a list contains repeated elements they should be placed in separate sublists.

Example: 

* (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))

Example in Haskell: 

*Main> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 
             'a', 'd', 'e', 'e', 'e', 'e']
["aaaa","b","cc","aa","d","eeee"]

Solutions

Problem 10

(*) Run-length encoding of a list. Use the result of problem P09 to implement the so-called run-length encoding data compression method. Consecutive duplicates of elements are encoded as lists (N E) where N is the number of duplicates of the element E.

Example: 

* (encode '(a a a a b c c a a d e e e e))
((4 A) (1 B) (2 C) (2 A) (1 D)(4 E))

Example in Haskell: 

encode "aaaabccaadeeee"
[(4,'a'),(1,'b'),(2,'c'),(2,'a'),(1,'d'),(4,'e')]

Solutions

Retrieved from "https://wiki.haskell.org/index.php?title=99_questions/1_to_10&oldid=54179"