CS302 Midterm Exam - October 8, 2020

This was a straightforward exam, which really only had one difficult question, which was the last.

Here is the distribution of the scores, along with my assignment of grades to scores. Please see https://web.eecs.utk.edu/~jplank/General-Teaching/Final_Grades.html for explanation on how exam grades are incorporated into the final grade.

The exam was on Canvas, and I used question banks for a lot of questions, so I won't have the exact exam here, but I will describe it:

Questions 1-10: These were Big-O questions that related to STL data structures, priority queues, disjoint sets and enumeration. Each question was multiple choice and three points. Examples: "What is the running time complexity of enumerating all words of length n from an alphabet with m characters?" (O(mⁿ)), and "What is the running time complexity of creating a multiset from a vector with n elements?" (O(n log(n))).
Question 11 was a bit arithmetic question, for three points. Example: "Let's suppose that the number y represents a set whose elements are numbers from 0 to 30. Let's also suppose that x is a number from 0 to 30. Which of these returns (y intersection { x } )?" Answer:

y & (1 << x).
Question 12 was a more "mathy" big-O question for four points. Example: "If m = O(log n), then what is the simplest way to express O(m+n)?" Answer: O(n).
Question 13 was a 3-point question about a priority queue or map, worth 3 points. Example: "If a node in a priority queue/heap is at index i, how do we calculate its right child?" Answer: 2i+2.
Question 14 was the same for everyone: "Explain in your own words what an interface is, and why it is a useful concept in a language like C++ (Even though C++ doesn't formally have an interface, you can view it as a restricted subset of inheritance)." 10 points.
The answer is that an interface defines the prototypes of methods that a class may implement. If a class implements those, then the class may "belong" to the interface, and then one may program with an instance of the interface, and it will work with all classes that belong to the interface.
The interface does not define common variables -- that is inheritance, and if you said such, you were penalized for it. I also penalized vagueness ("interfaces allow you to group together like classes and they simplify code").
Question 15 was a priority queue push question, where you were given a picture of a priority queue, and you had to tell me the index of the value that was pushed. 4 points. For example:
The answer to this question is 12.
Question 16 was a priority queue push question, where you were given a vector representation of a priority queue, and you had to tell me the index of the value that was pushed. 4 points. For example:
The answer to this question is 7.
Question 17 was a priority queue push question, where you were given a vector representation of a priority queue, and you had to tell me the index of the last element in the priority queue following a pop operation. 4 points. For example:
The answer to this question is 9.
Question 18 was a disjoint set Union question. Four points. For example:
The answer here is that links[6] is set to 16, and that sizes[16] is set to 11.
Question 19 was a disjoint set Find question. Four points. For example:
The answer to this question is "23 23 9 9".

Question 20 was a programming question. 15 points:

This is a map question. For all of the ages < 80, you need a map keyed on an integer (the age), whose val is a multiset of names. You print it with a nested traversal -- the outer loop loops over the ages and the inner loop loops over the names.

You have to treat values >= 0 differently. Either you have to have a separate multiset for them, or you can simply set any age ≥ 80 to 80. The code below does the former approach:

#include <map>
#include <set>
#include <iostream>
using namespace std;

int main()
{
  int age;
  string name;

  map <int, multiset <string> > u80;
  map <int, multiset <string> >::iterator uit;
  multiset <string> o80;
  multiset <string>::iterator oit;

  while (cin >> age >> name) {
    if (age < 80) {
      u80[age].insert(name);
    } else {
      o80.insert(name);
    }
  }
  
  for (uit = u80.begin(); uit != u80.end(); uit++) {
    for (oit = uit->second.begin(); oit != uit->second.end(); oit++) cout << *oit << endl;
  }
  for (oit = o80.begin(); oit != o80.end(); oit++) cout << *oit << endl;
  return 0;
}

A lot of the points in grading this question came from your choice of a data structure. If you simply had a map whose key was an integer and whose val was a string, you lost roughly 8 points, because you lose names when you insert duplicate ages into the map. You lost more points if you chose to store things in a vector, and then to have O(n²) code to traverse the vector and print things out.

The last question was a permutation question with a twist (15 points):

We went over code like this in class with the ThreeTeleports question. It's just like the regular permutation code, except you check to see if the last element is the "ending" element, and if it is, you print it out and return. This is as opposed to only printing the vector when index is v.size():

#include <iostream>
#include <vector>
using namespace std;

void permute(vector <int> &v, int index, int terminate)
{
  size_t i, j;
  int tmp;

  for (i = index; i < v.size(); i++) {
    tmp = v[i];
    v[i] = v[index];
    v[index] = tmp;

    if (v[index] == terminate) {
      for (j = 0; j <= index; j++) cout << " " << v[j];
      cout << endl;
    } else {
      permute(v, index+1, terminate);
    }
  
    tmp = v[i];
    v[i] = v[index];
    v[index] = tmp;
  }
}
    

int main()
{
  size_t i;
  int val;
  vector <int> v;

  while (cin >> val) v.push_back(val);
  if (v.size() == 0) return 0;
  permute(v, 0, v[v.size()-1]);
  return 0;
}

A harder approach that I saw some students take is to do a power set enumeration of all of the elements except the last, and then for each subset, enumerating the permutations of that and finally printing out the last value. When you did that, you typically ended up losing points because it was harder to put the pieces together.