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

From HaskellWiki
Jump to: navigation, search
m (Removed examples of solutions from the page with description of the problem.)
m (Problem 8)
 
(One intermediate revision by the same user not shown)
Line 12: Line 12:
   
 
<haskell>
 
<haskell>
Prelude> myLast [1,2,3,4]
+
λ> myLast [1,2,3,4]
 
4
 
4
Prelude> myLast ['x','y','z']
+
λ> myLast ['x','y','z']
 
'z'
 
'z'
 
</haskell>
 
</haskell>
Line 30: Line 30:
   
 
<haskell>
 
<haskell>
Prelude> myButLast [1,2,3,4]
+
λ> myButLast [1,2,3,4]
 
3
 
3
Prelude> myButLast ['a'..'z']
+
λ> myButLast ['a'..'z']
 
'y'
 
'y'
 
</haskell>
 
</haskell>
Line 53: Line 53:
   
 
<haskell>
 
<haskell>
Prelude> elementAt [1,2,3] 2
+
λ> elementAt [1,2,3] 2
 
2
 
2
Prelude> elementAt "haskell" 5
+
λ> elementAt "haskell" 5
 
'e'
 
'e'
 
</haskell>
 
</haskell>
Line 69: Line 69:
   
 
<haskell>
 
<haskell>
Prelude> myLength [123, 456, 789]
+
λ> myLength [123, 456, 789]
 
3
 
3
Prelude> myLength "Hello, world!"
+
λ> myLength "Hello, world!"
 
13
 
13
 
</haskell>
 
</haskell>
Line 85: Line 85:
   
 
<haskell>
 
<haskell>
Prelude> myReverse "A man, a plan, a canal, panama!"
+
λ> myReverse "A man, a plan, a canal, panama!"
 
"!amanap ,lanac a ,nalp a ,nam A"
 
"!amanap ,lanac a ,nalp a ,nam A"
Prelude> myReverse [1,2,3,4]
+
λ> myReverse [1,2,3,4]
 
[4,3,2,1]
 
[4,3,2,1]
 
</haskell>
 
</haskell>
Line 101: Line 101:
   
 
<haskell>
 
<haskell>
*Main> isPalindrome [1,2,3]
+
λ> isPalindrome [1,2,3]
 
False
 
False
*Main> isPalindrome "madamimadam"
+
λ> isPalindrome "madamimadam"
 
True
 
True
*Main> isPalindrome [1,2,4,8,16,8,4,2,1]
+
λ> isPalindrome [1,2,4,8,16,8,4,2,1]
 
True
 
True
 
</haskell>
 
</haskell>
Line 133: Line 133:
   
 
<haskell>
 
<haskell>
*Main> flatten (Elem 5)
+
λ> flatten (Elem 5)
 
[5]
 
[5]
*Main> flatten (List [Elem 1, List [Elem 2, List [Elem 3, Elem 4], Elem 5]])
+
λ> flatten (List [Elem 1, List [Elem 2, List [Elem 3, Elem 4], Elem 5]])
 
[1,2,3,4,5]
 
[1,2,3,4,5]
*Main> flatten (List [])
+
λ> flatten (List [])
 
[]
 
[]
 
</haskell>
 
</haskell>
Line 161: Line 161:
   
 
<haskell>
 
<haskell>
> compress "aaaabccaadeeee"
+
λ> compress "aaaabccaadeeee"
 
"abcade"
 
"abcade"
 
</haskell>
 
</haskell>
Line 182: Line 182:
   
 
<haskell>
 
<haskell>
*Main> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a',
+
λ> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a',
 
'a', 'd', 'e', 'e', 'e', 'e']
 
'a', 'd', 'e', 'e', 'e', 'e']
 
["aaaa","b","cc","aa","d","eeee"]
 
["aaaa","b","cc","aa","d","eeee"]
Line 202: Line 202:
 
Example in Haskell:
 
Example in Haskell:
 
<haskell>
 
<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')]
 
</haskell>
 
</haskell>

Latest revision as of 09:06, 9 February 2019


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:

λ> myLast [1,2,3,4]
4
λ> 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:

λ> myButLast [1,2,3,4]
3
λ> 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:

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

Solutions


Problem 4

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

Example in Haskell:

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

Solutions


Problem 5

(*) Reverse a list.

Example in 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]

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:

λ> isPalindrome [1,2,3]
False
λ> isPalindrome "madamimadam"
True
λ> 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]
λ> 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 [])
[]


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 "aaaabccaadeeee"
"abcade"

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:

λ> 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