Solved Problems
Output a string to the console
Write the string
"Hello World!" to STDOUT
haskell
main = putStrLn "Hello World!"
Retrieve a string containing ampersands from the variables in a url
My PHP script first does a query to obtain customer info for a form. The form has first name and last name fields among others. The customer has put entries such as
The script variable for first name $_REQUEST
I have tried various functions like urldecode but all to no avail. I even tried encoding the url before the view screen is painted so that the url looks like
Of course this fails for the same reasons. What is a better approach?
"Ron & Jean" in the first name field in the database. Then the edit form script is called with variables such as
"http://myserver.com/custinfo/edit.php?mode=view&fname=Ron & Jean&lname=Smith".
The script variable for first name $_REQUEST
['firstname'] never gets beyond the "Ron" value because of the ampersand in the data.
I have tried various functions like urldecode but all to no avail. I even tried encoding the url before the view screen is painted so that the url looks like
"http://myserver/custinfo/edit.php?mode=view&fname="Ronxxnbsp;xxamp;xxnbsp;Jean"&lname=SMITH". (sorry I had to add the xx to replace the ampersand or it didn't display meaningful url contents the browser sees.)
Of course this fails for the same reasons. What is a better approach?
haskell
import Network.CGI
query = "http://myserver.com/custinfo/edit.php?" ++ formEncode [("mode", "view"), ("fname", "Ron & Jan"), ("lname","Smith")]
query = "http://myserver.com/custinfo/edit.php?" ++ formEncode [("mode", "view"), ("fname", "Ron & Jan"), ("lname","Smith")]
string-wrap
Wrap the string
Expected output:
> The quick brown fox jumps over the lazy dog. The quick brown fox jumps over t
> he lazy dog. The quick brown fox jumps over the lazy dog. The quick brown fox
> jumps over the lazy dog. The quick brown fox jumps over the lazy dog. The qui
> ck brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy
> dog. The quick brown fox jumps over the lazy dog. The quick brown fox jumps o
> ver the lazy dog. The quick brown fox jumps over the lazy dog.
"The quick brown fox jumps over the lazy dog. " repeated ten times to a max width of 78 chars, starting each line with "> "
Expected output:
> The quick brown fox jumps over the lazy dog. The quick brown fox jumps over t
> he lazy dog. The quick brown fox jumps over the lazy dog. The quick brown fox
> jumps over the lazy dog. The quick brown fox jumps over the lazy dog. The qui
> ck brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy
> dog. The quick brown fox jumps over the lazy dog. The quick brown fox jumps o
> ver the lazy dog. The quick brown fox jumps over the lazy dog.
haskell
wrap str
| length str <= 77 = [str]
| otherwise = [take 77 str] ++ wrap (drop 77 str)
mapM_ putStrLn . map ("> " ++) . wrap . concat . replicate 10 $ "The quick brown fox jumps over the lazy dog. "
| length str <= 77 = [str]
| otherwise = [take 77 str] ++ wrap (drop 77 str)
mapM_ putStrLn . map ("> " ++) . wrap . concat . replicate 10 $ "The quick brown fox jumps over the lazy dog. "
Define a string containing special characters
Define the literal string
"\#{'}${"}/"
haskell
putStrLn "\"\\#{'}${\"}/\""
let special = "\\#{'}${\"}/"
Define a multiline string
Define the string:
"This
Is
A
Multiline
String"
haskell
s = "This \
\Is \
\A \
\Multiline \
\String"
\Is \
\A \
\Multiline \
\String"
Define a string containing variables and expressions
Given variables a=3 and b=4 output
"3+4=7"
haskell
import Text.Printf
main = do
let a = 3
let b = 4
printf "%d+%d=%d" a b (a + b)
main = do
let a = 3
let b = 4
printf "%d+%d=%d" a b (a + b)
a = 3
b = 4
s = show a ++ "+" ++ show b ++ "=" ++ show (a + b)
main = putStrLn s
b = 4
s = show a ++ "+" ++ show b ++ "=" ++ show (a + b)
main = putStrLn s
Reverse the characters in a string
Given the string
"reverse me", produce the string "em esrever"
haskell
reverse "reverse me"
Reverse the words in a string
Given the string
"This is a end, my only friend!", produce the string "friend! only my end, the is This"
haskell
unwords (reverse (words "This is the end, my only friend!"))
Text wrapping
Wrap the string
> The quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog.
"The quick brown fox jumps over the lazy dog. " repeated ten times to a max width of 78 chars, starting each line with "> ", yielding this result:
> The quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog. The quick brown fox jumps
> over the lazy dog. The quick brown fox jumps over the lazy dog. The
> quick brown fox jumps over the lazy dog.
haskell
import Data.List (intercalate)
-- our list of words ["The", "quick", "brown", ...]
dogs = concat$ replicate 10$ words "The quick brown fox jumps over the lazy dog."
-- ["The", "The quick", "The quick brown", ...]
concats = scanl1 (\s v -> s ++ " " ++ v)
-- takes list of words, returns list of lines
wordwrap :: Int -> [String] -> [String]
wordwrap maxwidth [] = []
wordwrap maxwidth ws = sentence : (wordwrap maxwidth restwords)
where
zipped = zip (concats ws) ws
(sentences, rest) = span (\(s,w) -> (length s) <= maxwidth) zipped
sentence = last (map fst sentences)
restwords = map snd rest
main = putStrLn ("> " ++ intercalate "\n> " (wordwrap 76 dogs))
-- our list of words ["The", "quick", "brown", ...]
dogs = concat$ replicate 10$ words "The quick brown fox jumps over the lazy dog."
-- ["The", "The quick", "The quick brown", ...]
concats = scanl1 (\s v -> s ++ " " ++ v)
-- takes list of words, returns list of lines
wordwrap :: Int -> [String] -> [String]
wordwrap maxwidth [] = []
wordwrap maxwidth ws = sentence : (wordwrap maxwidth restwords)
where
zipped = zip (concats ws) ws
(sentences, rest) = span (\(s,w) -> (length s) <= maxwidth) zipped
sentence = last (map fst sentences)
restwords = map snd rest
main = putStrLn ("> " ++ intercalate "\n> " (wordwrap 76 dogs))
Remove leading and trailing whitespace from a string
Given the string
" hello " return the string "hello".
haskell
unwords (words " hello ")
Simple substitution cipher
Take a string and return the ROT13 and ROT47 (Check Wikipedia) version of the string.
For example:
String is: Hello World #123
ROT13 returns: Uryyb Jbeyq #123
ROT47 returns: w6==@ (@C=5 R`ab
For example:
String is: Hello World #123
ROT13 returns: Uryyb Jbeyq #123
ROT47 returns: w6==@ (@C=5 R`ab
haskell
import Char
ebg13 c | isAlpha c && toLower c <= 'm' = chr ((ord c) + 13)
| isAlpha c && toLower c > 'm' = chr ((ord c) - 13)
| otherwise = c
rot13 str = map ebg13 str
ebg47 c | c > ' ' && c <= 'N' = chr ((ord c) + 47)
| c > 'N' && c <= '~' = chr ((ord c) - 47)
| otherwise = c
rot47 str = map ebg47 str
ebg13 c | isAlpha c && toLower c <= 'm' = chr ((ord c) + 13)
| isAlpha c && toLower c > 'm' = chr ((ord c) - 13)
| otherwise = c
rot13 str = map ebg13 str
ebg47 c | c > ' ' && c <= 'N' = chr ((ord c) + 47)
| c > 'N' && c <= '~' = chr ((ord c) - 47)
| otherwise = c
rot47 str = map ebg47 str
Make a string uppercase
Transform
"Space Monkey" into "SPACE MONKEY"
haskell
toUpperCase oldstring converted = if oldstring == ""
then converted
else toUpperCase (tail(oldstring)) (converted ++ [Char.toUpper(head(oldstring))])
toUpperCase "Space Monkey" ""
then converted
else toUpperCase (tail(oldstring)) (converted ++ [Char.toUpper(head(oldstring))])
toUpperCase "Space Monkey" ""
toUpperCase = map Char.toUpper
toUpperCase "Space Monkey"
toUpperCase "Space Monkey"
Make a string lowercase
Transform
"Caps ARE overRated" into "caps are overrated"
haskell
import Char
str = map toLower "Caps ARE overRated"
str = map toLower "Caps ARE overRated"
Capitalise the first letter of each word
Transform
"man OF stEEL" into "Man Of Steel"
haskell
import Data.Char
capitalizeWords = unwords . map capitalizeWord . words
where capitalizeWord [] = []
capitalizeWord (c:cs) = toUpper c : map toLower cs
capitalizeWords = unwords . map capitalizeWord . words
where capitalizeWord [] = []
capitalizeWord (c:cs) = toUpper c : map toLower cs
Find the distance between two points
haskell
data Floating n => Point2 n = Point2 n n
distance :: Floating n => Point2 n -> Point2 n -> n
distance (Point2 x1 y1) (Point2 x2 y2) = sqrt (x'*x' + y'*y')
where
x' = x1 - x2
y' = y1 - y2
-- > distance (Point2 5 10) (Point2 3 5)
-- 5.385...
-- > distance (Point2 1 1) (Point2 2 2)
-- 1.414...
distance :: Floating n => Point2 n -> Point2 n -> n
distance (Point2 x1 y1) (Point2 x2 y2) = sqrt (x'*x' + y'*y')
where
x' = x1 - x2
y' = y1 - y2
-- > distance (Point2 5 10) (Point2 3 5)
-- 5.385...
-- > distance (Point2 1 1) (Point2 2 2)
-- 1.414...
Zero pad a number
Given the number 42, pad it to 8 characters like 00000042
haskell
import Text.Printf
printf "%08d" 42
printf "%08d" 42
Right Space pad a number
Given the number 1024 right pad it to 6 characters
"1024 "
haskell
let s = show 1024
p = 6
in s ++ (replicate (p - length s) ' ')
p = 6
in s ++ (replicate (p - length s) ' ')
import Text.Printf
main = do
putStrLn $ printf "%-6d" (1024::Int)
main = do
putStrLn $ printf "%-6d" (1024::Int)
Format a decimal number
Format the number 7/8 as a decimal with 2 places: 0.88
haskell
import Text.Printf
printf "%3.2f" (7/8)
printf "%3.2f" (7/8)
main = putStrLn $ Numeric.showFFloat (Just 2) (7/8) ""
Left Space pad a number
Given the number 73 left pad it to 10 characters
" 73"
haskell
import Text.Printf
formatted :: String
formatted = printf "%10d" 73
formatted :: String
formatted = printf "%10d" 73
Generate a random integer in a given range
Produce a random integer between 100 and 200 inclusive
haskell
import System.Random
randInRange :: Int -> Int -> IO Int
randInRange a b = getStdRandom $ randomR (a, b)
main = randInRange 100 200 >>= print
randInRange :: Int -> Int -> IO Int
randInRange a b = getStdRandom $ randomR (a, b)
main = randInRange 100 200 >>= print
import System.Random
main = randomRIO (1,100) >>= print
main = randomRIO (1,100) >>= print
Generate a repeatable random number sequence
Initialise a random number generator with a seed and generate five decimal values. Reset the seed and produce the same values.
haskell
import System.Random
import Control.Monad (forM_)
main = do
printRands
printRands
where printRands = forM_ [1..5] (\i -> print (randInt i))
randInt i = fst $ randomR (100, 200) (mkStdGen i) :: Int
import Control.Monad (forM_)
main = do
printRands
printRands
where printRands = forM_ [1..5] (\i -> print (randInt i))
randInt i = fst $ randomR (100, 200) (mkStdGen i) :: Int
import System.Random
gen1 = mkStdGen 12345
gen2 = mkStdGen 12345
main = do
print $ take 5 (randoms gen1 :: [Float])
print $ take 5 (randoms gen2 :: [Float])
gen1 = mkStdGen 12345
gen2 = mkStdGen 12345
main = do
print $ take 5 (randoms gen1 :: [Float])
print $ take 5 (randoms gen2 :: [Float])
Check if a string matches a regular expression
Display
"ok" if "Hello" matches /[A-Z][a-z]+/
haskell
import Text.Regex.Posix
main = if "Hello" =~ "[A-Z][a-z]+" then putStrLn "OK" else return ()
main = if "Hello" =~ "[A-Z][a-z]+" then putStrLn "OK" else return ()
Check if a string matches with groups
Display
"two" if "one two three" matches /one (.*) three/
haskell
import Text.Regex
main = case matchRegex (mkRegex "one (.*) three") "one two three" of
Nothing -> return ()
Just (x:_) -> putStrLn x
main = case matchRegex (mkRegex "one (.*) three") "one two three" of
Nothing -> return ()
Just (x:_) -> putStrLn x
Check if a string contains a match to a regular expression
Display
"ok" if "abc 123 @#$" matches /\d+/
haskell
import Text.Regex
main = case matchRegex (mkRegex "\d+") "abc 123 @#$" of
Nothing -> putStrLn "not ok"
Just _ -> putStrLn "ok"
main = case matchRegex (mkRegex "\d+") "abc 123 @#$" of
Nothing -> putStrLn "not ok"
Just _ -> putStrLn "ok"
Loop through a string matching a regex and performing an action for each match
Create a list
[fish1,cow3,boat4] when matching "(fish):1 sausage (cow):3 tree (boat):4" with regex /\((\w+)\):(\d+)/
haskell
import Text.Regex
getParenNum s = case matchRegexAll re s of
Nothing -> []
Just (_,_,after,[word,num]) -> (word ++ num):getParenNum after where
re = mkRegex "\\((\\w+)\\):([[:digit:]]+)"
main = putStrLn (show (getParenNum "(fish):1 sausage (cow):3 tree (boat):4"))
getParenNum s = case matchRegexAll re s of
Nothing -> []
Just (_,_,after,[word,num]) -> (word ++ num):getParenNum after where
re = mkRegex "\\((\\w+)\\):([[:digit:]]+)"
main = putStrLn (show (getParenNum "(fish):1 sausage (cow):3 tree (boat):4"))
Define an empty list
Assign the variable
"list" to a list with no elements
haskell
let list = []
Define a static list
Define the list
[One, Two, Three, Four, Five]
haskell
let a = ["One", "Two", "Three", "Four", "Five"]
Join the elements of a list, separated by commas
Given the list
[Apple, Banana, Carrot] produce "Apple, Banana, Carrot"
haskell
import Data.List
let join = intercalate ", " ["Apple", "Banana", "Carrot"]
let join = intercalate ", " ["Apple", "Banana", "Carrot"]
Join the elements of a list, in correct english
Create a function join that takes a List and produces a string containing an english language concatenation of the list. It should work with the following examples:
join(
join(
join(
join(
join(
[Apple, Banana, Carrot]) = "Apple, Banana, and Carrot"
join(
[One, Two]) = "One and Two"
join(
[Lonely]) = "Lonely"
join(
[]) = ""
haskell
join [] = ""
join [x] = x
join [x,y] = x ++ " and " ++ y
join [x,y,z] = x ++ ", " ++ y ++ ", and " ++ z
join (x:xs) = x ++ ", " ++ join xs
join [x] = x
join [x,y] = x ++ " and " ++ y
join [x,y,z] = x ++ ", " ++ y ++ ", and " ++ z
join (x:xs) = x ++ ", " ++ join xs
Produce the combinations from two lists
Given two lists, produce the list of tuples formed by taking the combinations from the individual lists. E.g. given the letters
["a", "b", "c"] and the numbers [4, 5], produce the list: [["a", 4], ["b", 4], ["c", 4], ["a", 5], ["b", 5], ["c", 5]]
haskell
comb :: [(String, Int)]
comb = do
b <- [4,5]
a <- ["a","b","c"]
return (a,b)
main = mapM_ print comb
comb = do
b <- [4,5]
a <- ["a","b","c"]
return (a,b)
main = mapM_ print comb
comb :: [(String, Int)]
comb = [(a, b) | b <- [4,5], a <- ["a","b","c"]]
main = print comb
comb = [(a, b) | b <- [4,5], a <- ["a","b","c"]]
main = print comb
From a List Produce a List of Duplicate Entries
Taking a list:
Write the code to produce a list of duplicates in the list:
["andrew", "bob", "chris", "bob"]
Write the code to produce a list of duplicates in the list:
["bob"]
haskell
import Data.List
input = ["andrew", "bob", "chris", "bob"]
output = [ head l | l <- group (sort input), length l > 1]
input = ["andrew", "bob", "chris", "bob"]
output = [ head l | l <- group (sort input), length l > 1]
Fetch an element of a list by index
Given the list
[One, Two, Three, Four, Five], fetch the third element ('Three')
haskell
let a = [1..5]
let b = a !! 2
print b
let b = a !! 2
print b
Fetch the last element of a list
Given the list
[Red, Green, Blue], access the last element ('Blue')
haskell
last ["Red", "Green", "Blue"]
Find the common items in two lists
Given two lists, find the common items. E.g. given beans =
['broad', 'mung', 'black', 'red', 'white'] and colors = ['black', 'red', 'blue', 'green'], what are the bean varieties that are also color names?
haskell
import Data.List
beans = ["broad", "mung", "black", "red", "white"]
colors = ["black", "red", "blue", "green"]
main = print (intersect beans colors)
beans = ["broad", "mung", "black", "red", "white"]
colors = ["black", "red", "blue", "green"]
main = print (intersect beans colors)
Display the unique items in a list
Display the unique items in a list, e.g. given ages =
[18, 16, 17, 18, 16, 19, 14, 17, 19, 18], display the unique elements, i.e. with duplicates removed.
haskell
import Data.List
ages = [18, 16, 17, 18, 16, 19, 14, 17, 19, 18]
uniqueAges = nub ages
ages = [18, 16, 17, 18, 16, 19, 14, 17, 19, 18]
uniqueAges = nub ages
Remove an element from a list by index
Given the list
[Apple, Banana, Carrot], remove the first element to produce the list [Banana, Carrot]
haskell
deleteNth n xs | n > 0 = take (n-1) xs ++ drop n xs
main = print $ deleteNth 1 [1..3]
main = print $ deleteNth 1 [1..3]
fruit :: [String]
fruit = ["Apple", "Banana", "Carrot"]
main :: IO ()
main = putStrLn $ show $ tail fruit
fruit = ["Apple", "Banana", "Carrot"]
main :: IO ()
main = putStrLn $ show $ tail fruit
Remove the last element of a list
haskell
ages = [1,2,3,4]
init ages
init ages
Rotate a list
Given a list
["apple", "orange", "grapes", "bananas"], rotate it by removing the first item and placing it on the end to yield ["orange", "grapes", "bananas", "apple"]
haskell
main = print $ rotate ["apple", "orange", "grapes", "bananas"]
rotate xs | length xs < 2 = xs
| otherwise = tail xs ++ [head xs]
rotate xs | length xs < 2 = xs
| otherwise = tail xs ++ [head xs]
Gather together corresponding elements from multiple lists
Given several lists, gather together the first element from every list, the second element from every list, and so on for all corresponding index values in the lists. E.g. for these three lists, first =
['Bruce', 'Tommy Lee', 'Bruce'], last = ['Willis', 'Jones', 'Lee'], years = [1955, 1946, 1940] the result should produce 3 actors. The middle actor should be Tommy Lee Jones.
haskell
import Prelude hiding (last)
first = ["Bruce", "Tommy Lee", "Bruce"]
last = ["Willis", "Jones", "Lee"]
years = [1955, 1946, 1940]
actors = zip3 first last years
first = ["Bruce", "Tommy Lee", "Bruce"]
last = ["Willis", "Jones", "Lee"]
years = [1955, 1946, 1940]
actors = zip3 first last years
List Combinations
Given two source lists (or sets), generate a list (or set) of all the pairs derived by combining elements from the individual lists (sets). E.g. given suites =
['H', 'D', 'C', 'S'] and faces = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'], generate the deck of 52 cards, confirm the deck size and check it contains an expected card, say 'Ace of Hearts'.
haskell
import Data.List
suites = ["H", "D", "C", "S"]
faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
main = do
let cards = [(s,f) | s <- suites, f <- faces ]
print (length cards)
print $ hasCard ("H", "A") "Ace of Hearts" cards
where hasCard t name cards = (if elem t cards then "Contains "
else "Does not contain") ++ name
suites = ["H", "D", "C", "S"]
faces = ["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"]
main = do
let cards = [(s,f) | s <- suites, f <- faces ]
print (length cards)
print $ hasCard ("H", "A") "Ace of Hearts" cards
where hasCard t name cards = (if elem t cards then "Contains "
else "Does not contain") ++ name
Perform an operation on every item of a list
Perform an operation on every item of a list, e.g.
for the list
the list of sizes of the strings, e.g.
for the list
["ox", "cat", "deer", "whale"] calculate
the list of sizes of the strings, e.g.
[2, 3, 4, 5]
haskell
map length ["ox", "cat", "deer", "whale"]
Split a list of things into numbers and non-numbers
Given a list that might contain e.g. a string, an integer, a float and a date,
split the list into numbers and non-numbers.
split the list into numbers and non-numbers.
haskell
import Data.List (partition)
type Date = String
data Things = TS String | TI Int | TD Date
deriving Show
main = do
let myList = [TI 1, TI 23, TS "Joe", TD "23/04/2009"]
print $ partition isNumber myList
where isNumber (TS _) = False
isNumber (TI _) = True
isNumber (TD _) = False
type Date = String
data Things = TS String | TI Int | TD Date
deriving Show
main = do
let myList = [TI 1, TI 23, TS "Joe", TD "23/04/2009"]
print $ partition isNumber myList
where isNumber (TS _) = False
isNumber (TI _) = True
isNumber (TD _) = False
Test if a condition holds for all items of a list
Given a list, test if a certain logical condition (i.e. predicate) holds for all items of the list.
haskell
all (> 1) [2, 3, 4]
all (> 1) [2, 3, 4]
Test if a condition holds for any items of a list
Given a list, test if a certain logical condition (i.e. predicate) holds for any items of the list.
haskell
any (> 1) [1, 2, 3]
Define an empty map
haskell
import qualified Data.Map as M
emptyMap = M.empty
emptyMap = M.empty
Define an unmodifiable empty map
haskell
import qualified Data.Map as Map
output :: Map.Map k v
output = Map.empty
output :: Map.Map k v
output = Map.empty
Define an initial map
Define the map
{circle:1, triangle:3, square:4}
haskell
import qualified Data.Map as M
initialMap = M.fromList [("circle", 1), ("triangle", 3), ("square", 4)]
initialMap = M.fromList [("circle", 1), ("triangle", 3), ("square", 4)]
Check if a key exists in a map
Given a map pets
{joe:cat,mary:turtle,bill:canary} print "ok" if an pet exists for "mary"
haskell
import qualified Data.Map as M
import Control.Monad (when)
pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
checkMary = when (M.member "mary" pets) (print "ok")
import Control.Monad (when)
pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
checkMary = when (M.member "mary" pets) (print "ok")
Retrieve a value from a map
Given a map pets
{joe:cat,mary:turtle,bill:canary} print the pet for "joe" ("cat")
haskell
import qualified Data.Map as M
pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
retrieve = print $ M.findWithDefault "Not found" "joe" pets
pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
retrieve = print $ M.findWithDefault "Not found" "joe" pets
Add an entry to a map
Given an empty pets map, add the mapping from
"rob" to "dog"
haskell
import qualified Data.Map as M
pets = M.insert "rob" "dog" M.empty
pets = M.insert "rob" "dog" M.empty
Remove an entry from a map
Given a map pets
{joe:cat,mary:turtle,bill:canary} remove the mapping for "bill" and print "canary"
haskell
import qualified Data.Map as M
main = do
let pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
pets2 = M.delete "bill" pets
print $ maybe "" id (M.lookup "bill" pets)
print pets2
main = do
let pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
pets2 = M.delete "bill" pets
print $ maybe "" id (M.lookup "bill" pets)
print pets2
Create a histogram map from a list
Given the list
[a,b,a,c,b,b], produce a map {a:2, b:3, c:1} which contains the count of each unique item in the list
haskell
import Data.List
import qualified Data.Map as Map
histogram :: Ord a => [a] -> Map.Map a Int
histogram xs = Map.fromList [ (head l, length l) | l <- group (sort xs) ]
output :: Map.Map String Int
output = histogram ["a","b","a","c","b","b"]
import qualified Data.Map as Map
histogram :: Ord a => [a] -> Map.Map a Int
histogram xs = Map.fromList [ (head l, length l) | l <- group (sort xs) ]
output :: Map.Map String Int
output = histogram ["a","b","a","c","b","b"]
import Control.Arrow
import Data.List
import qualified Data.Map as Map
import System.Random
histogram :: Ord a => [a] -> Map.Map a Int
histogram = Map.fromList . map (head &&& length) . group . sort
main = print . histogram . take 1000 . randomRs (1::Int, 100) =<< newStdGen
import Data.List
import qualified Data.Map as Map
import System.Random
histogram :: Ord a => [a] -> Map.Map a Int
histogram = Map.fromList . map (head &&& length) . group . sort
main = print . histogram . take 1000 . randomRs (1::Int, 100) =<< newStdGen
Categorise a list
Given the list
[one, two, three, four, five] produce a map {3:[one, two], 4:[four, five], 5:[three]} which sorts elements into map entries based on their length
haskell
import qualified Data.Map as Map
groupInMapBy :: Ord k => (a -> k) -> [a] -> Map.Map k [a]
groupInMapBy f = foldr (\a -> Map.insertWith (++) (f a) [a]) Map.empty
output :: Map.Map Int [String]
output = groupInMapBy length ["one", "two", "three", "four", "five"]
groupInMapBy :: Ord k => (a -> k) -> [a] -> Map.Map k [a]
groupInMapBy f = foldr (\a -> Map.insertWith (++) (f a) [a]) Map.empty
output :: Map.Map Int [String]
output = groupInMapBy length ["one", "two", "three", "four", "five"]
import Data.List (groupBy, sortBy)
import Data.Function (on)
groupInPairsBy :: Ord k => (a -> k) -> [a] -> [(k, [a])]
groupInPairsBy f = map (\xs -> (f (head xs), xs)) .
groupBy ((==) `on` f) . sortBy (compare `on` f)
output :: [(Int, [String])]
output = groupInPairsBy length ["one", "two", "three", "four", "five"]
import Data.Function (on)
groupInPairsBy :: Ord k => (a -> k) -> [a] -> [(k, [a])]
groupInPairsBy f = map (\xs -> (f (head xs), xs)) .
groupBy ((==) `on` f) . sortBy (compare `on` f)
output :: [(Int, [String])]
output = groupInPairsBy length ["one", "two", "three", "four", "five"]
Perform an action if a condition is true (IF .. THEN)
Given a variable name, if the value is
"Bob", display the string "Hello, Bob!". Perform no action if the name is not equal.
haskell
name = "Bob"
main = if name == "Bob" then putStrLn "Hello, Bob!" else return ()
main = if name == "Bob" then putStrLn "Hello, Bob!" else return ()
Perform different actions depending on a boolean condition (IF .. THEN .. ELSE)
Given a variable age, if the value is greater than 42 display
"You are old", otherwise display "You are young"
haskell
putStrLn ("You are " ++ if age > 42 then "old" else "young")
Replacing a conditional with many branches with a switch/case statement
Many languages support more compact forms of branching than just if ... then ... else such as switch or case or match. Use such a form to add an appropriate placing suffix to the numbers 1..40, e.g. 1st, 2nd, 3rd, 4th, ..., 11th, 12th, ... 39th, 40th
haskell
suffixed n = show n ++ suffix
where
suffix
| n `mod` 100 `div` 10 == 1 = "th"
| otherwise = case n `mod` 10 of
1 -> "st"
2 -> "nd"
3 -> "rd"
_ -> "th"
result = map suffixed [1..40]
where
suffix
| n `mod` 100 `div` 10 == 1 = "th"
| otherwise = case n `mod` 10 of
1 -> "st"
2 -> "nd"
3 -> "rd"
_ -> "th"
result = map suffixed [1..40]
Perform an action multiple times based on a boolean condition, checked before the first action (WHILE .. DO)
Starting with a variable x=1, Print the sequence
"1,2,4,8,16,32,64,128," by doubling x and checking that x is less than 150.
haskell
main :: IO ()
main = loop 1
where
loop x | x < 150 = do
putStr (show x ++ ",")
loop (x * 2)
loop _ = return ()
main = loop 1
where
loop x | x < 150 = do
putStr (show x ++ ",")
loop (x * 2)
loop _ = return ()
main = mapM_ print $ takeWhile (<150) $ iterate (* 2) 1
Perform an action multiple times based on a boolean condition, checked after the first action (DO .. WHILE)
Simulate rolling a die until you get a six. Produce random numbers, printing them until a six is rolled. An example output might be
"4,2,1,2,6"
haskell
import System.Random
diceRolls = do
gen <- newStdGen
print $ takeWhile (/=(6::Int)) (randomRs (1,6) gen)
diceRolls = do
gen <- newStdGen
print $ takeWhile (/=(6::Int)) (randomRs (1,6) gen)
Perform an action a fixed number of times (FOR)
Display the string
"Hello" five times like "HelloHelloHelloHelloHello"
haskell
import Control.Monad
hi5 = replicateM_ 5 $ putStr "Hello"
hi5 = replicateM_ 5 $ putStr "Hello"
Perform an action a fixed number of times with a counter
Display the string
"10 .. 9 .. 8 .. 7 .. 6 .. 5 .. 4 .. 3 .. 2 .. 1 .. Liftoff!"
haskell
countDown = mapM_ printN [10,9..1] >> putStr "Liftoff!"
where printN n = putStr $ show n ++ " .. "
where printN n = putStr $ show n ++ " .. "
Read the contents of a file into a string
haskell
readFile "c:/tmp/myFile.txt"
Process a file one line at a time
Open the source file to your solution and print each line in the file, prefixed by the line number, like:
1> First line of file
2> Second line of file
3> Third line of file
1> First line of file
2> Second line of file
3> Third line of file
haskell
import Data.List
prefixWithNumber str n = show n ++ "> " ++ str
numberStrings (x:xs) n = prefixWithNumber x n : (numberStrings xs (n+1))
numberStrings [] n = []
main = do
str <- readFile "prefix.hs"
putStrLn (intercalate "\n" (numberStrings (lines str) 1))
prefixWithNumber str n = show n ++ "> " ++ str
numberStrings (x:xs) n = prefixWithNumber x n : (numberStrings xs (n+1))
numberStrings [] n = []
main = do
str <- readFile "prefix.hs"
putStrLn (intercalate "\n" (numberStrings (lines str) 1))
prefix n str = show n ++ "> " ++ str
main = readFile "prefix.hs" >>=
putStr . unlines . zipWith prefix [1..] . lines
main = readFile "prefix.hs" >>=
putStr . unlines . zipWith prefix [1..] . lines
Write a string to a file
haskell
writeFile "filename" "stringe"
Append to a file
haskell
appendfile "filename" "string"
Process each file in a directory
haskell
import System.Directory
import Control.Monad
process filename = putStrLn filename
main = getDirectoryContents "." >>=
filterM doesFileExist >>=
mapM_ process
import Control.Monad
process filename = putStrLn filename
main = getDirectoryContents "." >>=
filterM doesFileExist >>=
mapM_ process
Process each file in a directory recursively
haskell
import System.Directory (doesFileExist, getDirectoryContents)
import System.FilePath ((</>))
process :: FilePath -> IO ()
process filename = putStrLn filename
mapDir :: (FilePath -> IO ()) -> FilePath -> IO ()
mapDir proc fp = do
isFile <- doesFileExist fp -- is a file of fp
if isFile then proc fp -- process the file
else getDirectoryContents fp >>=
mapM_ (mapDir proc . (fp </>)) . filter (`notElem` [".", ".."])
main = mapDir process "."
import System.FilePath ((</>))
process :: FilePath -> IO ()
process filename = putStrLn filename
mapDir :: (FilePath -> IO ()) -> FilePath -> IO ()
mapDir proc fp = do
isFile <- doesFileExist fp -- is a file of fp
if isFile then proc fp -- process the file
else getDirectoryContents fp >>=
mapM_ (mapDir proc . (fp </>)) . filter (`notElem` [".", ".."])
main = mapDir process "."
Display the current date and time
Create a Date object representing the current date and time. Print it out.
If you can also do this without creating a Date object you can show that too.
If you can also do this without creating a Date object you can show that too.
haskell
import System.Time
main = do ct <- getClockTime
print ct
main = do ct <- getClockTime
print ct
import Data.Time
main = do zt <- getZonedTime
print zt
main = do zt <- getZonedTime
print zt
Define a class
Declare a class named Greeter that takes a string on creation and greets using this string if you call the
"greet" method.
haskell
data Greeter = Greeter String
class Greets a where
greet :: a -> IO ()
instance Greets Greeter where
greet (Greeter s) = print s
main = greet (Greeter "Hello")
class Greets a where
greet :: a -> IO ()
instance Greets Greeter where
greet (Greeter s) = print s
main = greet (Greeter "Hello")
Instantiate object with mutable state
Reimplement the Greeter class so that the
For example, if the greetee is changed to
Hello, Tommy!
The getter would then be used to display the line:
I have just greeted Tommy.
'whom' property or data member remains private but is mutable, and is provided with getter and setter methods. Invoke the setter to change the greetee, invoke 'greet', then use the getter in displaying the line, "I have just greeted {whom}.".
For example, if the greetee is changed to
'Tommy' using the setter, the 'greet' method would display:
Hello, Tommy!
The getter would then be used to display the line:
I have just greeted Tommy.
haskell
data Greeter = G { greeting :: String, greetee :: String }
class Greets a where
greet :: a -> IO ()
instance Greets Greeter where
greet g = print (greeting g)
main = do
let g = G { greeting = "Hello", greetee = "{whom}" }
greet g
print $ "I have just greeted " ++ greetee g { greetee = "Tommy" }
class Greets a where
greet :: a -> IO ()
instance Greets Greeter where
greet g = print (greeting g)
main = do
let g = G { greeting = "Hello", greetee = "{whom}" }
greet g
print $ "I have just greeted " ++ greetee g { greetee = "Tommy" }
Implement Inheritance Heirarchy
Implement a Shape abstract class which will form the base of an inheritance hierarchy that models 2D geometric shapes. It will have:
* A non-mutable
* A
* A
* A non-mutable
'name' property or data member set by derived or descendant classes at construction time
* A
'area' method intended to be overridden by derived or descendant classes ( double precision floating point return value)
* A
'print' method (also for overriding) will display the shape's name, area, and all shape-specific values
Two derived or descendant classes will be created:
* Circle -> Constructor requires a 'radius' argument, and a 'circumference' method to be implemented
* Rectangle -> Constructor requires 'length' and 'breadth' arguments, and a 'perimeter' method to be implemented
Instantiate an object of each class, and invoke each objects 'print' method to show relevant details.
haskell
data Circle = C { namec :: String, radius :: Float }
data Rectangle = R { namer :: String, len :: Float, breadth :: Float }
circumference (C _ r) = 2 * pi * r
perimeter (R _ l b) = 2 * (l + b)
class Shape a where
area :: a -> Float
name :: a -> String
println :: a -> IO ()
instance Shape Circle where
area (C _ r) = pi * r * r
println c = print $ namec c ++ " : area = " ++
show (area c) ++ ", radius = " ++
show (radius c)
name (C n _) = n
instance Shape Rectangle where
area (R _ l b) = l * b
println r = print $ namer r ++ " : area = " ++
show (area r) ++ ", length = " ++
show (len r) ++ ", breadth = " ++
show (breadth r)
name (R n _ _) = n
main = do
let c = C { namec = "Circle", radius = 2.34 }
r = R { namer = "Rectangle", len = 3.4, breadth = 2.456 }
println c
println r
data Rectangle = R { namer :: String, len :: Float, breadth :: Float }
circumference (C _ r) = 2 * pi * r
perimeter (R _ l b) = 2 * (l + b)
class Shape a where
area :: a -> Float
name :: a -> String
println :: a -> IO ()
instance Shape Circle where
area (C _ r) = pi * r * r
println c = print $ namec c ++ " : area = " ++
show (area c) ++ ", radius = " ++
show (radius c)
name (C n _) = n
instance Shape Rectangle where
area (R _ l b) = l * b
println r = print $ namer r ++ " : area = " ++
show (area r) ++ ", length = " ++
show (len r) ++ ", breadth = " ++
show (breadth r)
name (R n _ _) = n
main = do
let c = C { namec = "Circle", radius = 2.34 }
r = R { namer = "Rectangle", len = 3.4, breadth = 2.456 }
println c
println r
Implement and use an Interface
Create a Serializable interface consisting of
* Accept a stream or handle or descriptor argument for the source or destination
* Save to destination or restore from source the properties or data members of the implementing class (restrict yourself to the primitive types
Next, create a Person class which has
'save' and 'restore' methods, each of which:
* Accept a stream or handle or descriptor argument for the source or destination
* Save to destination or restore from source the properties or data members of the implementing class (restrict yourself to the primitive types
'int' and 'string')
Next, create a Person class which has
'name' and 'age' properties or data members and implements this interface. Instantiate a Person object, save it to a serial stream, and instantiate a new Person object by restoring it from the serial stream.
haskell
import Data.Binary
import Control.Monad (liftM2)
data People = People { name :: String, age :: Integer }
deriving (Eq, Show)
class Serializable a where
save :: FilePath -> a -> IO ()
restore :: FilePath -> IO a
instance Serializable People where
save = encodeFile
restore = decodeFile
instance Binary People where
put (People n a) = put n >> put a
get = liftM2 People get get
main = do let fp = "people.dat"
p = People { name = "Joe", age = 24 }
save fp p
p' <- restore fp
print (p' :: People)
import Control.Monad (liftM2)
data People = People { name :: String, age :: Integer }
deriving (Eq, Show)
class Serializable a where
save :: FilePath -> a -> IO ()
restore :: FilePath -> IO a
instance Serializable People where
save = encodeFile
restore = decodeFile
instance Binary People where
put (People n a) = put n >> put a
get = liftM2 People get get
main = do let fp = "people.dat"
p = People { name = "Joe", age = 24 }
save fp p
p' <- restore fp
print (p' :: People)
Process an XML document
Given the XML Document:
<shopping>
<item name=
<item name=
</shopping>
Print out the total cost of the items, e.g. $14.50
<shopping>
<item name=
"bread" quantity="3" price="2.50"/>
<item name=
"milk" quantity="2" price="3.50"/>
</shopping>
Print out the total cost of the items, e.g. $14.50
haskell
File Edit Options Buffers Tools Haskell Help
import Text.ParserCombinators.Parsec
import Control.Monad
import System ( getArgs )
data Item = Item { name :: String,
quantity :: Int,
price :: Int }
deriving Show
type Basket = [Item]
item :: Parser Item
item = do string "<item name=\""
name <- manyTill letter (char '\"')
string " quantity=\""
quantity <- liftM read $ many digit
string "\" price=\""
dollars <- liftM read $ many digit
cents <- option 0 (char '.' >> (liftM read $ many digit))
string "\"/>"
return $ Item name quantity (100 * dollars + cents)
basket :: Parser Basket
basket = do string "<shopping>"
items <- manyTill item (try $ string "</shopping>")
return items
parseBasket :: String -> Basket
parseBasket input = case parse basket "Shopping Basket" input of
Left _ -> []
Right val -> val
main = do args <- getArgs
putStrLn $ show . (/100) . fromIntegral . sum . map (\(Item _ q p) -> q * p) . parseBasket $ head args
import Text.ParserCombinators.Parsec
import Control.Monad
import System ( getArgs )
data Item = Item { name :: String,
quantity :: Int,
price :: Int }
deriving Show
type Basket = [Item]
item :: Parser Item
item = do string "<item name=\""
name <- manyTill letter (char '\"')
string " quantity=\""
quantity <- liftM read $ many digit
string "\" price=\""
dollars <- liftM read $ many digit
cents <- option 0 (char '.' >> (liftM read $ many digit))
string "\"/>"
return $ Item name quantity (100 * dollars + cents)
basket :: Parser Basket
basket = do string "<shopping>"
items <- manyTill item (try $ string "</shopping>")
return items
parseBasket :: String -> Basket
parseBasket input = case parse basket "Shopping Basket" input of
Left _ -> []
Right val -> val
main = do args <- getArgs
putStrLn $ show . (/100) . fromIntegral . sum . map (\(Item _ q p) -> q * p) . parseBasket $ head args
import Text.XML.HXT.Core
import Text.Printf
main :: IO ()
main = do
prices <- runX (process "basket.xml")
printf "$%.2f\n" $ sum prices
process :: FilePath -> IOSArrow XmlTree Double
process filename =
readDocument [withValidate no] filename >>>
getChildren >>>
isElem >>> hasName "shopping" >>>
getChildren >>>
isElem >>> hasName "item" >>>
getQuantity &&& getPrice >>>
arr (uncurry (*))
getQuantity :: IOSArrow XmlTree Double
getQuantity =
getAttrl >>> hasName "quantity" >>> getChildren >>>
getText >>> arr read
getPrice :: IOSArrow XmlTree Double
getPrice =
getAttrl >>> hasName "price" >>> getChildren >>>
getText >>> arr read
import Text.Printf
main :: IO ()
main = do
prices <- runX (process "basket.xml")
printf "$%.2f\n" $ sum prices
process :: FilePath -> IOSArrow XmlTree Double
process filename =
readDocument [withValidate no] filename >>>
getChildren >>>
isElem >>> hasName "shopping" >>>
getChildren >>>
isElem >>> hasName "item" >>>
getQuantity &&& getPrice >>>
arr (uncurry (*))
getQuantity :: IOSArrow XmlTree Double
getQuantity =
getAttrl >>> hasName "quantity" >>> getChildren >>>
getText >>> arr read
getPrice :: IOSArrow XmlTree Double
getPrice =
getAttrl >>> hasName "price" >>> getChildren >>>
getText >>> arr read
Find all Pythagorean triangles with length or height less than or equal to 20
Pythagorean triangles are right angle triangles whose sides comply with the following equation:
a * a + b * b = c * c
where c represents the length of the hypotenuse, and a and b represent the lengths of the other two sides. Find all such triangles where a, b and c are non-zero integers with a and b less than or equal to 20. Sort your results by the size of the hypotenuse. The expected answer is:
a * a + b * b = c * c
where c represents the length of the hypotenuse, and a and b represent the lengths of the other two sides. Find all such triangles where a, b and c are non-zero integers with a and b less than or equal to 20. Sort your results by the size of the hypotenuse. The expected answer is:
[3, 4, 5]
[6, 8, 10]
[5, 12, 13]
[9, 12, 15]
[8, 15, 17]
[12, 16, 20]
[15, 20, 25]
haskell
import Data.List
import Control.Monad
pythTriangles :: [(Int,Int,Int)]
pythTriangles = do
a <- [1..20]
b <- [a+1..20]
c <- [1..2*b]
guard (a*a + b*b == c*c)
return (a,b,c)
cmpThird (_,_,a) (_,_,b)
| a < b = LT
| a == b = EQ
| otherwise = GT
main = mapM_ print (sortBy cmpThird pythTriangles)
import Control.Monad
pythTriangles :: [(Int,Int,Int)]
pythTriangles = do
a <- [1..20]
b <- [a+1..20]
c <- [1..2*b]
guard (a*a + b*b == c*c)
return (a,b,c)
cmpThird (_,_,a) (_,_,b)
| a < b = LT
| a == b = EQ
| otherwise = GT
main = mapM_ print (sortBy cmpThird pythTriangles)
import Data.Function
import Data.List
pythTriangles =
[(a,b,c) | a <- [1..20], b <- [a+1..20], c <- [1..2*b], a*a + b*b == c*c]
main = mapM_ print $ sortBy (compare `on` third) pythTriangles where
third (_,_,x) = x
import Data.List
pythTriangles =
[(a,b,c) | a <- [1..20], b <- [a+1..20], c <- [1..2*b], a*a + b*b == c*c]
main = mapM_ print $ sortBy (compare `on` third) pythTriangles where
third (_,_,x) = x
Greatest Common Divisor
Find the largest positive integer that divides two given numbers without a remainder. For example, the GCD of 8 and 12 is 4.
haskell
8 `gcd` 12
produces a copy of its own source code
In computing, a quine is a computer program which produces a copy of its own source code as its only output.
haskell
main = putStr (s ++ [';',' ','s',' ','=',' '] ++ show s); s = "main = putStr (s ++ [';',' ','s',' ','=',' '] ++ show s)
main = (\s -> putStrLn (s ++ show s)) "main = (\\s -> putStrln (s ++ show s)) "
Subdivide A Problem To A Pool Of Workers (No Shared Data)
Take a hard to compute problem and split it up between multiple worker threads. In your solution, try to fully utilize available cores or processors. (I'm looking at you, Python!)
Note: In this question, there should be no need for shared state between worker threads while the problem is being solved. Only after every thread completes computation are the answers recombined into a single output.
Example:
-Input-
(In python syntax)
In other words, a list of random strings.
-Output-
(In python syntax)
In other words, all possible permutations of each input string are computed.
Note: In this question, there should be no need for shared state between worker threads while the problem is being solved. Only after every thread completes computation are the answers recombined into a single output.
Example:
-Input-
(In python syntax)
["ab", "we", "tfe", "aoj"]
In other words, a list of random strings.
-Output-
(In python syntax)
[ ["ab", "ba", "aa", "bb", "a", "b"], ["we", "ew", "ww", "ee", "w", "e"], ...
In other words, all possible permutations of each input string are computed.
haskell
import Control.Parallel
import Control.Parallel.Strategies
allPerms xs = do
x <- [1 .. length xs]
sequence (replicate x xs)
result = parMap rdeepseq allPerms ["ab", "we", "tfe", "aoj"]
main = print $ concat result
{-
Compile with -threaded
-}
import Control.Parallel.Strategies
allPerms xs = do
x <- [1 .. length xs]
sequence (replicate x xs)
result = parMap rdeepseq allPerms ["ab", "we", "tfe", "aoj"]
main = print $ concat result
{-
Compile with -threaded
-}
Create a multithreaded "Hello World"
Create a program which outputs the string
Example:
-Output-
Thread one says Hello World!
Thread two says Hello World!
Thread four says Hello World!
Thread three says Hello World!
-Notice that the threads can print in any order.
"Hello World" to the console, multiple times, using separate threads or processes.
Example:
-Output-
Thread one says Hello World!
Thread two says Hello World!
Thread four says Hello World!
Thread three says Hello World!
-Notice that the threads can print in any order.
haskell
mapM_ (\x -> forkIO (putStrLn ("Thread " ++ x ++ " says Hello World!"))) ["one", "two", "three", "four"]
