Date: Tue, 05 Nov 1996 20:57:46 GMT Server: NCSA/1.5 Content-type: text/html Last-modified: Mon, 14 Oct 1996 14:23:40 GMT Content-length: 7061
There will be three exams for CS367, two midterm and one final exam. Exams count for 50% of your final grade. Information on the exam format, studying tips, and topics for exam 1 may be found below. Topics for the other exams will be added to this page as the semester progresses. The exam dates are:
Midterm 1 15% Wednesday 10/23/96 7:15 - 9:15 pm, 1361 Chemistry Midterm 2 20% Tuesday 11/26/96 7:15 - 9:15 pm, tba Final 15% Wednesday 12/18/96 5:05 - 7:05 pm, tba
Make-up exams for the midterms are given only with my permission when you are unable to take the regular exam due to extenuating circumstances. A request for a makeup exam must be made during my office hours, and must be brought to my attention two weeks before the exam date. I will waive this requirement for verifiable emergencies, but no requests for make-ups will be accepted after the actual exam is given.
There will be no make-up for the final. Final exam dates are listed in the Timetable so that students can avoid conflicting final exams.
Exams have from five to ten questions (some having multiple parts), are designed for a two hour exam period, and an average score of 70 points out of 100.
Exam questions fall into three categories, tracing code, writing code, and miscellaneous. You can expect to see each of these three categories on the exams. Tracing requires you demonstrate understanding of code provided by showing the output or results generated, diagraming code execution, or describing what code does in general. Coding questions require you to demonstrate your knowledge of data structures and C++ syntax/semantics by writing C++ code to solve the particular problem described. Sometimes code is provided that you need to use or supplement to finish the question. Miscellaneous questions cover the broad spectrum of question styles such as true/false, fill in the blank, multiple choice, or short answer questions.
Prioritize your studying. When I create the exams I consider first what we covered during lectures, then the programming assignments, and finally the reading materials.
Study your notes. Of course this is obvious, but many go about studying their notes in the wrong manner. Don't just highlight your notes and think that counts as reading them! Don't just reread your notes and think that counts as studying them Successful studying requires you to be more involved and actively thinking about the material. One of the most effective ways to study is to reorganize and rewrite your notes in a succinct manner in terms that you understand.
Avoid getting bogged down on specific points. If you can figure something out, move on to other material and wait to ask me or the TAs.
You'll need to do some memorizing. Memorizing is a practical way to learn the definitions of terminology and concepts. A good way to memorize information is through repeated exposure to the material.
Form a study group. It is often easier and more motivating to work with others when studying for an exam. You can distribute the work by having each group member come up with a few questions, and then going over the solutions collectively. If you run into a concept that causes confusion, often others in the group will have similar difficulty. Together the group can figure something out more quickly than an individual, because of the multiple perspectives the members bring to the group.
Finally avoid cramming! We all know this. However, though we promise ourselves that we will start studying early, often we find ourselves waiting til too late. This is a habit worth breaking. Studies have shown that studying in half hour to hour intervals followed by half hour breaks is far more effective than non-stop cramming.
Basic C++ discussed in Appendix A of the text will not be directly tested, but it will be required to answer questions concerning topics listed below. The key topics covered are listed below:
Basic * objects and classes OOP o interface vs. implementation o public vs. private o data members and member functions o constructors and destructor o using objects and calling methods Advanced * using default arguments OOP o initializer list o copy constructor (shallow vs. deep) Recursion * concept & terminology o simple recursion and iteration o tracing using the box method o programming recursion Complexity * concept & terminology o growth rate functions f(N) o simplification of f(N) o big O notation o order of magnitude functions Search & * concepts & terminology Sorting o searching - O(N): linear - O(logN): binary (CH. 2 recursion) o sorting - O(N^2): bubble, selection, insertion - O(N^1.25): shellsort - O(N*logN): quicksort, & mergesort Basic * defining using * Pointers o operators - * "points-to" (dereferencing) - & "address-of" - new and delete (single and array) o static vs. dynamic allocation o arrays and pointers Linked * concept & terminology Lists o operations (lookup, insert, remove...) o position vs. key-value oriented o implementations - singly linked o variations - tail pointer - dummy head - doubly linked & prev pointer - circular list o recursion and linked lists Stacks * concept & terminology o operations (push, pop, peek) o implementations - dynamic array - linked list (free list) o using the stack adt