Exams

Final Exam:

• final exam | answer key

Extra credit artwork:

Alyssa, Brian, Charlotte, Daniel, Jake, Janet, Jeff, Kasey,
Jordan B, Kelly, Kim, Lisa, Logan, Marisa, Morgan, Robert,
Ryan, Stefanie H, Steven W, Sylvia, Whitaker

Score Distribution:	Score Averages by Question (uncurved):
Count As 98 26% Bs 120 31% Cs 87 23% Ds 45 12% all 383 100%	Question Average q1 (inheritance/polymorphism) 13.7 / 15 q2 (inheritance and comparable) 11.1 / 15 q3 (linked list programming) 9.9 / 15 q4 (searching and sorting) 13.0 / 15 q5 (binary search trees) 14.49 / 15 q6 (binary tree programming) 7.3 / 10 q7 (binary tree programming) 9.2 / 15

Regrades:

The final exam follows the same regrade policy as the midterm exam (see below). A cover sheet and Practice-It output is required for a final exam regrade. You can slide your final under Marty's office door (CSE 466) with the proper cover sheet(s) attached. Regrades will be accepted through the end of the first week of Spring 2009 quarter.

• Place: Kane 120 (our normal lecture room)
• Date: Thursday, March 19, 2009
• Time: 2:30 - 4:20pm

Sample Exams:

We strongly suggest that you try to solve all of these problems yourself, on paper, without a computer, and without looking at the answer key until you're done.

• practice final exam #1 ( answer key)
• practice final exam #2 ( answer key)
• practice final exam #3 ( answer key) (was given out as section 20's handout.)

• Sample final exams posted here are intended to be very similar to the actual final exam. The number of problems and type of problems on the actual exam will be much like what is seen on these practice exams.
• The following topics are guaranteed NOT to be explicitly tested on the final exam:
  • detailed knowledge of Big-Oh (some questions may ask you to solve them within a certain big-Oh limit, but mainly this is just to ward off extremely inefficient answers)
  • recursive backtracking (recursion will definitely be needed, but not specifically backtracking)
  • catching exceptions
  • priority queues
  • input/output streams
  • abstract classes
  • inner classes
  • implementing an Iterator class
  • generics
  • hashing

The questions on the final exam will be the following. Each question will be worth between 10-20 points:

• Inheritance and polymorphism: Given a set of classes with inheritance relationships, a set of variables declared using those classes, and a set of method calls made on those variables, write the output. (similar to section 17 problems)
• Inheritance/Comparable programming: Given an existing class, write a complete subclass of it that adds certain features. Also make the class Comparable based on a given set of comparison criteria. (similar to section 11,17 problems)
• Linked list programming: Add a method to the LinkedIntList class from lecture. (similar to section 8, 19 problems)
• Searching and sorting: Trace the execution of binary search, selection sort, and merge sort on given arrays of integers. (similar to section 5 problems)
• Binary search trees: Given a set of values, add them to a binary search tree. Then perform traversals in the three standard orders on that tree.
• Binary tree programming: Add a method to the IntTree class from lecture. (similar to section 15, 16 problems)
• Binary tree programming: Add a method to the IntTree class from lecture. Similar in spirit to the previous question but harder. (similar to section 15, 16 problems)

Midterm:

• midterm | answer key

Score Distribution:	Score Averages by Question (uncurved):
Raw Curved As 12 3% 94 24% Bs 53 13% 173 43% Cs 120 30% 259 65% Ds 211 53% 329 83% all 398 100% 398 100%	Question Average q1 (stacks/queues) 13.7 / 19 q2 (sets/maps) 9.0 / 15 q3 (linked list nodes) 12.5 / 15 q4 (linked list programming) 6.6 / 20 q5 (recursive tracing) 11.0 / 15 q6 (recursive programming) 6.5 / 15

Regrade Policy:

If your exam score was added up incorrectly, take it to your TA and they'll fix it for you.

If you disagree with the grading, such as if you think your solution actually does work, or that your solution is more nearly correct than it was given credit for, the procedure for regrades is the following:

• If your complaint is about the correctness of your solution to a programming question, go to our Practice-It! system, which will contain runnable testers for the midterm problems. Type your code into Practice-It, fixing any trivial syntax problems. Run it for yourself and see how nearly correct your solution is.
• If you still think your grade is incorrect, submit your exam to Marty for a regrade. (Either give it to us in lecture, go to our office hours, or slide it under our office doors.) You must include a cover page with a brief written explanation of what specifically you think was misgraded and why. If your complaint is about overly harsh grading on a programming question, you should also submit a printout of your code being run in Practice-It, along with the test case results, to us so that we can to verify its correctness. We will not accept any exam for a regrade unless it includes this cover page, and we will not re-evaluate grading of the correctess of any programming questions without a typed copy of your solution from Practice-It being shown to us first.
• Also note: When you submit an exam for a regrade, we will regrade your entire exam. If we notice anywhere that you were mistakenly given too many points, we will also correct this, up to a maximum penalty of -2 for the entire exam. So it is possible (though unlikely) that a regrade request will result in you receiving a slightly lower mark than what you started with.
• All midterm regrade requests (other than simple score addition errors) must be submitted to Marty by Friday, February 27.

Sample Exams:

• sample midterm #1 | answer key
• sample midterm #2 | answer key
  • additional practice problems can be found in the textbook, in your section handouts, and in our Practice-It! tool

• Sample midterm exam(s) posted here are intended to be very similar to the actual midterm. The number of problems and type of problems on the actual exam will be much like what is seen on these practice exams. Material from Weeks 1-5 is considered "fair game" for questions on the actual midterm.
• The following topics are guaranteed NOT to be required to solve any problem on the midterm:
  • Java I/O, file processing, Scanner
  • Iterator
  • implementing interfaces
  • programming with inheritance (extending a class, etc.)
  • binary search
  • Comparable
  • sorting algorithms
  • grammars / BNF
  • recursive backtracking

Rules and Information:

• You must show your UW Student ID card to a TA or the instructor for your submitted exam to be accepted.
• You will have roughly 50 minutes to complete the exam. You may receive a deduction if you keep working after the instructor calls for papers.
• The exam is open-book/notes. You must work alone and may not use any computing devices of any kind including calculators. Cell phones, music players, and other electronic devices may NOT be out during the exam for any reason.
• Unless a question specifically mentions otherwise, your code you write will be graded purely on external correctness (proper behavior and output) and not on internal correctness (style). So, for example, redundancy or lack of comments will not reduce your score.
• You don't need to write any import statements in your exam code.
• On the exam it will be allowed to abbreviate S.o.p for System.out.print and S.o.pln for System.out.println. Otherwise do not abbreviate any code on the exam.
• Please be quiet during the exam. If you have a question or need, please raise your hand.
• Corrections or clarifications to the exam will be written at the front of the room.
• If you violate the University Code of Conduct during the exam, you may receive a 0% for the exam and possibly further punishment.
• When you have finished the exam, please turn in your exam quietly and leave the room.
• If you enter the room, you must turn in an exam paper and will not be permitted to leave the room without doing so.