Quiz Learning Objectives

This page lists the Quiz Learning Objectives for this course. The focus here is on quizzes, but you’ll have a chance to practice these skills in class and on assignments as well.

Unit 1: Kotlin and Course Foundations

Kotlin foundations

  • KF 1: variables

    • Proficiency: define variables for basic types
    • Mastery: define variables for collections with generics

  • KF 2: conditional statements

    • Proficiency: write if-else statements
    • Mastery: write when statements or nested ifs

  • KF 3: loops (definite and indefinite)

    • Proficiency: write basic loops
    • Mastery: write nested loops

  • KF 4: functions

    • Proficiency: write a function with no parameters or return value
    • Mastery: write a function with parameters and return value

Object orientation

  • OO 1: objects

    • Proficiency: instantiate and use without parameters/return
    • Mastery: instantiate and use with parameters and return

  • OO 2: interfaces

    • Proficiency: implement a specified interface
    • Mastery: define your own interface

  • OO 3: inheritance

    • Proficiency: implement a simple subclass
    • Mastery: use call to super to build on super’s method

Time complexity

  • TC 1: complexity classes
    • Proficiency: order polynomial complexity classes
    • Mastery: order mixes of polynomial, logarithmic, and exponential complexity classes

Unit 2: Linear ADTs

Lists

  • LT 1: linked lists

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • LT 2: linked-list time complexity

    • Proficiency: define Big-O of specified linked-list operation(s)
    • Mastery: demonstrate how you get that Big-O

  • LT 3: array-based lists

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • LT 4: array-based list time complexity

    • Proficiency: define Big-O of specified array-based list operation(s)
    • Mastery: demonstrate how you get that Big-O

  • LT 5: debugging lists

    • Proficiency: identify bugs in list implementations
    • Mastery: identify and fix bugs in list implementations

Stacks

  • SK 1: stack ADT

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • SK 2: stack time complexity

    • Proficiency: define Big-O of specified operation(s)
    • Mastery: demonstrate how you get that Big-O

Queues

  • QQ 1: queue ADT

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • QQ 2: queue time complexity

    • Proficiency: define Big-O of specified operation(s)
    • Mastery: demonstrate how you get that Big-O

Unit 3: Set ADT and Hashing

Sets and hashing

  • HT 1: sets via hash tables

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • HT 2: hashing time complexity

    • Proficiency: define worst-case Big-O of operation(s)
    • Mastery: demonstrate how you get that Big-O

Unit 4: Recursion and Trees

Recursion

  • RC 1: recursion

    • Proficiency: define the “three laws of recursion”
    • Mastery: write a recursive function

  • RC 2: debugging recursion

    • Proficiency: identify bugs in recursive functions
    • Mastery: identify and fix bugs in recursive functions

Trees

  • TR 1: tree traversal

    • Proficiency: identify in-order, pre-order, and/or post-order tree traversal
    • Mastery: give each of in-order, pre-order, and post-order tree traversals

  • TR 2: binary search tree insertion/deletion

    • Proficiency: demonstrate insertion/deletion in simple case
    • Mastery: demonstrate insertion/deletion in complex case

  • TR 3: balanced search tree insertion/deletion

    • Proficiency: demonstrate insertion/deletion in simple case
    • Mastery: demonstrate insertion/deletion in complex case

  • TR 4: debugging trees

    • Proficiency: identify bugs in tree implementations
    • Mastery: identify and fix bugs in tree implementations

Unit 5: Sorting, Heaps, and Priority Queues

Quicksort

  • QS 1: quicksort

    • Proficiency: perform quicksort on a small list given a diagram
    • Mastery: perform quicksort on a large list

  • QS 2: quicksort time complexity

    • Proficiency: define best- and worst-case Big-O
    • Mastery: demonstrate how you get that Big-O

Heaps

  • HP 1: heap ADT

    • Proficiency: demonstrate the effect of a single operation
    • Mastery: demonstrate the effects of a sequence of operations

  • HP 2: heapsort time complexity

    • Proficiency: define worst-case Big-O
    • Mastery: demonstrate how you get that Big-O

Unit 6: Graphs

  • GS 1: breadth-first search

    • Proficiency: indicate first level of BFS
    • Mastery: demonstrate full BFS

  • GS 2: breadth-first search time complexity

    • Proficiency: define Big-O in worse case
    • Mastery: demonstrate how you get that Big-O

  • GS 3: depth-first search

    • Proficiency: indicate first sequence of DFS
    • Mastery: demonstrate full DFS

  • GS 4: depth-first search time complexity

    • Proficiency: define Big-O in worse case
    • Mastery: demonstrate how you get that Big-O