Department of Math and Computer Science
Computer Science Comprehensive Exam FAQ

1. After you register, you will receive periodic emails from: nobody@mcs.csueastbay.edu
   This User ID is for security reasons, and this means: a) these emails might get filtered by your PC
   b) you cannot respond to this address
   c) respond to the instructor instead
2. What might happen if I cheat? At the exam, you will be asked to sign the following on your cover sheet:

   WARNING: University regulations are serious about plagiarism, copying, cheating. The Computer Science Graduate Committee will enforce serious penalties, in particular disqualification from the graduate program, for any student(s) found to be cheating.

   I certify that the submitted papers are solely my own work. I have not offered these results to others and I have not received results from others. I understand the possible penalties for violations.

3. What do I need to bring with me? One Self-Addressed Stamped Envelope (SASE, business size, which is about 9.5in x 4.25in or 24cm x 10.3cm. Only need one for the entire exam); pens/pencils, eraser, Photo ID in case we ask to see it.
4. How is the exam graded, what is passing?

   The new exam structure has 3 problems per exam. You select 2. We look at the exam and decide whether or not you show a reasonable amount of understanding of the subject. In that sense the result is simply a boolean yes (pass) or no (not a pass). To help us decide, we initially grade each problem on a scale of 0-20, resulting in a maximum score of 40 points.

   Note that the initial scores on a paper are just that: initial. The committee reviews the exams after that to make a final determination. There may be differences in scores between graders and we pay particular attention to this in cases where it makes a difference in the outcome. But, again, the initial scores you see are a guide for the committee and borderlines will be evaluated for a reasonable understanding of the subject.

   With respect to the new exam structure, the committee has discussed general guidelines for determining a pass. The transition year Fall 2005/Spring 2006 will be used by the committee to refine these guidelines. As in the past, the committee is interested in a good, solid solution to one question. That, by itself, is important but the other solution will have an effect. Note that even with guidelines for scoring a pass, the bottom line is that the committee has to make borderline decisions, and these are always determined by a reasonable understanding of the subject.

   As before, the committee recommends that students do the best they can on each exam - and then it is the committee's task to evaluate results.

5. If I'm working the past exams, and I can't answer problem X, what should I do? The chances of us asking problem X again are very small. The real question is whether you understand the fundamental issues at stake. If not, then you should put some more effort into reading lecture notes and/or reference books. Also, work in a study team. If you ask a faculty to work problem X for you, they will probably give you general direction rather than detailed answers.
6. What is the most common mistake on the comps? That's easy. Consider this function:

     int myFunc() {
       some code
     }
   

   This occurs in the data structure portion and is usually a recursive function. Students will call this function and not do anything with the result - in this case, the integer might be a counter or just a boolean. The return value is crucial to the computation. All functions (unless void) must be sure to return a value and all calling functions must be sure to utilize the value. Here is a full example:

   /*1*/int leaf_nodes(/*2*/ BINARY_TREE T) {
   
         if (T == NULL)   /*3*/
           return 0;      /*4*/
         else
           if (T->left == NULL && T->right == NULL) /*5*/
             return 1;    /*6*/
           else
             return /*7*/ leaf_nodes(T->left) + leaf_nodes(T->right); /*8*/
   }
   

   1. examine the return type
      • function must return this type under all circumstances
      • returned value from a function call must be used
   2. examine the parameter types
      • must provide exactly these parameters/types in all function calls
   3. stop the recursion
      • put at the top
      • often stop because of falling off the tree (NULL)
   4. consider what the default return value should be
      • what should be the result for an empty tree?
   5. look ahead to children
      • UNUSUAL
      • usually call recursively and let default situation take care of it
   6. must always return a value of the correct type
   7. must always return a value of the correct type
   8. recursive calls
      • input parameter (e.g. T->left) matches expected type (BINARY_TREE)
      • recursion moves the parameter values along (e.g. T->left)
      • must use function values returned from function calls
      • can treat as ordinary values
      • do not have to have temporary variables
      • can do arithmetic (+,-,*,/) on ints
      • can do boolean logic (!,&&,||) on boolean ints
      • can use function values in IF and RETURN statements
      • but just don't call the function and forget about the return value
7. What language can I use to answer Data Structures? You can program in any language as long as your code clearly displays the algorithm operating on a data structure. This will typically be C, C++, or Java. We do not recommend scripting languages such as Perl, unless they are used in a fashion that clearly illustrates the algorithm (and not something cryptic, which is very common in Perl).

   But be careful of one thing. If you use special, language specific, structures like Arraylist, you could get into trouble. Don't use a structure that loses "linked list". Don't start using some array, when the problem calls for "linked list". That is, if the problem says "linked", then there better be a ".next" or "->next" and not L[i] or L.elementAt(i). There's a crucial difference between an array and a list.