Avijit Roy
Fall 2026 John Jay College

CSCI 377: Computer Algorithms

This course develops practical skill in designing, analyzing, and explaining algorithms. We will examine asymptotic performance, divide-and-conquer, greedy optimization, dynamic programming, sorting, searching, trees, and graph algorithms, then connect those ideas to clear implementations and evidence-based choices.

Instructor: Avijit Roy
Schedule: Friday, 10:50 AM – 1:30 PM | Room NB 6.67
Office & contact: NB 6.63.29 · By appointment ARoy [AT] jjay [DOT] cuny [DOT] edu

Course Information

Catalog focus: CSCI 377 is a three-credit undergraduate course on the design and analysis of algorithms. Topics include important algorithm-design techniques, deterministic and randomized sorting and searching, paths and matchings, fast algebraic methods, and selected applications in number theory, machine learning, and string matching.

Prerequisites: ENG 201 and either CSCI 272 or MAT 272. Students should be comfortable with a high-level programming language and should expect to read pseudocode, analyze algorithms mathematically, and implement selected techniques.

The official description and prerequisite are available in the John Jay Undergraduate Bulletin.

Learning Outcomes

  • Analyze the asymptotic time and space complexity of algorithms using standard notation and clear assumptions.
  • Apply divide-and-conquer, greedy, and dynamic programming paradigms to suitable problems.
  • Compare major sorting and searching algorithms by correctness, efficiency, and practical constraints.
  • Use and analyze foundational tree and graph algorithms, including traversal and shortest-path techniques.
  • Form and solve useful recurrences for recursive algorithms.
  • Select an algorithm by weighing correctness, scalability, memory use, and implementation tradeoffs.
  • Synthesize efficient algorithms for common scientific and computational design situations.
  • Implement, test, document, and explain selected algorithms using an appropriate high-level programming language.

Weekly Plan

This syllabus provides the official semester course outline and schedule. Brightspace is the primary source for weekly materials, assigned readings, submission instructions, announcements, and any subsequently announced changes to the schedule.

August 28 | Module 1: Introduction to Algorithms

Course requirements and the Git/GitHub workflow; algorithm fundamentals and real-world uses; correctness, termination, and efficiency; the design-implement-analyze-experiment cycle; and an introduction to algorithm types and running-time analysis.

Reading assigned
September 4 | Module 2: Analyzing and Designing Algorithms

Insertion sort, loop invariants, algorithm analysis, merge sort, and the divide-and-conquer pattern.

Assignment 1 Assigned Homework / Reading
September 11 | No Class

No classes are scheduled under the Fall 2026 academic calendar.

September 18 | Module 3: Characterizing Running Time

Growth of functions, asymptotic notation, common complexity classes, best/worst/average cases, and communicating performance claims.

Homework / Reading
September 25 | Module 4: Divide and Conquer

Recursive decomposition, recurrence relations, substitution and recursion-tree reasoning, and selected divide-and-conquer applications.

Assignment 1 Due Project Topic Selection
October 2 | Module 5: Heapsort and Quicksort

Binary heaps, heap operations, heapsort, quicksort partitioning, randomized choices, and comparative performance.

Assignment 2 Assigned Homework / Reading
October 9 | Modules 1–5 Review and Analysis Workshop

Guided complexity-analysis practice, sorting comparisons, recurrence review, and preparation for the midterm exam.

Project Proposal / Plan Midterm Review
October 16 | Midterm Exam

Midterm assessment covering Modules 1–5, followed by a brief introduction to the next unit if time permits.

Midterm Exam
October 23 | Module 6: Linear-Time Sorting Algorithms

Comparison-sort lower bounds, counting sort, radix sort, bucket sort, and the assumptions that make linear-time performance possible.

Assignment 2 Due
October 30 | Module 7: Binary Search Trees and Red-Black Trees

Search-tree properties, traversal, search, insertion, deletion, predecessor/successor operations, and balanced-tree motivation.

Assignment 3 Assigned Homework / Reading
November 6 | Module 8: Graph Algorithms

Graph representations, breadth-first search, depth-first search, reachability, connected components, and topological ordering.

Project Checkpoint
November 13 | Module 9: Single-Source Shortest Paths

Relaxation, Bellman-Ford, Dijkstra's algorithm, negative-weight considerations, correctness, and implementation tradeoffs.

Assignment 3 Due Assignment 4 Assigned
November 20 | Module 10: Greedy Algorithms

Greedy-choice reasoning, fractional knapsack, Huffman coding, proof strategies, and recognizing when a greedy approach is appropriate.

Homework / Reading
November 27 | No Class

College closed for the Thanksgiving recess.

December 4 | Module 11: Dynamic Programming

Optimal substructure, overlapping subproblems, memoization, bottom-up solutions, and selected optimization problems.

Assignment 4 Due Project Draft / Testing Check
December 11 | Project Presentations and Final Review

Project demonstrations and presentations, cross-module synthesis, final-exam preparation, and remaining course questions.

Project Due Final Review
December 18 | Final Exam

Exam time: 1:00 PM–3:00 PM, following the published Fall 2026 undergraduate final-exam schedule for a Friday class meeting from 10:50 AM–1:30 PM.

Final Exam

Assessments

Your performance is evaluated through engagement, attendance, preparation, quizzes, algorithm-analysis assignments, exams, and a course project.

Engagement & Attendance

Class engagement and regular attendance (10%).

  • Class participation and discussion (5%): problem solving, algorithm walkthroughs, constructive group work, and course discussion.
  • Attendance (5%): regular and punctual attendance under the Departmental Attendance Policy.
  • Attendance scoring: 0 unexcused absence equivalents earns 5 points; 0.5–1 earns 4 points; 1.5–2 earns 3 points; 2.5–3 earns 2 points; and more than 3 earns 0 points before the departmental letter-grade penalty is applied.

Preparation & Assignments

Independent preparation and formal problem solving (25%).

  • Homework, readings, and knowledge checks (5%): assigned preparation, textbook exercises, short practice, and checks of conceptual understanding.
  • Assignments (20%): four problem sets combining analysis, pseudocode, proofs, and selected implementations.

Quizzes & Exams

Individual quizzes and exams (50%).

  • Quizzes (10%): announced or brief in-class checks of algorithmic reasoning.
  • Midterm exam (20%): Modules 1–5, including analysis, design choices, and algorithm tracing.
  • Final exam (20%): cumulative foundations with emphasis on Modules 6–11.

Algorithm Project

Applied design, implementation, and communication (15%).

  • Small groups propose, analyze, implement, and test an algorithmic solution.
  • Project deliverables include a proposal, source repository, written report, and presentation.

Grading Breakdown

Class Participation & Discussion 5%
Attendance 5%
Homework, Readings & Knowledge Checks 5%
Quizzes 10%
Assignments 20%
Midterm Exam 20%
Project 15%
Final Exam 20%

College grading rules: Review John Jay's Grades policy for official grade symbols, grade-point values, withdrawals, and Pass/No Credit rules.

Incomplete grades: An INC may be considered only when a student would otherwise be passing the course and, after consultation with the instructor, there is a reasonable expectation that the outstanding work can be completed by the last day of the following semester. An INC is not guaranteed and is assigned at the instructor's discretion. If the work is not successfully completed and no grade change is submitted, the INC becomes a FIN under College policy.

Extra Credit Policy

Extra credit is not guaranteed. If an opportunity is offered, it will be announced to the entire class and governed by the following rules:

  • Deadline Policy: All extra credit work must be submitted by the posted due dates.
  • No Extensions: Extra credit deadlines cannot be extended under any circumstances.
  • No Retroactive Credit: Missed or expired extra credit opportunities cannot be submitted later.

Responsibilities & Policies

Course Expectations

This course meets once per week in person. You are expected to keep up with weekly materials, participate in activities, and monitor course updates regularly. Brightspace will be your central hub for announcements, readings, homework, assignments, project descriptions, sample implementations, and grades.

  • Check Brightspace several times a week for new content and updates.
  • Submit assignments through the method specified for each task (Brightspace or GitHub).
  • Bring a pen or pencil and paper to every class; some algorithm tracing and analysis activities will be completed by hand without computers.
  • Receive email responses within 24 hours, Monday–Friday.
  • You may see optional practice activities in modules - these are not graded but strongly recommended.

Course Flexibility

To support student learning, the instructor may adapt this syllabus and weekly plan in response to class progress, demonstrated understanding, instructional needs, College calendar changes, or unforeseen circumstances. Adjustments may include the pace or sequence of topics, readings, activities, assignments, or due dates. Substantive changes will be announced in class and posted on Brightspace with reasonable notice; grading changes will not be applied retroactively to work already submitted.

Student Responsibilities

  • Attend class lectures regularly and arrive on time.
  • Complete knowledge checks, exams, and in-class activities at the scheduled times.
  • Complete assigned readings, homework, algorithm exercises, and project milestones on time.
  • Bring work that runs when implementation is required, and be ready to explain the algorithm and your design choices.
  • Back up your work and verify submissions (build, run, and test locally).

Participation Expectations

You are expected to engage respectfully and professionally with your classmates. Participation includes asking questions during examples, offering ideas, comparing algorithmic strategies, and contributing to group work. You are encouraged to explain your logic and collaborate conceptually without sharing full solutions.

  • Participate actively in discussions and algorithm walkthroughs.
  • Focus on explaining concepts rather than sharing full code with others.
  • Practice clearly communicating your reasoning and design decisions.
  • Respect the diverse experience levels of your classmates.

Departmental Attendance Policy

Regular attendance is expected and essential to success in the course. You are responsible for all material, announcements, and assignments covered in class, whether present or not.

  • Unexcused absences: More than 3 unexcused absence equivalents in the semester will result in a one-full-letter-grade penalty, such as B to C or B+ to C+. Additional unexcused absences may result in further letter-grade penalties and may result in a failing grade.
  • Excused absences: Documented illness, religious observance, family emergency, jury duty, or military service requires notification and, where possible, documentation within 2 class meeting days.
  • Late arrival or early departure: Arriving more than 15 minutes late or leaving more than 15 minutes early counts as one-half absence. Two partial absences equal one full absence.
  • Missed material: It is your responsibility to obtain missed notes, materials, and announcements from a classmate and to review Brightspace.
  • Make-up work: Work missed because of an excused absence must be arranged with the instructor within 1 week of your return to class.

Approved Office of Accessibility Services accommodations will be applied as authorized. The course-level attendance score is described under Assessments. This policy will be reviewed on the first class meeting and posted as a standalone item on Brightspace.

Late Work & Make-Up Policy

  • Knowledge checks, homework/readings, and participation tasks: Complete these on time. They generally cannot be made up after answers or feedback have been discussed, except when an excused absence qualifies for make-up work under the Departmental Attendance Policy.
  • Assignments and project milestones: You may submit work up to 3 days late only if you contact me before the due date. Late submissions may receive up to a 20% deduction. You will need to email me for approval.
  • Midterm and final exams: You must complete these on the scheduled dates unless you have a documented emergency.

Use of AI Tools

  • Use AI tools to learn and explore ideas — not as a substitute for your own work.
  • Cite all use: if AI helps you solve a problem or write code, clearly note which tool you used and what you asked.
  • No copy-paste: submitting AI-generated code as your own work is considered plagiarism.
  • Be ready to share the prompts and responses you used from AI tools if requested. Do not delete the conversation history.
  • You must be able to explain your code in person if asked. Inability to do so may result in loss of credit.

Example citation: “Used ChatGPT on October 30, 2026, to review the difference between BFS and DFS. Prompt: ‘Compare BFS and DFS without solving my assignment problem.’”

Academic Integrity

Academic dishonesty is prohibited. Penalties may include academic sanctions, such as a failing or reduced grade, and disciplinary sanctions, including suspension or expulsion.

Cheating is the unauthorized use or attempted use of materials, information, notes, study aids, devices, collaboration, or communication during an academic exercise. Examples include, but are not limited to:

  • Copying or sharing answers on an assignment or exam.
  • Collaborating when collaboration is not authorized.
  • Having another person complete work for you, completing work for another student, or submitting someone else's work as your own.
  • Fabricating data or using unauthorized notes, websites, devices, AI tools, or other resources.

Plagiarism is presenting another person's ideas, research, writing, code, media, or computer-generated content as your own without appropriate attribution. This includes copying or paraphrasing material from online or other sources without citation, failing to acknowledge collaborators, or submitting AI-generated content as original work.

  • Credit all permitted external help, including peers, forums, snippets, and AI tools, in your README.
  • Be prepared to orally explain any code you submit.
  • If you are unsure whether a resource or form of collaboration is allowed, ask before submitting.

These examples are not exhaustive. Review the John Jay Academic Integrity Office for definitions, College policies, and information about the review process.

Accessibility Services

Students who believe they may need an accommodation for a temporary or permanent disability are encouraged to contact the Office of Accessibility Services (OAS) at [email protected]. OAS handles disability documentation and coordinates approved academic adjustments.

You are welcome, but not required, to discuss your course-specific needs with the instructor privately. You do not need to disclose your diagnosis or the specific nature of your disability to the instructor. Any disability-related information you choose to share will be treated privately. Please contact OAS and the instructor as early as possible so approved accommodations can be implemented.

Student Support Resources

John Jay offers academic, health, counseling, accessibility, emergency, and basic-needs support. Seeking support early can help you stay healthy and engaged in the course.

Tools & Setup

Core Workflow

  • Visual Studio Code - recommended editor for pseudocode, reports, and implementations.
  • Git and GitHub - required workflow when a repository is specified for an assignment or the project.
  • Programming language: assignments may use Python, C++, or Java as specified. Use a local runtime/compiler that you can run and debug reliably.

Algorithm analysis and explanation matter as much as producing output. Keep pseudocode, complexity claims, test cases, and implementation decisions together in your submission.

Language References

Course Materials & Submissions

CSCI 377 Course Repository

The public CSCI 377 Computer Algorithms repository provides module notes, readable C++ examples, tracing practice, and supplemental learning materials. Use it to study how an algorithm works, predict its behavior, run the examples, and test your own modifications. Unless explicitly permitted, do not submit repository examples as completed assignment solutions.

Open Course Repository

The repository is a supplemental learning resource. Brightspace remains authoritative for announcements, assignments, readings, due dates, submission instructions, grades, and other official course information.

Using GitHub for Your Work

GitHub will be our shared workspace and code archive. It helps you track every change, back up projects safely, and practice professional version control workflows. You'll also use it to document algorithm implementations and submit work when instructed. Practice and share only your learning repos (like CSCI-377-Fall-2026), not graded assignments, to avoid revealing answers to others.

Note: Not all assignments will be submitted via GitHub. Follow the submission method listed on Brightspace for each assignment.

Get Started

Personal Practice Repo Pattern

  • Create a personal practice repo named CSCI-377-Fall-2026.
  • Use this repo for practice implementations, algorithm notes, benchmarks, and experiments.
  • Do not post full assignment solutions before grading is completed; you may be asked to submit privately.

Assignments & Submission

  • When instructed, submit via GitHub (private repo) by sharing access to the instructor; otherwise submit on Brightspace.
  • Use a clear folder structure for analysis, source code, test data, and documentation.
  • Commit regularly with meaningful messages (e.g., “add Bellman-Ford negative-cycle test”).
  • Do not commit credentials, large generated files, binaries, or IDE build folders.

README Expectations

  • Problem statement, selected algorithm, and the reasoning behind that choice.
  • Complexity analysis, assumptions, and how to build/run the implementation.
  • Test strategy, sample results, limitations, and references or permitted external assistance.

Algorithm Project

The project provides a structured opportunity to select an algorithmic problem, justify an approach, implement and test the solution, and communicate the results. Students will work in groups of 2–3; detailed project instructions and approved topics will be posted on Brightspace.

Project Milestones

  • Topic selection: identify the problem, group members, and a preliminary algorithmic direction.
  • Proposal: define inputs, outputs, constraints, planned techniques, and team roles.
  • Checkpoint: show analysis, repository progress, initial tests, and unresolved risks.
  • Final submission: submit the source repository and concise written report.
  • Presentation: demonstrate the solution and explain correctness, complexity, testing, limitations, and individual contributions.

Project assessment considers problem formulation, algorithm selection, correctness, complexity analysis, implementation quality, testing, documentation, presentation, and the ability of each student to explain the submitted work.

Books & References

Required / Main Text

  • Introduction to Algorithms (4th Edition), Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein - MIT Press, ISBN-13: 978-0262046305

Optional References

  • Algorithms (4th Edition), Robert Sedgewick and Kevin Wayne.
  • The Algorithm Design Manual (2nd Edition), Steven S. Skiena.

Library or ebook access is fine for reading and study. Assigned sections will be identified on Brightspace as the weekly plan is finalized.

Important Websites

Practice & Learning Resources

Use these resources to reinforce course concepts through alternative explanations, visualizations, worked examples, and additional practice. Brightspace materials and assigned textbook sections remain the primary course sources.

Concepts, Lectures & Visualizations

How to Practice Effectively

  • Trace the algorithm by hand before running an implementation.
  • State the inputs, outputs, assumptions, and invariants before writing code.
  • Test normal cases, boundary cases, and inputs that expose worst-case behavior.
  • Compare empirical timing with the asymptotic analysis, but do not confuse one benchmark with a proof.
  • Explain why the algorithm is correct and why it fits the problem, not only what the code does.

External materials are optional unless assigned. Do not copy solutions from these or other sites into graded work; follow the course attribution and academic-integrity rules.

Quick FAQs

How do I submit assignments?

Follow instructions on Brightspace for each assignment. When asked to use GitHub, keep the repo private and share access for grading.

What if my implementation runs but the algorithm or analysis is incomplete?

Running code is only one part of the work. Grading may also consider correctness, algorithm choice, complexity analysis, test coverage, explanation, and adherence to the assignment requirements.

Can I use AI tools?

Use AI to learn concepts, not to replace your analysis or implementation. Cite permitted use in your README and retain the interaction history. You must be able to explain every submitted decision.

Course Updates

  • August 29, 2026 - Standardized syllabus terminology and expanded student-support resources.
  • August 28, 2026 - Public course repository added for supplemental notes, examples, and tracing practice.
  • August 24, 2026 - Fall 2026 syllabus published.

Last updated: