H-99: Ninety-Nine Haskell Problems: Difference between revisions

From HaskellWiki
m (updated #1 to new format)
m (fixed link for ocaml's exercise list)
 
(68 intermediate revisions by 22 users not shown)
Line 1: Line 1:
__NOTOC__
__NOTOC__


These are Haskell translations of [http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html Ninety Nine Lisp Problems].
These are Haskell translations of [http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html Ninety-Nine Lisp Problems],
which are themselves translations of [https://web.archive.org/web/20170324220754/https://sites.google.com/site/prologsite/prolog-problems Ninety-Nine Prolog 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.  
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 Haskell>,<solution in haskell> and <description of implementation> fields. Then be sure to update the status on this page to indicate that we have a solution!


== Problem 1 ==
== The problems ==


(*) Find the last box of a list.
These problems have been split into 11 parts, for ease of access.


Example:
* [[99_questions/1_to_10|Questions 1 to 10]]: Lists
* [[99_questions/11_to_20|Questions 11 to 20]]: Lists, continued
* [[99_questions/21_to_28|Questions 21 to 28]]: Lists again
* [[99_questions/31_to_41|Questions 31 to 41]]: Arithmetic
* [[99_questions/46_to_50|Questions 46 to 50]]: Logic and codes
* [[99_questions/54A_to_60|Questions 54A to 60]]: Binary trees
* [[99_questions/61_to_69|Questions 61 to 69]]: Binary trees, continued
* [[99_questions/70B_to_73|Questions 70B to 73]]: Multiway trees
* [[99_questions/80_to_89|Questions 80 to 89]]: Graphs
* [[99_questions/90_to_94|Questions 90 to 94]]: Miscellaneous problems
* [[99_questions/95_to_99|Questions 95 to 99]]: Miscellaneous problems, continued


<pre>
(Though the problems number from 1 to 99, there are some gaps and some additions marked with letters. There are actually only 88 problems.)
* (my-last '(a b c d))
(D)
</pre>


Example in Haskell:
== Solutions ==


<haskell>
Known solutions are listed at [[99 questions/Solutions]]. Some of those we have could do with cleaning up or additional solutions.
Prelude> last [1,2,3,4]
4
Prelude> last ['x','y','z']
'z'
</haskell>


Solution:
== References ==


<haskell>
* [https://web.archive.org/web/20170324220754/https://sites.google.com/site/prologsite/prolog-problems P-99: Ninety-Nine Prolog Problems] (Wayback Machine; original link now dead) contains Prolog solutions to all the problems.
last :: [a] -> a
* [http://www.ic.unicamp.br/~meidanis/courses/mc336/2006s2/funcional/L-99_Ninety-Nine_Lisp_Problems.html L-99: Ninety-Nine Lisp Problems] contains Lisp solutions to problems 1-11, 14, 15, 17 and 20-28.
last [x] = x
* [https://www.perlmonks.org/?node_id=590113 99 Problems in Perl 6] has an increasing number of Perl 6 solutions.
last (_:xs) = last xs
* [https://www.ocaml.org/exercises 99 Problems in OCaml] contains Ocaml solutions to many problems.
</haskell>


This function is defined in Prelude.
== Problem 2 ==
(*) Find the last but one box of a list.
<pre>
Example:
* (my-but-last '(a b c d))
(C D)
</pre>
This can be done by dropping all but the last two elements of a list:
<haskell>
myButLast :: [a] -> [a]
myButLast list = drop ((length list) - 2) list
</haskell>
== Problem 3 ==
(*) Find the K'th element of a list.
The first element in the list is number 1.
<pre>
Example:
* (element-at '(a b c d e) 3)
C
</pre>
This is (almost) the infix operator !! in Prelude, which is defined as:
<haskell>
(!!)                :: [a] -> Int -> a
(x:_)  !! 0        =  x
(_:xs) !! n        =  xs !! (n-1)
</haskell>
Except this doesn't quite work, because !! is zero-indexed, and element-at should be one-indexed. So:
<haskell>
elementAt :: [a] -> Int -> a
elementAt list i = list !! (i-1)
</haskell>
== Problem 4 ==
(*) Find the number of elements of a list.
This is "length" in Prelude, which is defined as:
<haskell>
length          :: [a] -> Int
length []        =  0
length (_:l)    =  1 + length l
</haskell>
== Problem 5 ==
(*) Reverse a list.
This is "reverse" in Prelude, which is defined as:
<haskell>
reverse          :: [a] -> [a]
reverse          =  foldl (flip (:)) []
</haskell>
The standard definition is concise, but not very readable. Another way to define reverse is:
<haskell>
reverse :: [a] -> [a]
reverse [] = []
reverse (x:xs) = reverse xs ++ [x]
</haskell>
== 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).
This is trivial, because we can use reverse:
<haskell>
isPalindrome :: (Eq a) => [a] -> Bool
isPalindrome xs = xs == (reverse xs)
</haskell>
== 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).
<pre>
Example:
* (my-flatten '(a (b (c d) e)))
(A B C D E)
</pre>
This is tricky, because lists in Haskell are homogeneous. [1, [2, [3, 4], 5]]
is a type error. We have to devise some way of represent a list that may (or
may not) be nested:
<haskell>
data NestedList a = Elem a | List [NestedList a]
flatten :: NestedList a -> [a]
flatten (Elem x) = [x]
flatten (List []) = []
flatten (List (x:xs)) = flatten x ++ flatten (List xs)
</haskell>
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]). Let's try it out in ghci:
<pre>
*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 [])
[]
</pre>
== 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.
<pre>
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:
*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>
compress = map head . group
</haskell>
We simply group equal values together (group), then take the head of each.
       
== Problem 9 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 10 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 11 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 12 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 13 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 14 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 15 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 16 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 17 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 18 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 19 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 20 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 21 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 22 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 23 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 24 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 25 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 26 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 27 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 28 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 29 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 30 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 31 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 32 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 33 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 34 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 35 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 36 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 37 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 38 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 39 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 40 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 41 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 42 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 43 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 44 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 45 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 46 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 47 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 48 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 49 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 50 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 51 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 52 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 53 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 54 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 55 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 56 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 57 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 58 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 59 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 60 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 61 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 62 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 63 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 64 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 65 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 66 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 67 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 68 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 69 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 70 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 71 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 72 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 73 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 74 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 75 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 76 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 77 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 78 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 79 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 80 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 81 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 82 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 83 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 84 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 85 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 86 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 87 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 88 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 89 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 90 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 91 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 92 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 93 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 94 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 95 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 96 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 97 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 98 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
== Problem 99 ==
<Problem description>
<pre>
Example:
<example in lisp>
Example in Haskell:
<example in Haskell>
</pre>
Solution:
<haskell>
<solution in haskell>
</haskell>
<description of implementation>
       
[[Category:Tutorials]]
[[Category:Tutorials]]
[[Category:Code]]

Latest revision as of 19:49, 4 January 2024


These are Haskell translations of Ninety-Nine Lisp Problems, which are themselves translations of Ninety-Nine Prolog 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 Haskell>,<solution in haskell> and <description of implementation> fields. Then be sure to update the status on this page to indicate that we have a solution!

The problems

These problems have been split into 11 parts, for ease of access.

(Though the problems number from 1 to 99, there are some gaps and some additions marked with letters. There are actually only 88 problems.)

Solutions

Known solutions are listed at 99 questions/Solutions. Some of those we have could do with cleaning up or additional solutions.

References

Retrieved from "https://wiki.haskell.org/index.php?title=H-99:_Ninety-Nine_Haskell_Problems&oldid=66483"