Difference between revisions of "99 questions/11 to 20"
m |
|||
(57 intermediate revisions by 27 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]. |
|
− | 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 11 == |
== Problem 11 == |
||
+ | <div style="border-bottom:1px solid #eee">(*) Modified run-length encoding. <span style="float:right"><small>[[99 questions/Solutions/11|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Modify the result of problem 10 in such a way that if an element has no duplicates it is simply copied into the result list. Only elements with duplicates are transferred as (N E) lists. |
||
− | (*) Modified run-length encoding. |
||
− | Modify the result of problem P10 in such a way that if an element has no duplicates it is simply copied into the result list. Only elements with duplicates are transferred as (N E) lists. |
||
− | |||
+ | Example: |
||
<pre> |
<pre> |
||
− | Example: |
||
* (encode-modified '(a a a a b c c a a d e e e e)) |
* (encode-modified '(a a a a b c c a a d e e e e)) |
||
((4 A) B (2 C) (2 A) D (4 E)) |
((4 A) B (2 C) (2 A) D (4 E)) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | P11> encodeModified "aaaabccaadeeee" |
||
− | [Multiple 4 'a',Single 'b',Multiple 2 'c',Multiple 2 'a',Single 'd',Multiple 4 'e'] |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> encodeModified "aaaabccaadeeee" |
||
− | data ListItem a = Single a | Multiple Int a |
||
+ | [Multiple 4 'a',Single 'b',Multiple 2 'c', |
||
+ | Multiple 2 'a',Single 'd',Multiple 4 'e'] |
||
+ | </haskell> |
||
− | encodeModified :: Eq a => [a] -> [ListItem a] |
||
− | encodeModified = map encodeHelper . encode |
||
− | where |
||
− | encodeHelper (1,x) = Single x |
||
− | encodeHelper (n,x) = Multiple n x |
||
− | </haskell> |
||
− | Again, like in problem 7, we need a utility type because lists in haskell are homogeneous. Afterwards we use the <hask>encode</hask> function from problem 10 and map single instances of a list item to <hask>Single</hask> and multiple ones to <hask>Multiple</hask>. |
||
− | |||
== Problem 12 == |
== Problem 12 == |
||
+ | <div style="border-bottom:1px solid #eee">(**) Decode a run-length encoded list. <span style="float:right"><small>[[99 questions/Solutions/12|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Given a run-length code list generated as specified in problem 11. Construct its uncompressed version. |
||
− | (**) Decode a run-length encoded list. |
||
− | Given a run-length code list generated as specified in problem P11. Construct its uncompressed version. |
||
− | <pre> |
||
− | Example: |
||
− | <example in lisp> |
||
Example in Haskell: |
Example in Haskell: |
||
− | <example in Haskell> |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> decodeModified |
||
− | <solution in haskell> |
||
+ | [Multiple 4 'a',Single 'b',Multiple 2 'c', |
||
+ | Multiple 2 'a',Single 'd',Multiple 4 'e'] |
||
+ | "aaaabccaadeeee" |
||
</haskell> |
</haskell> |
||
+ | |||
− | <description of implementation> |
||
+ | |||
− | |||
== Problem 13 == |
== Problem 13 == |
||
+ | <div style="border-bottom:1px solid #eee">(**) Run-length encoding of a list (direct solution). <span style="float:right"><small>[[99 questions/Solutions/13|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Implement the so-called run-length encoding data compression method directly. I.e. don't explicitly create the sublists containing the duplicates, as in problem 9, but only count them. As in problem P11, simplify the result list by replacing the singleton lists (1 X) by X. |
||
− | (**) Run-length encoding of a list (direct solution). |
||
− | Implement the so-called run-length encoding data compression method directly. I.e. don't explicitly create the sublists containing the duplicates, as in problem P09, but only count them. As in problem P11, simplify the result list by replacing the singleton lists (1 X) by X. |
||
− | <pre> |
||
Example: |
Example: |
||
+ | |||
+ | <pre> |
||
* (encode-direct '(a a a a b c c a a d e e e e)) |
* (encode-direct '(a a a a b c c a a d e e e e)) |
||
((4 A) B (2 C) (2 A) D (4 E)) |
((4 A) B (2 C) (2 A) D (4 E)) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | <example in Haskell> |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> encodeDirect "aaaabccaadeeee" |
||
− | <solution in haskell> |
||
+ | [Multiple 4 'a',Single 'b',Multiple 2 'c', |
||
+ | Multiple 2 'a',Single 'd',Multiple 4 'e'] |
||
</haskell> |
</haskell> |
||
+ | |||
− | <description of implementation> |
||
+ | |||
− | |||
== Problem 14 == |
== Problem 14 == |
||
+ | <div style="border-bottom:1px solid #eee">(*) Duplicate the elements of a list. <span style="float:right"><small>[[99 questions/Solutions/14|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Example: |
||
− | (*) Duplicate the elements of a list. |
||
<pre> |
<pre> |
||
− | Example: |
||
* (dupli '(a b c c d)) |
* (dupli '(a b c c d)) |
||
(A A B B C C C C D D) |
(A A B B C C C C D D) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | > dupli [1, 2, 3] |
||
− | [1,1,2,2,3,3] |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
− | dupli [ |
+ | λ> dupli [1, 2, 3] |
+ | [1,1,2,2,3,3] |
||
− | dupli (x:xs) = [x,x] ++ dupli(xs) |
||
</haskell> |
</haskell> |
||
+ | |||
− | |||
+ | |||
+ | |||
== Problem 15 == |
== Problem 15 == |
||
+ | <div style="border-bottom:1px solid #eee">(**) Replicate the elements of a list a given number of times. <span style="float:right"><small>[[99 questions/Solutions/15|Solutions]]</small></span> |
||
+ | </div> |
||
+ | Example: |
||
− | (**) Replicate the elements of a list a given number of times. |
||
<pre> |
<pre> |
||
− | Example: |
||
* (repli '(a b c) 3) |
* (repli '(a b c) 3) |
||
(A A A B B B C C C) |
(A A A B B B C C C) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | > repli "abc" 3 |
||
− | "aaabbbccc" |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> repli "abc" 3 |
||
− | repli :: [a] -> Int -> [a] |
||
+ | "aaabbbccc" |
||
− | repli as n = concatMap (replicate n) as |
||
</haskell> |
</haskell> |
||
+ | |||
+ | |||
== Problem 16 == |
== Problem 16 == |
||
− | (**) Drop every N'th element from a list. |
+ | <div style="border-bottom:1px solid #eee">(**) Drop every N'th element from a list. <span style="float:right"><small>[[99 questions/Solutions/16|Solutions]]</small></span> |
+ | </div> |
||
+ | <br> |
||
− | <pre> |
||
Example: |
Example: |
||
+ | |||
+ | <pre> |
||
* (drop '(a b c d e f g h i k) 3) |
* (drop '(a b c d e f g h i k) 3) |
||
(A B D E G H K) |
(A B D E G H K) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | *Main> drop = "abcdefghik" 3 |
||
− | "abdeghk" |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> dropEvery "abcdefghik" 3 |
||
− | drop xs n = drops xs (n-1) n |
||
+ | "abdeghk" |
||
− | drops [] _ _ = [] |
||
− | drops (x:xs) 0 max = drops xs (max-1) max |
||
− | drops (x:xs) (n+1) max = x:drops xs n max |
||
</haskell> |
</haskell> |
||
− | Here, drops is a helper-function to drop. In drops, there is an index n that counts from max-1 down to 0, and removes the head element each time it hits 0. |
||
− | |||
− | Note that drop is one of the standard Haskell functions, so redefining it is generally not a good idea. |
||
− | |||
== Problem 17 == |
== Problem 17 == |
||
+ | <div style="border-bottom:1px solid #eee">(*) Split a list into two parts; the length of the first part is given. <span style="float:right"><small>[[99 questions/Solutions/17|Solutions]]</small></span> |
||
− | |||
+ | </div> |
||
− | (*) Split a list into two parts; the length of the first part is given. |
||
+ | <br> |
||
Do not use any predefined predicates. |
Do not use any predefined predicates. |
||
− | <pre> |
||
Example: |
Example: |
||
+ | |||
+ | <pre> |
||
* (split '(a b c d e f g h i k) 3) |
* (split '(a b c d e f g h i k) 3) |
||
( (A B C) (D E F G H I K)) |
( (A B C) (D E F G H I K)) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | *Main> split "abcdefghik" 3 |
||
− | ("abc", "defghik") |
||
− | </pre> |
||
− | Solution using take and drop: |
||
<haskell> |
<haskell> |
||
+ | λ> split "abcdefghik" 3 |
||
− | split xs n = (take n xs, drop n xs) |
||
+ | ("abc", "defghik") |
||
</haskell> |
</haskell> |
||
+ | |||
− | |||
+ | |||
== Problem 18 == |
== Problem 18 == |
||
+ | <div style="border-bottom:1px solid #eee">(**) Extract a slice from a list. <span style="float:right"><small>[[99 questions/Solutions/18|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Given two indices, i and k, the slice is the list containing the elements between the i'th and k'th element of the original list (both limits included). Start counting the elements with 1. |
||
− | (**) Extract a slice from a list. |
||
+ | Example: |
||
− | Given two indices, i and k, the slice is the list containing the elements between the i'th and i'th element of the original list (both limits included). Start counting the elements with 1. |
||
<pre> |
<pre> |
||
− | Example: |
||
* (slice '(a b c d e f g h i k) 3 7) |
* (slice '(a b c d e f g h i k) 3 7) |
||
(C D E F G) |
(C D E F G) |
||
+ | </pre> |
||
Example in Haskell: |
Example in Haskell: |
||
− | *Main> slice ['a','b','c','d','e','f','g','h','i','k'] 3 7 |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> slice ['a','b','c','d','e','f','g','h','i','k'] 3 7 |
||
− | slice xs (i+1) k = take (k-i) $ drop i xs |
||
+ | "cdefg" |
||
</haskell> |
</haskell> |
||
− | |||
− | == Problem 19 == |
||
+ | |||
− | (**) Rotate a list N places to the left. |
||
+ | |||
+ | == Problem 19 == |
||
+ | <div style="border-bottom:1px solid #eee">(**) Rotate a list N places to the left. <span style="float:right"><small>[[99 questions/Solutions/19|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
Hint: Use the predefined functions length and (++). |
Hint: Use the predefined functions length and (++). |
||
− | <pre> |
||
Examples: |
Examples: |
||
+ | |||
+ | <pre> |
||
* (rotate '(a b c d e f g h) 3) |
* (rotate '(a b c d e f g h) 3) |
||
(D E F G H A B C) |
(D E F G H A B C) |
||
Line 196: | Line 189: | ||
* (rotate '(a b c d e f g h) -2) |
* (rotate '(a b c d e f g h) -2) |
||
(G H A B C D E F) |
(G H A B C D E F) |
||
+ | </pre> |
||
Examples in Haskell: |
Examples in Haskell: |
||
+ | |||
− | *Main> rotate ['a','b','c','d','e','f','g','h'] 3 |
||
+ | <haskell> |
||
+ | λ> rotate ['a','b','c','d','e','f','g','h'] 3 |
||
"defghabc" |
"defghabc" |
||
− | + | λ> rotate ['a','b','c','d','e','f','g','h'] (-2) |
|
"ghabcdef" |
"ghabcdef" |
||
− | </pre> |
||
− | |||
− | Solution: |
||
− | <haskell> |
||
− | rotate [] _ = [] |
||
− | rotate l 0 = l |
||
− | rotate (x:xs) (n+1) = rotate (xs ++ [x]) n |
||
− | rotate l n = rotate l (length l + n) |
||
</haskell> |
</haskell> |
||
− | There are two separate cases: |
||
− | <br/>- If n > 0, move the first element to the end of the list n times. |
||
− | <br/>- If n < 0, convert the problem to the equivalent problem for n > 0 by adding the list's length to n. |
||
== Problem 20 == |
== Problem 20 == |
||
+ | <div style="border-bottom:1px solid #eee">(*) Remove the K'th element from a list. <span style="float:right"><small>[[99 questions/Solutions/20|Solutions]]</small></span> |
||
+ | </div> |
||
+ | <br> |
||
+ | Example in Prolog: |
||
− | Remove the K'th element from a list. |
||
+ | |||
+ | <pre> |
||
+ | ?- remove_at(X,[a,b,c,d],2,R). |
||
+ | X = b |
||
+ | R = [a,c,d] |
||
+ | </pre> |
||
+ | |||
+ | Example in Lisp: |
||
<pre> |
<pre> |
||
− | Example: |
||
* (remove-at '(a b c d) 2) |
* (remove-at '(a b c d) 2) |
||
(A C D) |
(A C D) |
||
+ | </pre> |
||
+ | |||
+ | (Note that this only returns the residue list, while the Prolog version also returns the deleted element.) |
||
Example in Haskell: |
Example in Haskell: |
||
− | *Main> removeAt 1 ['a','b','c','d'] |
||
− | "acd" |
||
− | </pre> |
||
− | Solution: |
||
<haskell> |
<haskell> |
||
+ | λ> removeAt 2 "abcd" |
||
− | removeAt k xs = take k xs ++ drop (k+1) xs |
||
+ | ('b',"acd") |
||
</haskell> |
</haskell> |
||
+ | |||
− | Simply use the take and drop functions from the Prelude to take k elements from the start of xs and prepend to the list of elements k+1 to the end. Note that the Lisp code treats 1 as the first element in the list, and it appends NIL elements to the end of the list if k is greater than the list length. |
||
[[Category:Tutorials]] |
[[Category:Tutorials]] |
Latest revision as of 04:58, 10 June 2023
This is part of Ninety-Nine Haskell Problems, based on Ninety-Nine Prolog Problems and Ninety-Nine Lisp Problems.
Problem 11
Modify the result of problem 10 in such a way that if an element has no duplicates it is simply copied into the result list. Only elements with duplicates are transferred as (N E) lists.
Example:
* (encode-modified '(a a a a b c c a a d e e e e)) ((4 A) B (2 C) (2 A) D (4 E))
Example in Haskell:
λ> encodeModified "aaaabccaadeeee"
[Multiple 4 'a',Single 'b',Multiple 2 'c',
Multiple 2 'a',Single 'd',Multiple 4 'e']
Problem 12
Given a run-length code list generated as specified in problem 11. Construct its uncompressed version.
Example in Haskell:
λ> decodeModified
[Multiple 4 'a',Single 'b',Multiple 2 'c',
Multiple 2 'a',Single 'd',Multiple 4 'e']
"aaaabccaadeeee"
Problem 13
Implement the so-called run-length encoding data compression method directly. I.e. don't explicitly create the sublists containing the duplicates, as in problem 9, but only count them. As in problem P11, simplify the result list by replacing the singleton lists (1 X) by X.
Example:
* (encode-direct '(a a a a b c c a a d e e e e)) ((4 A) B (2 C) (2 A) D (4 E))
Example in Haskell:
λ> encodeDirect "aaaabccaadeeee"
[Multiple 4 'a',Single 'b',Multiple 2 'c',
Multiple 2 'a',Single 'd',Multiple 4 'e']
Problem 14
Example:
* (dupli '(a b c c d)) (A A B B C C C C D D)
Example in Haskell:
λ> dupli [1, 2, 3]
[1,1,2,2,3,3]
Problem 15
Example:
* (repli '(a b c) 3) (A A A B B B C C C)
Example in Haskell:
λ> repli "abc" 3
"aaabbbccc"
Problem 16
Example:
* (drop '(a b c d e f g h i k) 3) (A B D E G H K)
Example in Haskell:
λ> dropEvery "abcdefghik" 3
"abdeghk"
Problem 17
Do not use any predefined predicates.
Example:
* (split '(a b c d e f g h i k) 3) ( (A B C) (D E F G H I K))
Example in Haskell:
λ> split "abcdefghik" 3
("abc", "defghik")
Problem 18
Given two indices, i and k, the slice is the list containing the elements between the i'th and k'th element of the original list (both limits included). Start counting the elements with 1.
Example:
* (slice '(a b c d e f g h i k) 3 7) (C D E F G)
Example in Haskell:
λ> slice ['a','b','c','d','e','f','g','h','i','k'] 3 7
"cdefg"
Problem 19
Hint: Use the predefined functions length and (++).
Examples:
* (rotate '(a b c d e f g h) 3) (D E F G H A B C) * (rotate '(a b c d e f g h) -2) (G H A B C D E F)
Examples in Haskell:
λ> rotate ['a','b','c','d','e','f','g','h'] 3
"defghabc"
λ> rotate ['a','b','c','d','e','f','g','h'] (-2)
"ghabcdef"
Problem 20
Example in Prolog:
?- remove_at(X,[a,b,c,d],2,R). X = b R = [a,c,d]
Example in Lisp:
* (remove-at '(a b c d) 2) (A C D)
(Note that this only returns the residue list, while the Prolog version also returns the deleted element.)
Example in Haskell:
λ> removeAt 2 "abcd"
('b',"acd")