Difference between revisions of "99 questions/1 to 10"
(Updated the link to "NinetyNine Prolog Problems") 
m (→Problem 8) 

(8 intermediate revisions by 7 users not shown)  
Line 12:  Line 12:  
<haskell> 
<haskell> 

−  +  λ> myLast [1,2,3,4] 

4 
4 

−  +  λ> myLast ['x','y','z'] 

'z' 
'z' 

</haskell> 
</haskell> 

Line 30:  Line 30:  
<haskell> 
<haskell> 

−  +  λ> myButLast [1,2,3,4] 

3 
3 

−  +  λ> myButLast ['a'..'z'] 

'y' 
'y' 

</haskell> 
</haskell> 

Line 53:  Line 53:  
<haskell> 
<haskell> 

−  +  λ> elementAt [1,2,3] 2 

2 
2 

−  +  λ> elementAt "haskell" 5 

'e' 
'e' 

</haskell> 
</haskell> 

Line 69:  Line 69:  
<haskell> 
<haskell> 

−  +  λ> myLength [123, 456, 789] 

3 
3 

−  +  λ> myLength "Hello, world!" 

13 
13 

</haskell> 
</haskell> 

Line 85:  Line 85:  
<haskell> 
<haskell> 

−  +  λ> myReverse "A man, a plan, a canal, panama!" 

"!amanap ,lanac a ,nalp a ,nam A" 
"!amanap ,lanac a ,nalp a ,nam A" 

−  +  λ> myReverse [1,2,3,4] 

[4,3,2,1] 
[4,3,2,1] 

</haskell> 
</haskell> 

Line 101:  Line 101:  
<haskell> 
<haskell> 

−  +  λ> isPalindrome [1,2,3] 

False 
False 

−  +  λ> isPalindrome "madamimadam" 

True 
True 

−  +  λ> isPalindrome [1,2,4,8,16,8,4,2,1] 

True 
True 

</haskell> 
</haskell> 

Line 127:  Line 127:  
Example in Haskell: 
Example in Haskell: 

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

<haskell> 
<haskell> 

⚫  
+  data NestedList a = Elem a  List [NestedList a] 

+  </haskell> 

+  
+  <haskell> 

⚫  
[5] 
[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] 

−  +  λ> flatten (List []) 

[] 
[] 

</haskell> 
</haskell> 

⚫  
+  
⚫  
== Problem 8 == 
== Problem 8 == 

Line 155:  Line 161:  
<haskell> 
<haskell> 

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

+  λ> compress "aaaabccaadeeee" 

−  ["a","b","c","a","d","e"] 

+  "abcade" 

</haskell> 
</haskell> 

Line 176:  Line 182:  
<haskell> 
<haskell> 

−  +  λ> pack ['a', 'a', 'a', 'a', 'b', 'c', 'c', 'a', 

+  'a', 'd', 'e', 'e', 'e', 'e'] 

["aaaa","b","cc","aa","d","eeee"] 
["aaaa","b","cc","aa","d","eeee"] 

</haskell> 
</haskell> 

[[99 questions/Solutions/9  Solutions]] 
[[99 questions/Solutions/9  Solutions]] 

−  
== Problem 10 == 
== Problem 10 == 

Line 196:  Line 201:  
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 NinetyNine Haskell Problems, based on NinetyNine Prolog Problems and NinetyNine 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'
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'
Problem 3
(*) Find the K'th element of a list. The first element in the list is number 1.
Example:
* (elementat '(a b c d e) 3) c
Example in Haskell:
λ> elementAt [1,2,3] 2
2
λ> elementAt "haskell" 5
'e'
Problem 4
(*) Find the number of elements of a list.
Example in Haskell:
λ> myLength [123, 456, 789]
3
λ> myLength "Hello, world!"
13
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]
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
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:
* (myflatten '(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 [])
[]
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"
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"]
Problem 10
(*) Runlength encoding of a list. Use the result of problem P09 to implement the socalled runlength 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')]