haskell

Question 1

3.0 + 4

Answer 1

7.0

Question 2

8.0 / 2

Answer 2

4.0

Question 3

negation

Answer 3

not True

Question 4

or

Answer 4

False || True

Question 5

and

Answer 5

&&

Question 6

not equal

Answer 6

/=

Question 7

4 ways to concatenate. Hint: add, colon, colon tuple, colon all the way

Answer 7

[1,2,3] ++ [4,5] ⇒ [1,2,3,4,5]
[] ++ [1,2] ⇒ [1,2]

3 : [4,5] [3,4,5]
2 : (3 : (4 : [])) [2,3,4]
2 : 3 : 4 : [] [2,3,4]

Question 8

whats the type for ‘abc’

Answer 8

errro

Question 9

whats the output for ‘a’ ++ “bcd”

Answer 9

error

Question 10

write two ways to add a list of characters to a string.
hint: concat operator and colon.

Answer 10

“ab” ++ [‘c’,’d’]

Question 11

compare list of chars with a string. tell me whats the output

Answer 11

[‘X’, ‘Y’] == “XY” True

Question 12

write me a function that takes a and b and returns a list of a and b

Answer 12

listify a b = [a, b]

Question 13

write a two line recursie mylength function

Answer 13

myLength [] = 0
myLength (_:xs) = 1 + myLength xs

Question 14

write a are two lists equal recursive function considering edge cases

Answer 14

listEqual [] [] = True
listEqual (x:xs) (y:ys) = x == y && listEqual xs ys
listEqual [] (:) = False
listEqual (:) [] = False
(or listEqual _ _ = False and use the first-match-only behaviour.)

Question 15

write a even odd length function:

two ways:
- recursively
- using the even function

Answer 15

hasEvenLength [] = True – base case: length 0 is even
hasEvenLength [ _ ] = False – base case: length 1 is odd
hasEvenLength (_ : _ :rest) = hasEvenLength rest

or:
hasEvenLength xs = even (length xs)

Question 16

what are the 3 Rules for pattern matching:

Answer 16

plain identifier (argument name, like x): matches anything and captures the value.
_: matches anything but we don’t need the value.
literal value (like 1, [], etc): matches if equal.

Question 17

what are the 4 ways to match lists

hint:
match 0 elements
match 1,
match 2,
or match all of the rest of the elements

Answer 17

[]: matches an empty list.
[a]: matches a one-element list.
(a:tail): matches a list with at least one element. First is a, rest of list is tail (and could be an empty list).
(a:b:tail): matches a list with at least two elements. First is a, second is b, remainder of list is tail (could be empty).

Question 18

if we have (a:b:c), what is the result for the following arguments:
a b c
[6, 7, 8, 9]
[‘a’,’b’]
“ab”
[100]

Answer 18

6, 7, [8,9]
‘a’ ‘b’ []
‘a’ ‘b’ [] (==””)
[100]: ERROR

Question 19

write a simple mySigNum function using conditional

Answer 19

mySignum x
| x>0 = 1
| x<0 = -1
| otherwise = 0

Question 20

write using a case expression that matches 1, 2, 3 with their words, everything else with ????. and finally, concatenate it with “X”

Answer 20

wordWithX n = (case n of
1 -> “one”
2 -> “two”
3 -> “three”
_ -> “???”) ++ “X”

Question 21

write the describe llist function. concatenate “the list is “ with corresponding list length

Answer 21

describeList lst = “The list is “ ++ case lst of
_ : _ : _ : _ : _ -> “fairly long” – >= 4 elements
_ : _ -> “short” – >= 1 element
[] -> “empty”

Question 22

write a list comprehension for x^2+1 with x = 1 to 7

Answer 22

[ x^2+1 | x <- [1, 2, 3, 4, 5, 6, 7] ]

Question 23

use more than one generator to fwrite 10*x + y

Answer 23

[ 10*x + y | x <- [3,4,5], y <- [6,7,8,9]]

Question 24

create a list by using the even guard x in x^2+1

Answer 24

[ x^2+1 | x <- [1, 2, 3, 4, 5, 6, 7], even x ]

Question 25

build a list function

Answer 25

n = [ i*i | i <- [2,4..n]]

Question 26

write a quick sort example with where clause

Answer 26

qs [] = []

qs (x:xs) = smaller ++ [x] ++ larger
where smaller = qs [a | a<-xs, a<=x]
larger = qs [a | a<-xs, a>x]

Question 27

write a quick sort example in one line with list comprehension

Answer 27

qs (x:xs) = qs [a | a <- xs, a <= x] ++ [x] ++ qs [a | a <- xs, a > x]

Question 28

write quicksort it with let clause:

Answer 28

BASE CASE
qs’ [] = []
qs’ (x:xs) =
let smaller = qs’ [a | a<-xs, a<=x]
larger = qs’ [a | a<-xs, a>x]
in smaller ++ [x] ++ larger

Question 29

write a simple myPower recursive function

Answer 29

myPower _ 0 = 1
myPower x y = x * myPower x (y-1)

Question 30

write an OlogN myPower’ using conditional

Answer 30

myPower’ x y
| y==0 = 1
| even y = halfhalf
| odd y = xhalf*half
where half = myPower’ x (div y 2)

Question 31

whats the flag to optimize haskell code

Answer 31

ghc -O2

Question 32

write tail recursive my power

Answer 32

myPowerTailRec a _ 0 = a
myPowerTailRec a x y = myPowerTailRec (x*a) x (y-1)

Question 33

write complete tail recursive factorial function with where clause

Answer 33

factorial’ n = factorialTailRec 1 n
where
factorialTailRec a 0 = a
factorialTailRec a n = factorialTailRec (n*a) (n-1)

Question 34

what overhead does tail recursion avoid

Answer 34

overhead of maintaining the call stack

Question 35

write a function that takes n nums from list, use split function

split :: Int -> [Int]

Answer 35

myTake n xs: start
where (start, _) = split n xs

Question 36

write a myGCD function

Answer 36

myGCD 0 b = b
myGCD a 0 = a
myGCD a b = gcd b r
Where (q,r) = a divMod b

Question 37

filter even numbers from a list using the even function and filter

Answer 37

Filter even [1..8]

Question 38

filter even numbers from a list using list comprehension

Answer 38

[ n | n <- [1..8], even n]

Question 39

map sqrt to a list

Answer 39

map sqrt [1..8]

Question 40

map sqrt to a list with list comprehension

Answer 40

[ sqrt n | n <- [1..8]]

Question 41

give me an example of foldr

Answer 41

foldr (+) 0 [1,2,34,5]

Question 42

know how to user foldl

Question 43

write the operators that you can perform on for these type classes:
​​Ord:
Num:
Integral:
Fractional:
Show:
Enum:

Answer 43

​​Ord: Eq plus can be ordered ((<), (>=), min, …).
Num: Number-like things ((+), (*), abs, …).
Integral: Integer-like things (div, mod, …).
Fractional: Num plus true division ((/), recip).
Show: can be converted to a string for display.
Enum: has previous/​next elements (pred, succ)

Question 44

what is Join / intercalate.
give an example

Answer 44

join is actually a function that takes a String and returns a function [String] -> String.

let words = [“Hello”, “World”]
putStrLn $ intercalate “ “ words

Question 45

implement comajoin on a list

Answer 45

commajoin :: [String] -> String
commajoin = join “, “

Question 46

what is map sqrt someList equivalent to

Answer 46

(map sqrt) someList

Question 47

what are equivalent calculations for this: div 10 2

Answer 47

Prelude> (div 10) 2
5

Know that this works:
Prelude> let d10=(div 10) in d10 2
5

Question 48

implement myConcat using foldl

myConcat :: [[a]] -> [a]

Answer 48

myConcat :: [[a]] -> [a]
myConcat xs = foldl (++) [] xs

myConcat’ :: [[a]] -> [a]
myConcat’ = foldl (++) []

Question 49

write a divors function, that returns a list of nums from 2 to n using filter

use the following type
divisors :: Integral a => a -> [a]

Answer 49

divisors n = filter (divides n) [2..(n div 2)]
where divides a b = (a mod b) == 0

Question 50

write function as argument with operators for (/) operator using map

Answer 50

Prelude> map (12/) [6,2,12]
[2.0,6.0,1.0]
Prelude> map (/12) [6,2,12]
[0.5,0.16666666666666666,1.0]

Question 51

curry and uncurry on div

Answer 51

addPair :: (Int, Int) -> Int
addPair (x, y) = x + y

addCurried :: Int -> Int -> Int
addCurried = curry addPair

*Main> (uncurry div) (10,2)
5
*Main> (curry myDiv) 10 2
5

(uncurry (+)) (2, 4)

Question 52

how do you zip these two elements and what is the output:
[1,2,3] [‘a’,’b’,’c’]

Answer 52

*Main> zip [1,2,3] [‘a’,’b’,’c’]
[(1,’a’),(2,’b’),(3,’c’)]

Question 53

implement a unzip function that takes two arrays and adds them together. hint: use zip and uncurry

Answer 53

addPairwise :: Num a => [a] -> [a] -> [a]
addPairwise xs ys = map (uncurry (+)) (zip xs ys)

addPairwise [1,2,3] [4,5,6]
== map (uncurry (+)) (zip [1,2,3] [4,5,6])
== map (uncurry (+)) [(1,4), (2,5), (3,6)]
== [(uncurry (+)) (1,4), (uncurry (+)) (2,5), (uncurry (+)) (3,6)]
== [(+) 1 4, (+) 2 5, (+) 3 6]
== [5, 7, 9]

Question 54

write function composition examples, for hailLen

Answer 54

hailLen = length . hailSeq
meaning:
hailSeq on n
then length on hailSeq n

Question 55

what does intercalate do

Answer 55

import Data.List (intercalate)

example1 = intercalate “, “ [“apple”, “banana”, “orange”]
– Output: “apple, banana, orange”

example2 = intercalate “ | “ [“Haskell”, “is”, “fun”]
– Output: “Haskell | is | fun”

example3 = intercalate “” [“a”, “b”, “c”, “d”, “e”]
– Output: “abcde”

Question 56

what does flip do

Answer 56

In this example, flip intercalate flips the order of the arguments for the intercalate function

example1 = flip (-) 5 3
– Output: -2

example2 = flip (++) “world” “hello, “
– Output: “hello, world”

example3 = flip const 42 “ignored”
– Output: 42

Question 57

write a function composition example for join primes where it joins prime numbers up to 11 with a string

hint use flip

Answer 57

joinPrimes :: String -> String
joinPrimes = (flip intercalate) [“2”, “3”, “5”, “7”, “11”]

or
joinPrimes = flip intercalate [“2”, “3”, “5”, “7”, “11”]

Question 58

write a myReverse function

Answer 58

myReverse :: [a] -> [a]
myReverse [] = []
myReverse (x:xs) = myReverse xs ++ [x]

Question 59

write a half of lambda function

Answer 59

half_of’ :: Float -> Float
half_of’ = \x -> x/2

Question 60

write a addToEach function using lambda

Answer 60

addToEach :: Num a => a -> [a] -> [a]
addToEach n lst = map (\x -> x+n) lst

Question 61

write comma join using lambda, partial function, and normal function

Answer 61

commajoin0, commajoin1, commajoin2 :: [String] -> String
commajoin0 = \xs -> join “, “ xs
commajoin1 = join “, “
commajoin2 xs = join “, “ xs

Question 62

what is a thunk

Answer 62

Thunk: represents the calculation that could happen

Question 63

what does this evaluate:
Prelude> fst (1+2, 3+4)
Prelude> fst (1+2, [1..])

Answer 63

Prelude> fst (1+2, 3+4)
3
Prelude> fst (1+2, [1..])
3

Question 64

implement a myTake function recursively

Answer 64

myTake 0 _ = []
myTake n (x:xs) = x : myTake (n-1) xs
myTake 2 [1..]
== take 2 (1:[2..]) – arg 2 matches x:xs?
== 1 : take (2-1) [2..] – recursive case
== 1 : take 1 [2..] – arg 1 matches 0?
== 1 : take 1 (2:[3..]) – arg 2 matches x:xs?
== 1 : 2 : take (1-1) [3..] – recursive case
== 1 : 2 : take 0 [3..] – arg 1 matches 0?
== 1 : 2 : [] == [1, 2] – base case

Question 65

how do you combine element with array

Answer 65

list = 1 : [2, 3, 4, 5]
– Output: [1, 2, 3, 4, 5]

Question 66

write a function that duplicates the first element in the list
[1,2,3]
output:
[1,1,2,3]

Answer 66

duplicateFirst :: [a] -> [a]
duplicateFirst [] = []
duplicateFirst (x:xs) = x : x : xs

Question 67

write a prepend to all function that gives the following input ouptut
prependToAll 0 [1, 2, 3, 4, 5]
– Output: [0, 1, 0, 2, 0, 3, 0, 4, 0, 5]

use map

Answer 67

prependToAll :: a -> [a] -> [a]
prependToAll x xs = map (x:) xs

Question 68

do thunk analysis on this:
foldl (+) 0 [1,2,3]

Answer 68

foldl (+) 0 [1,2,3]
== foldl (+) (0+1) [2,3]
== foldl (+) ((0+1)+2) [3]
== foldl (+) (((0+1)+2)+3) []
== ((0+1)+2)+3
== (1+2)+3
== 3+3
== 6

Question 69

what is the symbol to force non lazy evaluation

Answer 69

force strict evaluation with $! Operator

Question 70

write a non lazy myPowerTailRec as myPowerTailRecStrict using $!

Answer 70

myPowerTailStrict a _ 0 = a
myPowerTailStrict a x y = (myPowerTailStrict $! (a*x)) x (y-1)

Question 71

what does Seq a b do

Answer 71

returns b, but forces strict evaluation of a. It can be used like this to force a let/​where value to be strictly evaluated:

Question 72

write an example myPower with seq a b and where clause

Answer 72

myPowerSeq a _ 0 = a
myPowerSeq a x y = seq newacc (myPowerSeq newacc x (y-1))
where newacc = a*x

or:
myPower a _ 0 = a
myPower a x n = myPower (a seq a*x) x (n-1)

Question 73

write the equivalent of
myPowerTailStrict a _ 0 = a
myPowerTailStrict a x y = (myPowerTailStrict $! (a*x)) x (y-1)

using seq

Answer 73

myPowerSeq a _ 0 = a
myPowerSeq a x y = seq newacc (myPowerSeq newacc x (y-1))
where newacc = a*x

Question 74

write this using the $ notation
funnyDivisors n = map pred (divisors (n*2))

Answer 74

funnyDivisors n = map pred $ divisors $ n*2

Question 75

what is the difference between $ vs (.)

Answer 75

Note: ($) combines a function and an argument; (.) combines two functions

Question 76

write the following function using the (.) notation:
funnyDivisors n = map pred (divisors (n*2))

Answer 76

funnyDivisors’’ n = (map pred) . divisors . (* 2) $ n
or
funnyDivisors’’’ = (map pred) . divisors . (* 2)

Question 77

what is the (.) notation called

Answer 77

composite function

Question 78

what is the $ notation called

Answer 78

function application operator

Question 79

what is a free variable

Answer 79

A free variable is any value used that isn’t a function argument.

Question 80

what are two pure function properties

Answer 80

1 was a slight lie: function results depend on their arguments and free variables. A free variable is any value used that isn’t a function argument.

Given the same arguments, they always return the same results.
They have no side effects: do not modify the external state of the program.

Question 81

what enables lazy evaluation in haskell?

Answer 81

Purity is what allows lazy evaluation. Haskell can choose to calculate a value or not since there are no side effects to worry about.

Question 82

what does pseq do and what does it stand for

Answer 82

pseq a b: like seq but evaluates a before returning b.

Question 83

what is the difference between seq, pseq, and par

Answer 83

seq (short for “sequence”) is used to control the order of evaluation. The expression seq a b first evaluates a, then b, and finally returns the value of b. If a is a large data structure, then seq can be used to force that structure to be evaluated, avoiding the creation of a large number of thunks (a thunk in Haskell is a data expression that has not been evaluated yet).

par (short for “parallel”) introduces parallelism. The expression par a b “sparks” off a to potentially run in parallel with b, and returns b. This doesn’t guarantee that a will be evaluated in parallel, but it’s a hint to the runtime system that it could be beneficial to do so.

pseq (short for “parallel sequence”) is a combination of par and seq. The expression pseq a b evaluates a before b, like seq, but also arranges that a is evaluated in parallel with the current computation, like par.

Question 84

what does par do

Answer 84

par a b: evaluate a and b concurrently, and return b.

Question 85

what is the typical usage for par

Answer 85

Typical usage: use these to express do A and B in parallel and then combine them.

Question 86

how to enable parallel execution in command line

Answer 86

ghc -O2 -with-rtsopts=”-N8” -threaded concurrent1.hs

Question 87

how to calculate this in parallel

calcA = a + b
where a = calculation 1
b = calculation 2

Answer 87

calcB = (a par b) pseq (a + b)
where a = calculation 1
b = calculation 2

Question 88

how to run this in parallel
calcC = map slowCalc [0..100]

Answer 88

calcD = parMap rseq slowCalc [0..100]

Question 89

is parallel always faster?

Answer 89

Example 3: breaking the problem down too small will cause too much overhead when coordinating threads
Breaking the problem into chunks that are too small causes overhead coordinating threads. e.g. these take about the same amount of time to complete:
Too small: too much overhead starting/​stopping/​communicating. Too big: not enough parallelism.
calcE = map fastCalc [0..1000000]
calcF = parMap rseq fastCalc [0..1000000]

Question 90

what are the two operations a monad must do

Answer 90

Wrap and unwrap its values (e.g. convert between 2 and Just 2)
Chain together operations from one monad value to another.

The return function wraps a non-monad value in the appropriate monad

Question 91

explain this in 4 steps:
(»=) :: (Monad m) => m a -> (a -> m b) -> m b

Answer 91

It takes the result of the previous step (of type m a);
unwraps it automatically (to type a);
a function takes the unwrapped value and produces the result of this step (a function a -> m b);
The m b is the result of this step.

Question 92

write this:
secondLine :: IO String
secondLine = do
line1 <- getLine
line2 <- getLine
return line2

with:
- function unwrapping and without the return value
- and the&raquo_space;= expression

Answer 92

secondLine’ :: IO String
secondLine’ =
getLine > > = (\ line1 -> getLine > > = (\ line2 -> return line2))

secondLine’’ :: IO String
secondLine’’ = do
line1 <- getLine
getLine

Question 93

what does (»=) do

(»=) :: Monad m => m a -> (a -> m b) -> m b

Answer 93

And then (»=):
Basically joins the do notation

Question 94

write a function that takes 3 elements as argument that you want to find in a list of elements w

Answer 94

findElt

findThree :: Eq a => a -> a -> a -> [a] -> Maybe (Int, Int, Int)
findThree v1 v2 v3 xs = do
pos1 <- findElt v1 xs
pos2 <- findElt v2 xs
pos3 <- findElt v3 xs
return (pos1, pos2, pos3)
*Main> findThree 1 2 3 [1,6,2,5,3,4]
Just (0,2,4)
*Main> findThree 1 2 3 [1,6,2,5,4]
Nothing

Question 95

what is the function to generate random seed

Answer 95

newStdGen :: IO StdGen

Question 96

write a function that generates three random values

Answer 96

threeRand’ :: IO [Int]
threeRand’ = do
gen0 <- newStdGen
let
(rand0, gen1) = randomR (1, 100) gen0
(rand1, gen2) = randomR (1, 100) gen1
(rand2, _) = randomR (1, 100) gen2
return [rand0, rand1, rand2]

Question 97

return a list of 3 int values by generating an infinite list with randomRs

Answer 97

threeRand’’ :: IO [Int]
threeRand’’ = do
gen0 <- newStdGen
return $ take 3 $ randomRs (1, 100) gen0

Question 98

generate random values within range min max and take n elements from it

use this type
randInts :: Int -> Int -> Int -> IO [Int]

Answer 98

import System.Random
– generate n random integers
– make sure the get the type right
randInts :: Int -> Int -> Int -> IO [Int]
randInts n minval maxval = do
gen <- newStdGen
return $ take n $ randomRs (minval, maxval)