Haskell

Question 1

let

Answer 1

Defines a function

let original = 2
let add x y = x + y

Other way:
let a = 1 in a + a
let a = 2; b = 4 in a * b

Question 2

map

Answer 2

Map is a name of a higher-order function that applies a given function to each element of the list, returning a list of results.

let number = [2, 4 , 6]
map (+3) numbers = [5, 7, 9]

map (\x -> x*x) [1..5]
map function list

Question 3

Filter

Answer 3

Filter is the name of a higher-order function that processes a data structure, typically a list, in some order to produce a new data structure containing those exact elements of the original data structure that match a given condition.

let numbers = [25,9,(-20),100,16,(-2)]
filter (<16) numbers = shows numbers below 16

filter f (x:xs)
|f x = x : rest
|otherwise = rest
where rest = filter f xs

square_even :: [Int] -> [Int]
square_even list = map (^2) (filter even list)

Question 4

Fold

Answer 4

Reduce/Fold is the name of a higher-order function which reduces a list of values to a single value by repeatedly applying a combining function to the list values.

numbers = [2, 4, 6]
foldl (+) 0 numbers = adds all numbers including 0 from left to right.

sum’’ list = foldr (\ x acc -> acc + x) 0 list

Acc:
Actuator -> acc = 0 , then becomes 0 + whatever is on the right of the list

foldr1 = uses the last element in the list as the accumulator
foldr1 cannot change the type of the list

Question 5

Side Effect

Answer 5

A side effects is anything that changes global state. This means that is could change a variable, a console etc, in which pure functions disallow things like prints, loops and variables. No control flow either, like if statements, because that makes the result indeterministic.

Question 6

Pure Function

Answer 6

A functions with NO SIDE EFFECTS, meaning it is DETERMINISTIC and ALWAYS RETURNS A VALUE.

Question 7

Subroutine

Answer 7

They predominately have side effects. These subroutines that have side effects cause issues for code refactoring, complier designers, optimization and parrelization.

Question 8

**

Answer 8

Float (square)

Answer 9

Integer (square)

Question 10

&&
||

Answer 10

AND statement
OR statement

Question 11

Not

Answer 11

Gives opposite for boolean

Question 12

==

Answer 12

Equality testing

Question 13

/=

Answer 13

Not equal

Question 14

Negatives

Answer 14

Must be in brackets

Question 15

Priority

Answer 15

Functions

Question 16

mod

Answer 16

Remainder

Question 17

``

Answer 17

Allows function to become infix

Question 18

Brackets

Answer 18

Allows add and sub to become prefix

Question 19

Succ

Answer 19

Successor

Question 20

::

Answer 20

Has type
:t True
True :: Bool

Question 21

– and {–}

Answer 21

Allows comments

Question 22

Show

Answer 22

Turn anything into a string

Question 23

putStrLn

Answer 23

Prints

Question 24

If

Answer 24

If True then 1 else 0, both branches must exist.

Question 25

Lists

Answer 25

Contain items that all have the same type.
[]
They are linked (go through everything from the beginning)
Last, Init, Head, Tail
: = puts new head on (1: [2,3,4,5])
!! = index of list

Question 26

Tuples

Answer 26

Allows us to bind two or move values together
Can contain different types
()
Fixed length

Question 27

Range

Answer 27

[1..10]

Question 28

Step Size

Answer 28

[2,4..20]
Would give = [2,4,6,8,10 etc]
Counting downwards always needs a step size.

Question 29

take 4 [1..]

Answer 29

Infinite list, but returns the first four.

Question 30

Repeat and Cycle

Answer 30

Repeats the input and repeats the list.

Question 31

List Comprehension

Answer 31

Can produce more complex lists:
[ 2*x |x <- [1,2,3,4]] = [2,4,6,8]

Question 32

Predicates

Answer 32

[2*x | x <- [1,2,3,4], x<2] = [2]
Using commas to filter results.

Question 33

List Comprehension : Upper Case

Answer 33

st [c | c <- st, c ‘elem’ [‘A’…‘Z’]]

Question 34

List Comprehension : Prime Numbers With Factorials

Answer 34

factors n = [x | x <- [1..n], n mod x == 0]

prime n = [x | x <- [1..n], length (factors x) == 2] (only got 2 factors)

Question 35

Recursion

Answer 35

factorial n = if n > 1
then n * factorial (n-1)
else 1
Base case - not making recursive rule (else 1)

Another way:
factorial 1 = 1
factorial n = n * factorial (n-1)

Question 36

Guards

Answer 36

Guards:
f x
| x < 1 = “strictly less”
| x > 1 = “strictly more”
| otherwise = “other”
n == 1 = 1 - used for guards (format)

Question 37

Recursion With Lists

Answer 37

sum’ [] = 0 - base case
sum’ (x:xs) = x + sum’ xs

Question 38

Where

Answer 38

f x = x + a
where a = x + 1
Defines a
Difference between where and let is that let can be used multiple times.

Question 39

Zip’

Answer 39

zip’ takes two lists and returns a list of pairs
zip [1..10]”hello there”
[1,h][2,e] etc.

Question 40

Mutual Recursion

Answer 40

even’ 0 = True
even’ n = odd’ (n-1)
odd’ = False
odd’ n = even’ (n-1)
Recursive methods that call each other.

Question 41

Multiple Recursion

Answer 41

fib 0 = 0
fib 1=1
fib n = fib (n-1) + fib (n-2)
Multiple recursions in one line.

Question 42

Quicksort

Answer 42

Sorts elements in a list.
pivot element p
lower = all elements smaller than p
upper = all element larger than p
return sorted_lower ++ [p] ++ sorted_upper
split pivot [] = ([],[])
split pivot (x;xs) etc etc. (x lower or higher)
qs [] = []
qs (x:xs) = qs lower ++ [x] ++ qs upper
where (lower,upper) = split x xs

Question 43

:t

Answer 43

Will display the type
:t True = True :: Bool

is_lower c = c elem [a…z]
:t is_lower = char -> bool

Question 44

Int
Integer
Double

Answer 44

Holds 64-bit but faster
Holds arbitrary but slower
Holds 64-bit float

Question 45

Partial Application

Answer 45

plus a b = a+b
alternative:
plus2 = plus 1
plus2 2 = 3
Also known as currying

Question 46

Polymorphism

Answer 46

:t length
length :: [a] -> int
Works on all lists that have different types.
[function name] :: [type]

Question 47

fst

Answer 47

Returns first element of two ; tuple

Question 48

snd

Answer 48

Returns second element of two ; tuple

Question 49

:t take

Answer 49

take :: Int -> [a] -> [a]

Question 50

Difference between : and ++

Answer 50

++ takes two lists, : takes a single value

Question 51

:info …

Answer 51

Tells information on function.

Question 52

:t (+)

Answer 52

(+) = Num a => a -> a -> a
if you give two a’s which are equal to Num a, then return a

Question 53

f (x, y) = (x+1, y==2)
:t f

Answer 53

(eq a1, num a2, num a1) => ((the inputs)a2,a1) -> ((the results)a2, bool)

Question 54

General Type Annotations

Answer 54

The most general type annotation is the one that is least restrictive:
equals_two a b = a + b == 2
equals_two :: (Eq a, Num a) => a -> a -> bool

Question 55

fromIntegeral

Answer 55

Convert back to a more generic type.

Question 56

Show and Read

Answer 56

Show = converts other types into strings
Read = converts strings into other types

Question 57

x = [take 1, length] -> why does this not work?

Answer 57

Doesn’t work since they are different types ; take returns a list, length returns an integer

Question 58

Dot Operator

Answer 58

((+1) . (*2)) 4 -> dot operator
Use of dot operator removes the need for nested brackets.

Question 59

$

Answer 59

Used to evaluate the input.

Question 60

Anonymous Function

Answer 60

(\ x -> x+1) 5 -> this is an anonymous function; a function that has no name. This is meant to represent lambda.

Question 61

Scan

Answer 61

Like Fold, but prints the accumulator each time:

scanr (+) 0 [1,2,3,4]
[10,9,7,4,0]

scan1 (+) [1..10]
[0,1,3,6,10,15,21,28,36,45,55]

Question 62

Takewhile

Answer 62

Takes from a list while a condition is true

takeWhile (<=5) [1..10]
[1,2,3,4,5]

Question 63

Dropwhile

Answer 63

dropWhile drops from a list while a condition is true

dropWhile (==1) [1,1,2,2,3,3]
[2,2,3,3]

Question 64

Zipwith

Answer 64

Zips two lists using a function

zipWith (+) [1,2,3] [4,5,6]
[5,7,9]

Question 65

Type

Answer 65

type String’ = [char]
… :: String’ -> String’

type VoteResults = [(Int, String)]
results :: VoteResults
results = [(1, “Red”), …]

Question 66

Data

Answer 66

data Bool’ = True | False

data Direction = North | East | South | West deriving Show
Adds Direction to show, since Direction is not part of a class at the beginning
Show, Read, Eq, Ord = all derivable : deriving (Show, Read, Eq, Ord)

data TwoThings = Things Int Char deriving Show
f (Things x _ ) = x
f (Things 2 ‘a’) = 2

= or

Question 67

Record

Answer 67

Record Type:
data Person = Person String String Int String
get_first_name (Person x _ _ _) = x etc…
Record Type 2:
data Blah = Blah { one :: Int, two :: Char } deriving Show

Question 68

Difference between pattern matching lists and tuples

Answer 68

Lists = (s:s)
Tuples = (s,s)

Question 69

Use foldr to write a function product of evens that takes a list of
numbers, and multiplies all the even elements together.
Use foldr to write a function lt10 that takes a list of numbers and
returns the number of elements that are strictly less than 10.

You HAVE to use acc.

Answer 69

product_of_evens list = foldr (\ x acc -> if even x then x * acc else
acc) 1 list

lt10 list = foldr (\ x acc -> if x < 10 then 1 + acc else acc) 0 list

Question 70

Maybe, Just, and Nothing

Answer 70

data Maybe a = Just a | Nothing
safe_head [] = Nothing
safe_head (x:_) = Just x

Question 71

Case

Answer 71

h = safe_head list
case h of Just x -> x
Nothing -> 0

f x = case x of (x:xs) -> x
[] -> 0

Question 72

Either’

Answer 72

data Either’ a b = Left a | Right B

ghci> let list = [Left “one”, Right 2,
Left “three”, Right 4]

is_left (Left _) = True
is_left _ = False

Question 73

map unleft unright list *

Answer 73

Cannot be done as trying to combine two lists that contain different values will lead to an error.

Question 74

Recursive Data Types

Answer 74

data IntList = Empty | Cons Int IntList deriving(Show)
Cons 4 ( Cons 5 ( Cons 6 Empty)))

data a = Empty | Cons a (List a) deriving(Show)
Cons “hi” Empty

data TwoList a b = TwoEmpty
|ACons a (TwoList a b)
|BCons b (TwoList a b)
deriving(Show)

Question 75

Tree Search with Recursive Data Types

Answer 75

data TwoList a b = TwoEmpty
|ACons a (TwoList a b)
|BCons b (TwoList a b)
deriving(Show)

data Tree = Leaf | Branch Tree Tree deriving(Show)
size :: Tree -> Int
size (Leaf) = 1
size (Branch x y) = 1 + size x + size y

data DTree = DLeaf a | DBranch a (DTree a) (DTree a) deriving(Show)
tree_sum :: Num a => DTree a -> a
tree_sum (DLeaf x) = x
tree_sum (DBranch x l r) = x + tree_sum l + tree_sum r

Question 76

getLine

Answer 76

Reads an input line from the console (input) ; requires an IO String
:t -> getLine :: IO String

Question 77

putStrLn

Answer 77

Takes a string and prints out hi (print) ; requires a pure string
:t :: String -> IO ()

Question 78

getChar

Answer 78

Gives back a char from input char

Question 79

Conc two strings together via two inputs

Answer 79

print_two :: String -> String -> IO ()
print_two s1 s2 = putStrLn (s1 ++ s2)

Question 80

do / do blocks

Answer 80

Allows sequence of actions followed by an IO ; only works with IO.
get_and_print :: IO ()
get_and_print =
do
x <- getLine
y <- getLine
putStrLn (x ++ “ “ ++ y)

Question 81

return

Answer 81

Takes a pure value and returns the value in an IO box ; used for “do nothing”.
Return, in functional programming, does NOT stop the program running.
print_if_short :: String -> IO ()
print_if_short str =
if length str <= 2
then putStrLn str
else return ()
:: Monad m => a -> m a

Question 82

Mutual Recursion

Answer 82

Two functions which call upon one another.

Question 83

Multiple Recursion

Answer 83

Makes more than one recursive call in the actual function line.

Question 84

Tail Recursion

Answer 84

Nothing left to do once the function has made the recursive call.

Question 85

Lazy Evaluation

Question 86

List recursion

Answer 86

A recursion using lists.