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

Core        Advanced
KF 1: variables – define variables for basic types KF 5: collections – define variables for collections with generics
KF 2: conditional statements – write if-else and/or when statements KF 6: nested loops – write nested loops
KF 3: loops – write basic definite/indefinite loops
KF 4: functions – write a specified function

Object orientation

Core                      Advanced
OO 1: objects – instantiate and use an object OO 2: interfaces – implement a specified interface
OO 3: inheritance – implement a subclass

Time complexity

Core                                  Advanced
TC 1: core complexity classes – order polynomial complexity classes TC 2: complexity classes – order mixes of polynomial, logarithmic, and exponential complexity classes

Unit 2: Linear Data Structures

Lists

Core        Advanced
LT 1: array-based lists – demonstrate the effects of a sequence of operations LT 5: array-based list time complexity – demonstrate how you get the big-O of a specified operation
LT 2: core array-based list time complexity – define the big-O of a specified operation LT 6: linked-list time complexity – demonstrate how you get the big-O of a specified operation
LT 3: linked lists – demonstrate the effects of a sequence of operations LT 7: debugging lists – identify and fix bugs in list implementations
LT 4: core linked-list time complexity – define the big-O of a specified operation LT 8: using lists – use the appropriate list to solve a problem in very clear pseudocode

Stacks and Queues

Core                Advanced
SQ 1: stacks – demonstrate the effects of a sequence of operations SQ 5: stack time complexity – demonstrate how you get the big-O of a specified operation
SQ 2: core stack time complexity – define the big-O of a specified operation SQ 6: queue time complexity – demonstrate how you get the big-O of a specified operation
SQ 3: queues – demonstrate the effects of a sequence of operations SQ 7: using stacks/queues – use the appropriate data structure to solve a problem in very clear pseudocode
SQ 4: core queue time complexity – define the big-O of a specified operation

Unit 3: Sets and Hashing

Sets and hashing

Core        Advanced
SH 1: sets/hash tables – demonstrate the effects of a sequence of operations SH 3: hashing time complexity – demonstrate how you get the big-O of a specified operation
SH 2: core hashing time complexity – define the big-O of a specified operation

Unit 4: Recursion and Trees

Recursion

Core             Advanced
RC 1: defining recursion – define the three laws of recursion RC 2: using recursion – write a recursive function in very clear pseudocode

Trees

Core        Advanced
TR 1: tree traversal – identify in-order, pre-order, and/or post-order tree traversal(s) TR 4: debugging trees – identify and fix bugs in tree implementations
TR 2: binary search trees – demonstrate insertion/deletion operation(s) TR 5: using trees – use an appropriate tree to solve a problem in very clear pseudocode
TR 3: balanced trees – demonstrate insertion into a 2-3 tree

Unit 5: Sorting, Heaps, and Priority Queues

Heaps and priority queues

Core                                 Advanced
HP 1: heaps – demonstrate the effects of a sequence of operations HP 2: using heaps/priority queues – use a heap or priority queue to solve a problem in very clear pseudocode

Sorting

Core        Advanced
ST 1: quicksort – demonstrate quicksort on a diagram ST 4: quicksort time complexity – explain the idea behind the idea behind the big-O of quicksort
ST 2: core quicksort time complexity – define the best- and worst-case big-O of quicksort ST 5: heapsort time complexity – explain the idea behind the idea behind the big-O of heapsort
ST 3: core heapsort time complexity – define the worst-case big-O of heapsort

Unit 6: Graphs

Graphs

Core        Advanced
GR 1: breadth-first traversal – identify full breadth-first traversal order GR 4: BFS/DFS time complexity – explain the idea behind the idea behind the big-O of BFS and DFS
GR 2: depth-first traversal – identify full depth-first traversal order GR 5: using graphs – use a graph to solve a problem in very clear pseudocode
GR 3: core BFS/DFS time complexity – define the big-O of BFS and DFS