CISC 124

Objects and Basic Operations - Easy

Foundational understanding of object creation, method calls, and the Scanner class

Objects and State Management - Medium

Working with object state, method behavior, and understanding constructor overloading

Java Arrays and Loops - Fundamentals

Test basic understanding of Java array syntax, limitations, and iteration patterns compared to Python.

Java Arrays and Loops - Advanced Applications

Test application of array concepts to real problems, comparing Python and Java approaches, and understanding loop variable scope and index tracking.

String Fundamentals and Operations - Easy

Basic understanding of String class methods, char type, and string operations in Java.

String Operations and Type Conversions - Medium/Hard

Advanced String manipulation, char arithmetic, type conversions, and lexicographical ordering.

Java Fundamentals and Python Comparison – Easy

Tests basic understanding of Java syntax, entry points, and differences from Python.

Java Fundamentals and Python Comparison – Medium

Tests deeper understanding of Java's object-oriented design, type system, and syntax rules.

If Statements, Scope, and Logical Operators—Easy

Introductory assessment covering if/else if/else structure, variable scope, and basic logical operators in Java.

If Statements, Scope, and Logical Operators—Medium/Hard

Advanced assessment covering scope edge cases, operator precedence, and the interplay between multiple return statements and compiler behavior.

Java Collections Fundamentals (Medium Difficulty)

Tests understanding of ArrayList and HashSet creation, element types, common operations, and the Python-to-Java transition.

Java Collections and Type System (Hard Difficulty)

Focuses on edge cases, wrapper types, set operations, and conceptual depth around generics and collection choice.

Javadoc, Contracts, and Invariants - Medium Difficulty

Test your understanding of documentation practices, method contracts (preconditions and postconditions), assertions, and class invariants.

Inheritance, Polymorphism, and Generics - Expert Difficulty

Advanced assessment of inheritance design, polymorphic type comparisons, enumerated types, and generic type parameters.

Arrays Fundamentals — Easy

Basic understanding of array declaration, purpose, and constraints.

Arrays Fundamentals — Medium

Conceptual reasoning about array constraints, type safety, and design implications.

Java Types, Variables, and Methods – Intermediate

Tests understanding of primitive vs. reference types, integer overflow, method declaration syntax, and Java semantics compared to Python.

Java Fundamentals – Expert Challenge

Advanced questions on primitive vs. reference types, method design, overflow behavior, and nuanced semantic differences between Java and Python.

Array Indexing Fundamentals - Easy

Basic understanding of zero-based indexing, valid index ranges, and array element access.

Array Indexing and Bounds - Medium

Intermediate challenges involving array bounds, the relationship between array size and valid indices, and debugging out-of-bounds errors.

For Loop Fundamentals - Easy

Basic understanding of for loop structure, parts, and execution order.

For Loop Analysis and Application - Medium

Deeper understanding of for loop mechanics, scope, and practical applications like array traversal.

Array Loop Fundamentals - Practice Test 1

Tests understanding of array iteration patterns, loop bounds, and element access in array algorithms.

Array Loop Fundamentals - Practice Test 2

Advanced test focusing on loop boundary conditions, adjacent element patterns, and algorithm efficiency.

ArrayList Fundamentals and Iteration

Test basic ArrayList operations, list manipulation, and iteration techniques.

ArrayList Iteration and List Manipulation

Test deeper understanding of iteration patterns, defensive programming, and practical ArrayList use cases.

Arrays, Loops, and Control Flow - Foundational

Tests understanding of loop selection, array indexing, and break statement optimization.

Arrays, Loops, and Control Flow - Advanced

Tests optimization, edge cases, and synthesis across multiple concepts.

Floating-Point Fundamentals – Practice Test 1

Covers IEEE 754 representation, error measurement, and basic arithmetic operations on floating-point numbers.

Floating-Point Arithmetic – Practice Test 2

Focuses on addition/subtraction mechanics, guard digits, and the consequences of repeated operations.

Practice Test 1: Sets & Stack Fundamentals

Mixed-difficulty test covering set operations, set types, and stack implementation basics.

Practice Test 2: Advanced Set & Stack Concepts

Harder test focusing on algorithmic understanding, edge cases, and design trade-offs.

Coin Flip Simulation: Foundational Concepts

Tests understanding of binomial distribution concepts and simulation mechanics at introductory level.

Coin Flip Simulation: Advanced Analysis

Tests interpretation of results, probability mechanics, and algorithmic reasoning at intermediate-to-advanced level.

Object Structure and Behavior – Easy

Foundation-level assessment covering basic object terminology and concepts.

Object Structure and Behavior – Medium

Intermediate assessment focusing on composition, interaction, and design implications.

Java Generics and Recursion Fundamentals

Beginner-level assessment covering generic type constraints and basic recursion concepts.

Advanced Recursion and Generic Constraints

Intermediate-to-advanced assessment targeting deeper understanding of recursive decomposition and type system constraints.

Jump It Fundamentals – Easy

Basic comprehension of Jump It rules, valid moves, and simple scenarios.

Jump It Problem-Solving – Hard

Advanced reasoning about board solvability, cycle detection, and recursive decomposition.

Recursive Sorting Fundamentals - Basic

Tests understanding of how minToFront works, the structure of selection sort, and basic recursion mechanics in list sorting.

Recursive Sorting Analysis - Advanced

Tests analysis of algorithm complexity, comparison of sorting approaches, and deeper understanding of recursion mechanics in selection sort.

Jump It Problem: Fundamentals & Solution Design

Tests understanding of the Jump It problem structure, why greedy fails, and how to construct a recursive solution.

Jump It Problem: Deep Reasoning & Extensions

Advanced assessment focusing on why greedy fails, recursive proof of correctness, and problem variants.

Board Solvability Recursion - Fundamentals

Tests understanding of the recursive backtracking algorithm structure, base cases, and state management in the isSolvable method.

Board Solvability Recursion - Deep Analysis

Advanced test focusing on edge cases, algorithm correctness, and the reasoning behind design choices in backtracking implementations.

Object Lifecycle and Reference Semantics – Test 1

Medium-difficulty test covering object creation, lifecycle control, reference equality, and defensive copying.

Equals, HashCode, and Collections – Test 2

Hard-difficulty test covering equals contract, hashCode implementation, instanceof checks, and collection behavior.

Linked List Fundamentals - Easy

Basic understanding of linked list structure and recursion

Linked List Recursion - Medium/Hard

Deeper analysis of recursive structure and algorithm design implications

Nodes and Data Structures - Fundamentals

Foundation-level assessment of node concepts, their properties, and relationships to common data structures.

Nodes and Data Structures - Advanced Relationships

Intermediate to advanced assessment targeting conceptual connections between node structure, link semantics, and data structure properties.

Dice Odds Simulation – Fundamentals

Tests understanding of the simulation algorithm, list structure, and probability estimation.

Dice Odds Simulation – Advanced

Tests deeper conceptual understanding, coding implementation details, and statistical reasoning.

Constructors Fundamentals — Easy

Basic understanding of constructor syntax, naming, and purpose.

Constructors Fundamentals — Medium

Deeper understanding of constructor mechanics, naming rules, and distinction from methods.

Set Operations Fundamentals - Practice Test 1

Tests understanding of set operations, particularly retainAll() and set intersection concepts

Set Operations Applied - Practice Test 2

Advanced application of set operations focusing on intersection logic and set algebra

Set Operations Fundamentals - Practice Test 1

Foundation-level assessment covering set membership, removeAll() mechanics, and basic set algebra concepts.

Set Operations & Conceptual Mastery - Practice Test 2

Advanced assessment emphasizing the relationship between set methods and set algebra theory, with application scenarios.

Set-Based Duplicate Detection - Fundamentals

Test your understanding of how sets are used to identify and separate unique and duplicate accounts in a linear pass through data.

Set-Based Duplicate Detection - Advanced Applications

Deeper exploration of algorithm correctness, edge cases, and comparisons with alternative approaches.

Constructors Fundamentals - Practice Test 1

Easy to medium difficulty assessment covering no-argument constructors, copy constructors, and parameterized constructors.

Constructors Fundamentals - Practice Test 2

Medium to hard difficulty assessment emphasizing the conceptual relationships between constructor types and object initialization.

True/False - Constructors Fundamentals

Quick true/false checks on constructor concepts.

Short Answer - Constructor Design

Short-answer questions requiring explanation of constructor usage and design.

Essay - Constructor Strategy

Essay question on overall constructor design strategy.

Set Operations and Behavior - Foundation

Basic understanding of set properties, the addAll() method, and how sets differ from other collections.

Set Operations and Collection Behavior - Advanced

Deeper analysis of set semantics, union operations, and collection design trade-offs.

Class Design & Documentation - Easy

Foundation-level assessment of class invariants, wrapper classes, and documentation practices.

Class Design & Documentation - Medium

Intermediate assessment requiring application of concepts to new scenarios and deeper reasoning.

Static Methods and String Conversion - Foundational

Tests understanding of static method invocation, String.valueOf(), and basic type conversion concepts.

Static Methods and Type Conversion - Advanced Application

Tests deeper understanding of when to use static methods, type conversion mechanisms, and API design choices.

Static Members and Utility Classes – Easy

Foundational concepts: accessing static members, public static final fields, and basic utility class design.

Static Members and Utility Classes – Hard

Advanced concepts: constructor delegation, static factory methods, and design patterns for avoiding constructor overloading.

Static Fields Fundamentals - Easy

Basic understanding of static field concepts, memory organization, and when to use static vs. instance variables.

Static Fields in Context - Medium

Application of static field concepts to design decisions, memory efficiency, and distinguishing between static and instance data.

Scanner and Control Flow - Fundamentals

Basic understanding of Scanner input handling and loop control mechanisms.

Scanner and Control Flow - Advanced

Deeper analysis of input handling edge cases and program design patterns.

Method Preconditions – Fundamentals

Tests understanding of precondition definition, responsibility assignment, and documentation.

Method Preconditions – Application & Edge Cases

Tests ability to apply precondition concepts to real scenarios and understand enforcement tradeoffs.

Javadoc Fundamentals - Practice Test 1

Test on basic Javadoc structure, comment syntax, and documentation generation principles.

Javadoc Documentation Standards - Practice Test 2

Test on Javadoc best practices, proper use of block tags, and documentation strategies for different code elements.

Object Identity, Inheritance, and Class Invariants — Foundational

Tests understanding of why equals() must be overridden, how inheritance structures work, and the role of class invariants in substitutability.

equals(), Iterables, and Nested Classes — Advanced Application

Tests ability to apply concepts to novel scenarios, including custom equals() implementation, iterator design, and access modifier implications.

Postconditions: Fundamentals & Implementation

Test understanding of postcondition concepts, checking mechanisms, and their practical application.

Postconditions: Advanced Scenarios

Test deeper understanding of postconditions in complex scenarios and edge cases.

Static Factory Methods Fundamentals

Basic understanding of static factory methods, their purpose, and differences from constructors.

Static Factory Methods Advanced Applications

Deeper understanding of static factory method design patterns, immutability, and API design decisions.

Static Methods and Utility Classes — Foundational

Tests understanding of static features, utility class design, and basic access patterns.

Static Methods and Utility Classes — Advanced Application

Tests deeper understanding of static design patterns, access control, and practical utility class scenarios.

Enumerations: Fundamentals and Old-Style Problems

Easy-to-medium difficulty test covering the motivation for enums and problems with using primitives to represent enumeration values.

Enumerations: Advanced Problems and Best Practices

Medium-to-hard difficulty test covering deeper understanding of enumeration problems and design considerations.

Java Enums Fundamentals - Easy/Medium

Tests basic understanding of enum syntax, built-in methods, and field initialization.

Java Enums Advanced Concepts - Hard

Tests deep understanding of enum design principles, Comparable implementation, and field initialization patterns.

Wrapper Classes, Generics, and Static Utilities

Test covering auto-boxing/unboxing, generic type declaration, utility class design, and static field semantics.

Advanced Static Features and Immutability

Expert-level test on compareTo contracts, mutable fields in constants, and advanced utility class patterns.

Equals Implementation Fundamentals

Foundation-level test covering core concepts of equals contracts, state comparison, and field equality checking.

Advanced Equals and Type Checking

Advanced test covering instanceof type checking, transitivity pitfalls, and practical equals implementation strategies.

Stack Fundamentals — Easy

Basic understanding of stack operations, terminology, and LIFO behavior.

Stack Applications & Behavior — Medium

Conceptual understanding of stack behavior, exceptions, and when stacks are applied.

Hash Tables and Comparable Practice Test 1

Focus on hashCode contracts, hash table performance, and Comparable interface fundamentals.

Hash Tables and Comparable Practice Test 2

Focus on hash function design, hashCode/equals contracts, Comparable consistency, and edge cases.

Enums and Code Design Fundamentals

Test your understanding of when and why to use enums, and the readability improvements they provide.

Enum Design Principles and Application

Intermediate to advanced assessment of enum usage patterns, trade-offs, and when to use them vs. alternatives.

Stacks Fundamentals - Easy

Basic understanding of stack operations, LIFO principle, and real-world applications.

Stacks Implementation & Design - Medium

Deeper understanding of stack implementation choices, design patterns, and advanced applications.

Inheritance and Is-A Relationships - Foundational

Test your understanding of when inheritance is and isn't appropriate, and the reasoning behind the Circle-Ellipse problem.

Inheritance and Is-A Relationships - Advanced Application

Apply is-a principles to complex scenarios and evaluate design decisions.

UML Class Diagrams and Relationships — Foundational Test

This test covers basic UML notation, class diagram components, and the conceptual distinctions between dependency, association, aggregation, and composition.

Composition, Defensive Copying, and Collections — Advanced Test

This test covers the mechanics of implementing composition with defensive copying, shallow vs. deep copies of collections, and the cost-benefit analysis of design choices.

Stack-Based Recursion Conversion – Fundamental Concepts

Test your understanding of how stacks simulate recursive method calls and the basic conversion strategy.

Stack-Based Recursion Conversion – Advanced Application

Advanced questions testing synthesis, design decisions, and edge cases in converting recursive methods.

Stack Implementation Fundamentals

Tests understanding of array-based and linked-list stack implementations, complexity analysis, and core operations.

Stack Operations and Design Patterns

Focuses on designing stack operations, iteration patterns, interface design, and comparing implementation strategies.

Constructor Inheritance & Object Initialization

Tests understanding of superclass constructor calls, constructor chaining, and the object initialization chain.

Polymorphism & Type Systems

Tests understanding of subtype polymorphism, declared types vs. runtime types, and equals() implementation in inheritance hierarchies.

Java Generics Fundamentals - Basic Comprehension

Test your understanding of generic class declaration, type parameters, and the motivation for using generics.

Java Generics Application - Medium Difficulty

Test your ability to apply generic concepts, understand parameterization, and work with multi-type generic classes.

Generics Fundamentals – Easy

Basic understanding of generics motivation and type safety concepts.

Generics and Type Safety – Medium

Deeper analysis of generics benefits, type safety mechanisms, and design trade-offs.

Inheritance for Code Reuse – Fundamentals (Medium)

Tests understanding of access modifiers, inheritance design, and the Liskov Substitution Principle in the context of the Counter example.

Inheritance for Code Reuse – Advanced (Hard)

Tests deeper reasoning about design trade-offs, substitutability, and real-world implications of visibility and contract decisions.

Liskov Substitution & Dynamic Dispatch - Foundational

Tests understanding of how runtime types determine method behavior and why substitutability is critical for inheritance design.

Method Contracts & Invariants - Advanced Application

Deeper examination of how method contracts (parameters, return values, state changes) must be respected in subclass overrides.

Java Generics Fundamentals - Easy

Basic questions on generic type constraints, array creation, and interface definition.

Java Generics - Medium/Hard

Deeper questions on generic constraints, type erasure implications, and implementation details.

Generic Queues and Linked Lists — Foundation Test

Tests core understanding of queue structure, operations, implementations, and introductory linked-list concepts.

Advanced Queue and List Operations — Expert Test

Tests mastery of iterator design, array resizing, linked-list traversal, and generic methods applied to complex scenarios.