CS 1210 Placement Exam

Placement

UVM’s computer science programming curriculum includes the following sequence of courses:

  • CS 1210 Computer Programming I (taught in Python): An introduction to algorithmic problem solving and computer programming. Designed to provide a foundation for further studies in computer science.
  • CS 2100 Intermediate Programming (taught in Java): Intermediate programming concepts including common data structures, algorithms, style, design, documentation, testing and debugging techniques, and an introduction to object-oriented programming. Prerequisite: CS 1210 with a grade of C- or better.
  • CS 2240 Data Structures and Algorithms (taught in C++): Design and implementation of linear structures, trees and graphs. Examples of common algorithmic paradigms. Theoretical and empirical complexity analysis. Sorting, searching, and basic graph algorithms. Prerequisites: CS 2100 with a grade of C- or better; minimum sophomore standing.
  • CS 2300 Advanced Programming: Builds programming maturity and proficiency through significant projects with spiral development, including program specification, design, implementation, debugging, testing, validation, internal and external documentation. Focus on advanced topics including efficiency, profiling, modularity, extensibility, programming paradigms, design patterns, memory management, and generics. Prerequisite: CS 2240.

Typically, the first three of these courses are taken sequentially during the first three semesters a student is enrolled in the program. It is imperative that after completing this sequence, students have not only become strong programmers, but also are proficient in Python, Java and C++ programming languages.

If you have taken AP Computer Science Principles or AP Computer Science A and received a 4 or 5 on the exam, your progression may look a bit different.

Please refer to the placement flowchart to determine your best path forward (Click the graphic for full size pdf).

CS 1210 Placement Exam Flowchart

Placing out of CS 1210

To place out of CS 1210, one of the following must apply:

  • You received credit for AP CS Principles with a 4 or 5 on the exam, and can document that it was taught in Python.
  • You have transfer credit for a comparable Python programming course from another institution.
  • You have passed the UVM CS Department's CS 1210 placement test.

About the placement exam

The Department of Computer Science offers a placement exam giving students the option of testing out of CS 1210 Introduction to Programming. Students who place out will not receive credit for CS 1210, but will be able to register for courses that have CS 1210 as a prerequisite (e.g., CS 2100 Intermediate Programming).

Topics

The placement exam covers fundamentals of programming, in the context of the Python programming language. You should be able to:

  • answer true/false or multiple choice questions about programming in general, simple data structures (e.g., lists, stacks, queues, key/value), and the Python programming language,
  • demonstrate fluency in use of basic features of Python,
  • trace the execution of small portions of code (e.g., containing loops, conditionals, etc.), and
  • write small snippets of code or functions to perform specified tasks with given constraints.

Checklist

Fundamentals:

  • Common Python types: int, float, bool, str, range, enumerate, list, tuple, dict, and NoneType
  • Variables, identifiers, and assignment
  • Understanding dynamic typing
  • Difference between expressions and statements
  • Mutability and immutability
  • Arithmetic operators: +, -, /, //, //, **, and %
  • Comparison operators: ==, <, <=, >, >=, !=
  • Lexicographic order
  • Boolean operations with comparison
    • Connectives: and, or and not
    • Truthiness and falsiness
    • Comparability
    • Keyword is
  • Use of constructors for common Python types
  • Specifying the entry point with if __name__ == '__main__':
  • Correct program structure
  • Matters of style and PEP 8
  • Syntax vs semantics

Functions:

  • Defining functions with def
  • Specifying function parameters and passing arguments to a function
  • Returning values from a function with return
  • Writing pure and impure functions and understanding side-effects
  • Calling a function and using the return value(s)
  • Matters of scope

Sequences and iterables:

  • Basics of sequences and iterables
  • Common sequence operations: in, not in, + and * (where permitted)
  • Indexed reads from any sequence, and indexed writes to lists, and slices of any sequence
  • Built-ins that work with sequences len(), min(), max(), sum()
  • List methods: .append(), .pop(), .sort(), .extend(), .reverse()
  • String methods: .upper(), .lower(), .capitalize(), .split(), .join(), .replace(), .title(), .strip()
  • Sequence methods .index(), .count()
  • Sequence unpacking
  • Nested sequences
  • Copying lists (shallow) with .copy(), the list constructor, or slice
  • Using slicing with lists, e.g., extracting some portion of a list using a slice
  • Use of next()

Branching:

  • Branching with if, elif, and else
  • Using conditionals in branch statements
  • Nested conditionals

Loops:

  • Loops with for and while, and understanding use cases for each
  • Using an accumulator (or accumulators) in a loop
  • Proper use of break
  • Nested loops

Dictionaries:

  • Dictionary fundamentals: keys and values
  • Dictionary views with .keys(), .values(), .items()
  • Use of dictionary method .pop() and keyword del
  • Hashability

Console I/O:

  • Python built-ins: input() and print()
  • Use of f-strings and format specifiers

File I/O:

  • Basic file I/O using a context manager (with)
  • open() and file handles
  • File mode flags
  • File handle methods: .read(), .write()
  • Use of next()

Python modules and imports:

  • Importing with import, from, as
  • Understanding the dunder __name__ in the context of imports
  • Math module: .pi, .e, .sqrt(), .sin(), .cos() , .log(), .log2(), .log10(), .degrees(), .radians(), .floor(), .ceil()
  • Random module: .random(), .randint(), .choice(), .seed(), .gauss(), .shuffle(), .sample()

Exceptions and exception handling:

  • Common exceptions: SyntaxError, IndentationError, NameError, ValueError, TypeError, IndexError, FileNotFoundError, ZeroDivisionError, AttributeError, KeyError, ModuleNotFoundError, UnboundLocalError, etc.
  • Exception handling with try, except

Miscellaneous:

  • Built-in functions abs(), dir(), sorted()
  • Method chaining
  • Splats

Intermediate questions:

In addition to questions drawn from introductory level topics (above), there will be some intermediate questions on the exam as well. Your placement will not be based on intermediate questions, but your responses will help us gauge the overall preparedness of students taking the placement exam.