CSE 143

Course Info

Tutorials

Getting Help

Check Scores

Other

Exam Dates

  • Midterm: Friday, July 20th during lecture in SIG 134
  • Final part 1: Thursday, August 16th in your section
  • Final part 2: Friday, August 17th during lecture in SIG 134

After the Final:

  • average was 78.3, median was 80.2 (before score adjustment)
  • final key
  • regrade policy
  • regrade requests due by Wednesday, October 10th.

Final exam contents:

Seating assignments for Sieg 134 (all sections): list (names shortened), map

No seating assignments for part 1 of the final exam taken in your assigned section.

icon cheat sheet (will be provided as last page of exam)

icon TA final strategies

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

  • Binary Tree Traversals: Perform pre-order, in-order and post-order traversals on a tree.
  • Binary Search Trees: Given a set of values, add them to a binary search tree.
  • Polymorphism mystery: 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 8/9 problems)
  • Comparable programming: Write a complete class and make it Comparable based on a given set of comparison criteria. (similar to section 8/7 problems) You will not be asked to extend another pre-existing class like some problems seen on past exams
  • Collections programming: Write a method that uses one or more class from the Java Collections framework (with focus on Sets, Maps and Lists).
  • Binary tree programming: Add a method to the IntTree class from lecture. (similar to section 7/31 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 8/2 problems).
  • Linked list programming: Add a method to the LinkedIntList class from lecture. (similar to section 7/5 problems)

The following topics are guaranteed NOT to be explicitly tested on the final exam:

  • detailed knowledge of Big-O (some questions may ask you to solve them within a certain big-O limit, but mainly this is just to ward off extremely inefficient answers)
  • detailed knowledge of search/sort algorithms
  • tracing or writing code with 2-D arrays
  • catching exceptions
  • priority queues
  • input/output streams
  • abstract classes
  • inner classes
  • implementing an Iterator class
  • implementing a "generic" class (one that accepts type parameters such as <T>)
  • hashing
  • extending a pre-existing class for the Comparable problem

Practice Exams and Problems:

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. You may also want to time yourself to practice your pacing. Note that many of these practice exams are from previous quarters, so they may contain problem categories that will not be on your final. Refer to the section abo ve to determine whether or not practice exam questions are relevant for your studying.

Note: Several of these ask about sorting or ask you to write a class that extends another. You will NOT be asked these kinds of questions (though, you will have to write a class that implements th e Comparable interface)

Additional practice problems can be found on Practice-It or by category here

Exam Rules and Information:

  • You will have an assigned seat and you must sit in that seat. If you arrive for the exam and find someone else in your seat, ask them to move because we will move students to their assigned seats. We will take pictures of the room to help us verify that students sit in their assigned seats (please contact us if you have a concern about this). Students are expected to make a reasonable effort to sit in their assigned seat. Students who demonstrate an egregious disregard for the seating assignments will receive a 5-point penalty (e.g., if a student goes to the wrong room or refuses to move when asked to).
  • We may ask to check your UW ID card during the exam so please have it ready.
  • You will have 60 minutes to complete the midterm and 110 minutes to complete the final. We will distribute the exam early and you can read and fill out the cover page of the exam, but you should not look at the exam questions until you are told to begin. At the end when time is called, you are required to stop writing and close your exam. Students who look at the exam before being told to begin and students who make changes to their exam after time is called will receive a 10-point penalty. Students who do not close their exam booklet when time is called may also receive a 10-point penalty.
  • The exams are closed-book and closed-note. You must work alone and may not use any computing devices of any kind including calculators or digital copies of the textbook. Cell phones, music players, and other electronic devices may NOT be out during the exam for any reason.
  • There will be a cheat sheet included as the last page of the exam. Space will be provided for your answers. If you need additional scratch paper, raise your hand and a TA will give it to you. You are not allowed to use your own paper during the exam.
  • Unless a question specifically mentions otherwise, the 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 are, however, required to declare all data fields as private, to use generics properly, and to declare variables and parameters using interfaces when possible. The midterm cheat sheet mentions important restrictions on stacks and queues that you must follow.
  • Unless otherwise specified, you should write each solution as a public instance method. You may define helper methods as part of your solution, but they should be declared to be private.
  • You are allowed to abbreviate "compiler error" and "runtime error" for the inheritance question on the midterm (as in "ce" and "re" or "c.e." and "r.e."), but you should otherwise NOT use any abbreviations on the exam.
  • You don't need to write any import statements in your exam code.
  • You are not allowed to use advanced material to solve exam problems. In general, you are restricted to the classes and methods listed on the exam cheat sheet.
  • You are not allowed to use break, continue, a return from a void method, try/catch, the diamond operator (<>), or Java 8 features.
  • For standard Java classes such as Math and String, you are limited to the methods listed on the cheat sheet. You are not allowed to use the Arrays or Collections classes or other standard classes and methods that aren't included on the cheat sheet.
  • Please be sure that your answer is clearly indicated. This is particularly important if you provide more than one answer or if you have notes in addition to your answer. You can draw a box around the answer you want to have graded and you can draw an "X" through anything that you do not want to have graded.
  • You do not need to turn in scratch paper unless you have all or part of an answer on that sheet of paper (you can take the other sheets of paper with you). If you have a sheet of paper with all or part of an answer, please write your name on that sheet of paper, staple the entire sheet to the end of your test (not in the middle) with a single staple in the upper-left corner, and clearly indicate under the corresponding problem that your answer is attached on an extra sheet of paper. A stapler will be available.
  • Please be quiet during the exam. If you have a question or need assistance, please raise your hand.
  • When you have finished the exam, please turn in your exam quietly and leave the room.
  • You may not leave the exam room in the last 5 minutes of the testing period.

After the Midterm:

  • average was 67.8, median was 72 (before score adjustment)
  • scores will be adjusted up by 5 points with a max of 100 (score currently in canvas has not been adjusted yet; no adjustment for students who took the alternate midterm).
  • midterm key
  • regrade policy
  • regrade requests due by Wednesday, August 8th.
  • The midterm is worth 20% of your grade - that means about 50% of your grade is still to be determined! If the midterm didn't go as well as you would have liked, come talk to me about study tips and exam approaches to use on the final. You can also use Grade-a-nator to compute your approximate grade so far.

Midterm Content

Seating assignments for Sieg 134 (all sections): list (names shortened), map

icon cheat sheet (will be provided as last page of exam)

icon TA midterm strategies

Material from Weeks 1-5 is considered "fair game" for questions on the midterm. The actual midterm exam will have 6-8 total problems. Those problems will be selected from the following kinds of questions (and no other kinds of questions):

  • ArrayList "mystery" (look at a piece of code that uses ArrayLists, and write its output)
  • ArrayList programming (write a method that uses ArrayLists)
  • ArrayIntList programming (add a method to the ArrayIntList class from lecture)
  • Collection programming (write a method that uses Java collections such as Lists, Sets, and Maps)
  • stack and queue programming (write a method that uses Stacks and Queues)
  • linked list node manipulation (write a few lines of code to change a "before" picture of some linked nodes into an "after" picture)
  • recursion tracing (look at a piece of recursive code, and write its output)
  • recursion programming (write a method that uses recursion)
  • The following topics are guaranteed NOT to be required to solve any problem on the midterm:
    • programming with inheritance (extending a class, etc.)
    • writing an interface (though you might have to write a method that accepts a parameter of interface type, such as List, Set, Map, etc.
    • testing, debugging, commenting
    • grammars
    • implementing Comparable (though you may have to be a client of TreeSet and/or TreeMap which require the elements to be comparable)
    • implementing sorting algorithms (though you may have to be a client of TreeSet and/or TreeMap which maintains the elements in sorted order
    • hashing

Practice-It has many sample midterms. We recommend that you practice on paper so here are PDFs you can print out. Note that these examples provide s2q and q2s on the Stacks and Queues question, which we will not provide on your midterm: