CS 136 Elementary Algorithm Design and Data Abstraction - University of Waterloo Sample Final Examin

downloaded from

Scholarfriends

https://scholarfriends.com Downloaded by: writerforacademic@gmail.com | https://scholarfriends.com/singlePaper/312338/cs-136-elementary-algorithm-design-anddata-abstraction-university-of-waterloo-sample-final-examin Distribution of this document is illegal.

University of Waterloo Sample Final Examination Identifying information will be CS 136 printed here.

Term: Winter

Date: Time: Duration: Sections: Instructors:

Year: 2015

Take Home 001–008 -----

Student Signature: UW Student ID Number:

Number of Exam Pages (including this cover sheet)

23 pages

Exam Type

Closed Book

Additional Material Allowed

NO ADDITIONAL MATERIALS ALLOWED

Marking Scheme (for graders’ use only) Question Max Score Grader

Question

Max

1

8

6

10

2

6

7

10

3

6

8

10

4

35

9

15

5

6

10

25

Maximum Total Score: 131

Total Score:

Score

Grader

Instructions: Exam instructions.

CS 136 Sample Final Examination

Winter 2015

Page 2 of 23

1. (8 points) Multiple Choice: circle the most correct answer. (a) (2 points) What strategy can we use to amortize our run-time when dynamically allocating memory? a. Wrapper Strategy b. Functional Strategy c. Augmentation Strategy d. Doubling Strategy

(b) (2 points) What is the difference between a C string and an array of chars in C? a. C strings are always stored in read-only memory, whereas an array of chars do not have this restriction. b. An array of chars cannot be initialized using the double quote syntax (i.e. char a[] = "Hello, World"). c. An array of chars stores its length. d. C strings are null terminated. e. There is no difference.

(c) (2 points) Which approach permits us to write an O(1) add_to_back function for a singly linked list? a. Use the augmentation strategy. b. Use recursion in our add_to_back function. c. Use iteration in our add_to_back function. d. Use the wrapper strategy.

CS 136 Sample Final Examination

Winter 2015

Page 3 of 23

(d) (2 points) What approach would be able to determine the height of the BST in O(1) time? a. Augment the BST node to store the height of the subtree and increase it during each insertions. b. Recurse through the longest subtree. c. Count the number of items store in the tree, returning log2 (n) + 1 where n is the number of items stored. d. It is not possible to implement a O(1) height function for a BST.

CS 136 Sample Final Examination

Winter 2015

Page 4 of 23

2. (6 points) Multiple Choice: Select the appropriate ADT. (a) (2 points) A movie theatre has created a points card, which allows frequent customers to gain movie points every time they buy a ticket. They need to keep track of how many points each customer has. Which ADT would be best suited for the task? a. Queue b. Stack c. Dictionary d. Set

(b) (2 points) A web browser keeps track of the order in which you visit websites, and allows you to go back to previous pages in the reverse order you visited them. Which ADT should be used to store the pages? a. Queue b. Stack c. Dictionary d. Set

(c) (2 points) You have been hired by a popular online store which sells merchandise to write software to keep track of their orders. They would like to complete their orders on a first-come-first-served basis; that is, orders are processed in the order in which they are received. Which ADT should you use for this? a. Queue b. Stack c. Dictionary d. Set

CS 136 Sample Final Examination

Winter 2015

Page 5 of 23

3. (6 points) Multiple Choice: circle the answer with the lowest correct upperbound. Consider the runtime in the worst case. (a) (2 points) What is the runtime of the following function in terms of n, where n is the length of lon? (define (list-max lon) (cond [(empty? lon) -inf.0] [(> (first lon) (list-max (rest lon))) (first lon)] [else (list-max (rest lon))])) a. O(n) b. O(n2 ) c. O(2n ) d. O(n log n)

(b) (2 points) What is the runtime of the following function in terms of n, where n is the string length of str? char lastletter(char *str) { char retval = '\0'; for (int i = 0; i < strlen(str); i++) { if (((str[i] >= 'a') && (str[i] <= 'z')) || ((str[i] >= 'A') && (str[i] <= 'Z'))) { retval = str[i]; } } }

return retval;

a. O(1) b. O(log n) c. O(n) d. O(n2 )

CS 136 Sample Final Examination

Winter 2015

Page 6 of 23

(c) (2 points) What is the runtime of the following function in terms of n, where n is the length of lon? (define (part-sum lon) (cond [(empty? lon) 0] [(empty? (rest lon)) (first lon)] [(empty? (rest (rest lon))) (+ (first lon) (second lon))] [else (+ (first lon) (second lon) (third lon))]) a. O(1) b. O(log n) c. O(n) d. O(n2 )

CS 136 Sample Final Examination

Winter 2015

Page 7 of 23

4. (35 points) Answer the short questions below in one or two sentences. (a) (5 points) Recall that the five regions in memory are: code, read-only, global data, stack, and heap. Read the following code: #include <string.h> string literal -> char *myvar; store in read only int main(void) { memory char *str = "CS 136"; char **c = &str; myvar = str; char *newstr = strdup(str); also in global } At the end of this program, in which regions are the following addresses located?

• str: stack read only stack • c: read only • myvar: global • newstr: stack heap • main: code

(b) (3 points) Does Racket have functions equivalent to the free and malloc functions found in C? If so, which are they, and if not, why not?

CS 136 Sample Final Examination

Winter 2015

Page 8 of 23

(c) (3 points) Why is it bad for a function to return a pointer to a variable in its own stack frame?

(d) (3 points) We saw in lecture how we could use the wrapper strategy to obtain an O(1) length function for T linked lists. Starting with the linked list structure below, how could you write an O(1) length function using the augmentation strategy (where each node is augmented)? Note: You do not need to write any code, just explain how you could do this. struct llnode { int item; struct llnode *next; };

store the length as the member of each node

(e) (3 points) Why should we use always give malloc a sizeof(type) argument, rather than an integer?

Example: malloc(sizeof(int)) as opposed to malloc(4)

how big the size of variable in memory differs by implementation and compilers

CS 136 Sample Final Examination

Winter 2015

Page 9 of 23

(f) (3 points) Sort the following list of orders in Big O notation, from smallest to largest: O(2n ), O(n), O(log(n)), O(n2 ), O(1), O(n log(n)) T

O(1) > O(log(n)) > O(n) > O(n log(n)) > O(n^2) > O(2^n)

(g) (3 points) Consider the following C code: int i = 2; int *q = malloc(sizeof(int)); q = &i; Have we leaked memory yet? If so so explain where and if not, write the necessary C code to free all of the dynamically allocated memory.

(h) (3 points) What’s the difference between a data structure and an abstract data type?

DATA STRUCTURE: it is a structure in code, has serious fields, exists in code

ADT: a theoretical concept we define how implementation works, what we can build in a container

CS 136 Sample Final Examination

Winter 2015

Page 10 of 23

(i) (3 points) What’s the difference between a function declaration and a function definition? Provide an example of both.

function declaration: -> does not reserve in memory int add1 (int i); function definition: -> reserves memory int add1 (int i ){ return i + 1; }

(j) (3 points) Describe what a pointer is in C. You may find it useful to use a picture of the memory model.

Give an example of where pointers are useful.

a pointer is a data type stores address in memory

we can go to places like heap and anywhere (the address of value we want)

(k) (3 points) What’s an opaque structure in C and give an example (in code)? Provide an example of how opaque structures impact modularization.

opaque structure is the incomplete structure definition; users can have the pointers pointed to the structure but they cannot access the structure itself -> only pointers to the structure can be defined -> achieve information hiding, gain security and flexibility -> RAM IN MODULARIZATION

CS 136 Sample Final Examination

Winter 2015

Page 11 of 23

5. (6 points) In the following code sample, identify (circle) three errors, and briefly explain why they are erroneous.

1 struct myarray { 2 void **array; 3 int size; 4 } ; 5 6 typedef struct myarray *MyArray; 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

MyArray construct_MyArray(int size) { MyArray newArray = malloc(sizeof(MyArray)) sizeof the structure newArray->size = size; newArray->array = malloc(sizeof(void *) * size); }

return newArray;

void destroy_MyArray(MyArray myArray) { if (myArray) { free(myArray); } }

realloc definition void insert_MyArray(MyArray myArray, int index, void *data){formation assert(myArray); wrong-> if (myArray->size >= index){ realloc(array, myArray->array = realloc(sizeof(void *) * (index + 1)); newsize) myArray->size = index + 1; } else { myArray->size++; } myArray->array[index] = *data; data }

CS 136 Sample Final Examination

Winter 2015

Page 12 of 23

6. (10 points) Consider the following function declaration: #include <stdbool.h> struct bstnode { int key; int val; struct bstnode *left; struct bstnode *right; }; // bst_exist(bst, i) determines if i exists in bst. // requires: bst is not NULL and bst is balanced // time: O(log(n)), where n is the number of nodes in bst. bool bst_exist(struct bstnode *bst, int i); (a) (5 points) Write the implementation for bst_exist recursively.

bool bst_exist (struct bstnode *bst, int i) { if (bst == NULL) return false; else if (i == bst->key) return true; else if (i < bst->key) return bst_exist(bst->left, i); else return bst_exist (bst->right, i); }

(b) (5 points) Write the implementation for bst_exist iteratively.

bool bst_exist (struct bstnode *bst, int i) { assert(bst); while (bst != NULL) { if (i == bst->key) return true; else if (i > bst->key) bst = bst->right; else bst =bst->left; } return false; }

CS 136 Sample Final Examination

Winter 2015

Page 13 of 23

7. (10 points) Write the C code for the following function: // filter(arr, n, pred) removes all elements from arr for which pred // evaluates to false and returns the size of the filtered array. // requires: arr is a dynamically allocated array of size n // effects: arr is mutated and resized to the minimum size to hold the // filtered elements. // time: O(n) int filter(int **arr, int n, bool (*pred)(int));

CS 136 Sample Final Examination

Winter 2015

Page 14 of 23

8. (10 points) Write the implementation for the following header file. #include <stdbool.h> // reverse_string(str) reverses the order of all the characters // inside of str. // requires: str is valid // effects: The order of str is mutated void reverse_string(char *str); // censor(str, word) censors all occurrences of word // in str. // requires: str and word are not NULL, and str and word // are valid C-strings // effects: allocates a new block of memory on the heap that // is the same size as the block of memory that str // points to. Replaces all occurrences of word in str // with asterisks ('*'). If there are nested occurrences, // censor the first one (i.e. word is "bob" and str is // "bobob" the result is "***ob"). // caller must free resulting string. // time: O(nm), where n is the string length of str and m is // the string length of word. char *censor(char *str, char *word);

void reverse_string (char * str){ int len = strlen(str) - 1; for (int i = 0; i < = len/2; ++i){ char temp = str[i]; str[i] = str[len - i ]; str[len - 1 ] = temp; } }

CS 136 Sample Final Examination

Winter 2015

Page 15 of 23

char *censor(char *str, char *word) { int len = strlen(str); char * new = malloc(sizeof (char) * (len + 1)); int wlen = strlen(word); for (int i = 0; i<len;) { bool match = true; for (int j = 0; j< wlen; j++){ if (str[ j +1] != word[ j ]){ match = false; break; } } if (match) { for (int j = 0; j <wlen; j++) { new[i+j] = ‘*’; } i += wlen; } else { new[i] = str[i]; i++; } } new[len] = ‘\0’; return new; }

CS 136 Sample Final Examination

Winter 2015

Page 16 of 23

9. (15 points) In this question you will implement an ADT for controlling a robot. Initially, the robot is at the point (0,0). The robot can be given commands to move with store instruction(), but will only execute them when go() is called. When go() is called, the robot will execute each action in the same order in which they were given via store instruction(). After executing each action, go() should print out the current position followed by a newline (‘\n’) character (i.e., “(3,4)\n”).

The instructions that can be sent to the robot are ‘u’, ‘d’, ‘l’, and ‘r’, which move the robot up, down, left, and right, respectively. Write the implementation for the header file given below. struct robot; typedef struct robot *Robot; // create_Robot() creates a new robot. // effects: allocates a new block of memory for a new robot. The // new robot is at the origin facing north. // caller must make a call to destroy_Robot. // time: O(1) Robot create_Robot(void); // destroy_Robot(r) destroys the robot. // requires: r is a valid robot // effects: frees all of the memory associated with the robot, r. // time: O(n), where n is the number of stored instructions. void destroy_Robot(Robot r); // store_instruction(r, i) stores the instruction for the robot. // requires: r is a valid robot and i is one of { 'u', 'd', 'l', 'r' } // effects: allocates a new block of memory for an instruction. // time: O(1) void store_instruction(Robot r, char i); // go(r) executes all of the stored instructions for the robot. // requires: r is a valid robot // effects: executes all of the stored instructions // frees all instructions. // time: O(n), where n is the number of queued instructions. void go(Robot r);

CS 136 Sample Final Examination

Winter 2015

Page 17 of 23

CS 136 Sample Final Examination

Winter 2015

Page 18 of 23

10. (25 points) Below is the interface for a Sequence ADT. Implement this ADT first using a linked list, and then again using a dynamically sized array.

Note: For functions that consume a Sequence, you may assume that the Sequence is valid (ie. not NULL, and with valid values in its fields). struct sequence; typedef struct sequence *Sequence; // create_Sequence() creates a new Sequence // effects: user must free new sequence // time: O(1) Sequence create_Sequence(); // destroy_Sequence(seq) deallocates all memory associated with seq // requires: seq is a valid sequence // effects: seq is no longer a valid Sequence // time: with list: O(n), where n is length(seq) // with array: O(1) void destroy_Sequence(Sequence seq); // insert_at(seq, n, i) inserts the int n into index i of seq // (This shifts all elements with index >= i up by one index) // requires: 0 <= i <= length(seq), seq is a valid sequence // effects: item n is inserted at index i, length of seq increases // time: with list: O(i) // with array: O(n), where n is length(seq) - i void insert_at(Sequence seq, int n, int i); // remove_at(seq, i) removes the int at index i from seq // (This shifts all elements with index > i down by one index) // requires: 0 <= i < length(seq), seq is a valid sequence // effects: item at index i is removed from s, length of s decreases // time: with list: O(i) // with array: O(n), where n is length(seq) - i void remove_at(Sequence seq, int i); // item_at(seq, i) returns the int at index i in seq // requires: 0 <= i < length(seq), seq is a valid sequence // time: with list: O(i) // wih array: O(1) int item_at(Sequence seq, int i); // length(seq) returns the length of the sequence // requires: seq is a valid sequence // time: O(1) int length(Sequence seq); // average(seq) returns the average of the numbers in the sequence // requires: length(seq) > 0, seq is a valid sequence // time: O(1) // Note: You can assume the sum of integers in the sequence <= INT_MAX float average(Sequence seq)

CS 136 Sample Final Examination

Winter 2015

Page 19 of 23

CS 136 Sample Final Examination

Winter 2015

Page 20 of 23

CS 136 Sample Final Examination

Winter 2015

Page 21 of 23

CS 136 Sample Final Examination

Winter 2015

Page 22 of 23

CS 136 Sample Final Examination

Winter 2015

Page 23 of 23