Lecture 20, Thu 12/01

''' Final Exam Logistics
* Final Exam in-person, Thursday 12/8 @ 8am - 10am, BUCHN 1910
* Bring a writing utensil and a photo ID
    * Please write LEGIBLY (if we can't read it, we won't
    grade it)
    * When leaving the room, you must present your ID and
    hand in your exam before leaving (it's your ticket out!)
* Closed Book (No notes / book / electronic devices)
* The final exam will be cummulative
* Types of questions
    * True / False (if False, explain why)
    * Short Answers
        * Briefly describe / define / state / ...
    * Given some code, write the output, state the O-notation, ...
    * Write code satisfying a certain specification
    * Given some algorithm we covered, fill in the blank to make
    it work.
    * Draw diagrams, write next iteration of, ...
'''

''' Topics
Python Basics
    * Types
        * int, float, boolean, strings, lists, sets, dict,...
        * conversion functions (int(), float(), str())
        * Mutable vs. Immutable
    * Relational / Logical operators (==, <, <=, and, or, ...)
    * Python Lists
        Supporting methods (count, pop, ...)
    * Understanding under-the-hood functionality of lists and
    dictionaries
    * List / String slicing [:]
    * Strings
        * Supporting methods (replace, split, find, ...)
    * Function definitions
    * Control structures
        * If, else, elif, for, while, ...
Testing
    * Test Driven Development (TDD)
    * pytests
Python Errors
    * Syntax vs Runtime
Exceptions
    * Exception types (NameError, TypeError, ZeroDivisionError)
    * Exception Handling
        * try / except / raise
        * Flow of execution
        * Passing exceptions to function caller
        * Catching multiple exceptions
        * Catching inherited type exceptions
Object Oriented programming
    * Defining Python classes and methods
    * class constructors
        * Defining / initializing default parameters
    * Shallow vs. Deep Equality
        * overloading __eq__ method
    * overloading operators
        * __str__, __add__, __le__, ...
    * Inheritance
        * Know the implementation and inheritance behavior of
        fields / methods, and how to override inherited methods
        * Know the pattern on how to construct inherited
        classes
        * Know the hierarchy of types (applies to exception
        handling)
        * Know how to explicitly call super / base class(es)
        methods
Algorithm Analysis and O-notation
    * Know how to derive O-notation from a Time function for
    various data structure functionality and code segments
Binary Search
    * Search for items in a SORTED list
    * Know the implementation and O-notation
Recursion
    * Understand how recursive algorithms are managed by the
    call stack
    * Derive O-notation for various recursive functions
* Linear Data Structures
    * Know implementations (as covered in textbook / lecture)
    and O-notation for various functionality
        * Stacks, Queues, Deques, Linked Lists, Ordered Linked
        Lists
* Sorting Algorithms
    * Know the implementation and O-notation analysis (best /
    worst case scenarios) of various sorting algorithms
        * Bubble Sort (including optimized version), Selection
        Sort, Insertion Sort, Merge Sort, Quick Sort
* Trees
    * Terminology
    * O-notation
    * Know the min-heap / max-heap data structure implementation
    (and underlying list representation)
    * Binary Trees
        * Know the nodes and references implementation
        * Tree traversals: pre, in, post order
    * Binary Search Trees
        * BST property and how insertion affects the structure
        * add, search, and remove functionality
'''