Difference between revisions of "SML Practice Problems B"
Line 25: | Line 25: | ||
===number_passed=== | ===number_passed=== | ||
− | Using | + | Using <code>has_passed</code> as a helper function, write a function <code>number_passed</code> that takes a list of type <code>final_grade</code> (or a more general type) and returns how many list elements have passing (again, ≥75) grades. |
===number_misgraded=== | ===number_misgraded=== | ||
− | Write a function | + | Write a function <code>number_misgraded</code> of type <code>(pass_fail * final_grade) list -> int</code> that indicates how many list elements are "mislabeled" where mislabeling means a pair <code>(pass,x)</code> where <code>has_passed x</code> is false or <code>(fail,x)</code> where <code>has_passed x</code> is true. |
==Tree== | ==Tree== |
Revision as of 06:11, 24 September 2020
credit: Pavel Lepin and Charilaos Skiadas
Coursera Week 3 Extra Practice Problems
Contents
Code To Implement
file: | src/main/sml/practice2/practice2.sml | |
functions: | pass_or_fail has_passed number_passed number_misgraded ... |
Previous Practice Problems With Pattern Matching
Consider any of the extra Practice Problems from Section 1 and redo them using pattern matching.
Student Grades
Use these type definitions:
type student_id = int type grade = int (* must be in 0 to 100 range *) type final_grade = { id : student_id, grade : grade option } datatype pass_fail = pass | fail
Note that the grade might be absent (presumably because the student unregistered from the course).
pass_or_fail
Write a function pass_or_fail
of type {grade : int option, id : 'a} -> pass_fail
that takes a final_grade
(or, as the type indicates, a more general type) and returns pass
if the grade field contains SOME i
for an i≥75 (else fail
).
has_passed
Using pass_or_fail
as a helper function, write a function has_passed
of type {grade : int option, id : 'a} -> bool
that returns true
if and only if the the grade field contains SOME i
for an i≥75.
number_passed
Using has_passed
as a helper function, write a function number_passed
that takes a list of type final_grade
(or a more general type) and returns how many list elements have passing (again, ≥75) grades.
number_misgraded
Write a function number_misgraded
of type (pass_fail * final_grade) list -> int
that indicates how many list elements are "mislabeled" where mislabeling means a pair (pass,x)
where has_passed x
is false or (fail,x)
where has_passed x
is true.
Tree
Use these type definitions:
datatype 'a tree = leaf | node of { value : 'a, left : 'a tree, right : 'a tree } datatype flag = leave_me_alone | prune_me
tree_height
Write a function tree_height
that accepts an 'a tree
and evaluates to a height of this tree. The height of a tree is the length of the longest path to a leaf. Thus the height of a leaf is 0
.
sum_tree
Write a function sum_tree
that takes an int tree
and evaluates to the sum of all values in the nodes.
gardener
Write a function gardener
of type flag tree -> flag tree
such that its structure is identical to the original tree except all nodes of the input containing prune_me
are (along with all their descendants) replaced with a leaf.
List and Option
Re-implement various functions provided in the SML standard libraries for lists and options. See http://sml-family.org/Basis/list.html and http://sml-family.org/Basis/option.html. Good examples include last
, take
, drop
, concat
, getOpt
, and join
.
Natural Numbers
Use this type definition for natural numbers:
datatype nat = ZERO | SUCC of nat
A "natural" number is either zero, or the "successor" of a another integer. So for example the number 1 is just \verb|SUCC ZERO|SUCC ZERO, the number 2 is \verb|SUCC (SUCC ZERO)|SUCC (SUCC ZERO), and so on.
is_positive
Write \verb|is_positive : nat -> bool|is_positive : nat -> bool, which given a "natural number" returns whether that number is positive (i.e. not zero).
pred
Write \verb|pred : nat -> nat|pred : nat -> nat, which given a "natural number" returns its predecessor. Since 0 does not have a predecessor in the natural numbers, throw an exception \verb|Negative|Negative (will need to define it first).
nat_to_int
Write \verb|nat_to_int : nat -> int|nat_to_int : nat -> int, which given a "natural number" returns the corresponding \verb|int|int. For example, \verb|nat_to_int (SUCC (SUCC ZERO)) = 2|nat_to_int (SUCC (SUCC ZERO)) = 2. (Do not use this function for problems 13-16 -- it makes them too easy.)
int_to_nat
Write \verb|int_to_nat : int -> nat|int_to_nat : int -> nat which given an integer returns a "natural number" representation for it, or throws a \verb|Negative|Negative exception if the integer was negative. (Again, do not use this function in the next few problems.)
add
Write \verb|add : nat * nat -> nat|add : nat * nat -> nat to perform addition.
sub
Write \verb|sub : nat * nat -> nat|sub : nat * nat -> nat to perform subtraction. (Hint: Use \verb|pred|pred.)
mult
Write \verb|mult : nat * nat -> nat|mult : nat * nat -> nat to perform multiplication. (Hint: Use \verb|add|add.)
less_than
Write \verb|less_than : nat * nat -> bool|less_than : nat * nat -> bool to return \verb|true|true when the first argument is less than the second.
intSet
The remaining problems use this datatype, which represents sets of integers:
datatype intSet = Elems of int list (*list of integers, possibly with duplicates to be ignored*) | Range of { from : int, to : int } (* integers from one number to another *) | Union of intSet * intSet (* union of the two sets *) | Intersection of intSet * intSet (* intersection of the two sets *)
isEmpty
Write isEmpty : intSet -> bool
that determines if the set is empty or not.
contains
Write contains: intSet * int -> bool
that returns whether the set contains a certain element or not.
toList
Write toList : intSet -> int list
that returns a list with the set's elements, without duplicates.
Test
file: | unit_test_practice2.sml | |
source folder: | src/test/sml/practice2 |