cs6515 homework github

Welcome to my shared space of projects in engineering, startups, and personal interests.

OMSCS Review

CS 6515 - Graduate Algorithms

Okay, 90% of your engineers use my software (Homebrew), but I can't invert a binary tree, so fuck off. Don't worry, after this course, you can. Well, not exactly.

This course goes over the theory and analysis of algorithms. The topics and material heavily follow the textbook, Algorithms . There is not so much a focus on actual coding, but we do sometimes use pseudocode and implement with python. Rather, it trains you to use the fundamental algorithms we've used, and combine and alter their methods to apply them to different problems.

* I took this course Fall 2020, contents may have changed since then

🏢 Structure

• Eight Assignments - 15% (of the final grade)
• Three Coding Quizzes - 10%
• Three Exams - 75%

Assignments

These involve written descriptions, and sometimes pseudocode, on how to solve a given problem. Analyzing its performance and verifying the correctness is also required.

• Dynamic Programming - Notation and methods to solve dynamic programming problems
• DP (Continued) - More problems in the domain
• Divide & Conquer - D&C problem solving and time complexity analysis
• D & C (Continued) - More problems in the domain
• Graph Algorithms - Search algorithms, sorting, and strongly connected components
• Graphs (Continued) - Max flow and more problems in the domain
• NP-Completeness - Problem class distinctions, proofs, and reductions
• Linear Programming - Applications, duality, and algorithms

Coding Quizzes

These are pretty standard problems that require you to implement methods which are then tested against hidden test cases. I won't touch more on these, as they more more-so short exercises than in depth projects.

• Knapsack - Use dynamic programming to solve the knapsack problem
• Find X - Find target x in an infinite array using binary search
• Kruskal's - Implement Kruskal's algorithm and Union Find to find the minimum spanning tree of a graph

Exams were standard- closed note to be completed in a short time period. The content and problems were similar to that of homework assignments, covering 3-4 weeks of material. In addition, there were multiple choice and short answer problems that touched further topics than the assignments, including but not limited to: cryptography, Euler's method and modular arithmetic

📖 Assignments 1 + 2 - Dynamic Programming

Dynamic Programming (DP) is an algorithmic technique for solving an optimization problem by breaking it down into simpler subproblems and utilizing the fact that the optimal solution to the overall problem depends upon the optimal solution to its subproblems.

The Fibonacci sequence is a problem that captures this well. For any input n, the solution is derived from solutions of subproblems.

F i b ( n ) = F i b ( n − 1 ) + F i b ( n − 2 ) Fib(n) = Fib(n-1) + Fib(n-2)

A vanilla recursive implementation would have every node in the above tree to be called, which is redundant. A common optimization is to use memoization with recursion (any DP problem can also be solved this way). Recursion is considered a top-down approach, as you start from the highest level and keep going down depths until you reach a base case. DP, on the other hand, is bottom-up, where we start from the base case.

Dynamic programming solutions have three main components:

• Define your subproblem. For Fib, this is equal to the solution at n n
• Define your recurrence. How can a solution at n + 1 n+1 be expressed in terms of smaller subproblems? For Fib, this is as simple as its definition
• What are your base cases? We need somewhere to start. For Fib, this is [0, 1].

I thought it would be fun to approach this section of my course reviews differently. Since the results of the homework assignments are typically dense written explanations, I'll instead work through a similar problem under the topic from Leetcode. The problems I pick are similar (some harder some easier) to what we'd see in a homework or exam, but keep in mind we wouldn't have to code them up.

The DP problem is Minimum Number of Removals To Make a Mountain Array . A mountain array has a strictly increasing sequence followed by a strictly decreasing sequence of numbers. For this problem, we need to remove the fewest numbers in an array to make it a valid mountain array.

Here is one of the sample test cases

This can be broken down into the common dynamic programming problem, longest increasing subsequence . We can remove elements in any order, so the problem is essentially finding an increasing subsequence followed by a decreasing subsequence. Removing the elements in between those yields a valid mountain array.

For a dynamic programming solution of LIS,

• Subproblem: D P [ i ] DP[i] = longest increasing subsequence that includes index i i
• Recurrence: D P [ i ] = 1 + m a x ( D P [ j ] ) DP[i] = 1+ max(DP[j]) where 0 ≤ j < i , a r r [ j ] < a r r [ i ] 0 \leq j < i, arr[j] < arr[i]
• Base case: initialize D P DP with all ones

To find the longest decreasing subsequence (LDS), we just need to sweep from right to left instead. Alternatively, we could change the comparator from less than to greater than in the recurrence relation. Running both on the example above gives arrays:

Now, to find the largest mountain, we just need to look for the shared point between the increasing subsequence and decreasing subsequence that yields the longest combination. This is the highest sum of the same index between both arrays- in this case, it is at index 5, where the sum is 3 and 3. Since they share the same center, we need to subtract 1, and the longest mountain is size 5! Subtracting this from the total length of the array gives the minimum number of removals.

This solution runs in O ( n 2 ) O(n^2) , since for the LIS, we pass through all previous elements for each index. There is an O ( n l o g ( n ) ) O(nlog(n)) solution that is possible.

📖 Assignments 3 + 4 - Divide and Conquer

The divide-and-conquer strategy solves a problem by:

• Breaking it into subproblems that are themselves smaller instances of the same type of problem
• Recursively solving these subproblems
• Appropriately combining their answers

The most common and probably well-known algorithm that uses this is probably merge sort. This sorting algorithm breaks down an unsorted array into two halves and then merges the two sorted halves.

The runtime complexity of this is O(nlog 2 _2 (n)). This is because for every level of merging, we pass through every element exactly 1 time, and there are log 2 _2 (n) levels, so the total number of operations is proportional to multiplying those two together.

The master-theorem expresses a runtime complexity for varying D&C problems.

The D&C problem is Merge K-Sorted Lists . We are given a list of K sorted linked lists, and we want to merge all of them into one sorted linked list.

This can be solved by straightforward divide & conquer similar to merge sort. You break down all linked lists until they are of size 1. Combining two sorted linked lists is the same general technique as two sorted arrays. Each level forward, two combined linked lists will yield one sorted linked list, until it is all combined and returned!

📖 Assignments 5 + 6 - Graph Algorithms

A wide range of problems in different domains can be represented concisely in graphs. A graph is defined by a set of vertices and edges which may or may not specify direction and weight.

The majority of operations within graphs that we encountered were:

• Search (DFS/BFS, Dijkstra's, MST, Strongly Connected Components)
• Flow-based (Edmund Karp, Max-flow mincut, ford fulkerson)
• Ordering (Topological sort)
• Manipulations (Removing, reversing, and adding edges)

We would typically use these algorithms as a black box with some modifications to solve for the problem at hand.

Here's a problem that does not seem immediately seem like a graph problem, Alien Dictionary .

There is an "alien" language that uses the english alphabet, but the ordering between letters is unknown (ex. instead of abcdef... it might be bpaoef... ). Given a list of words which are sorted lexicographically , return the order of the letters in this language. An example:

We know which character comes first one at a time, so we can map this relation for every single character to construct a directed graph. This can be constructed by comparing each word at a r r [ i ] arr[i] with that at a r r [ i + 1 ] arr[i+1] , and finding the first changed character. For ['wrf', 'er'], this is 'w' and 'e'. For ['wrt', 'wrf'], this is 't' and 'f'. The direction of the edge is second → first, so 'e' → 'w', and 'f' → 't'

Topological sorting for directed acyclic graph is a linear ordering of vertices such that for every directed edge (u, v), vertex u comes before v in the ordering. In this case, we want the direct opposite, so the furthest down is returned first. The direction is somewhat arbitrary, since you can return a reversed order, or point the edges in a reversed direction to achieve the same result.

There are a few methods to find the sorting, but to me the simplest is to use depth-first search, and I used that for my solution to alien dictionary. For each vertex, in any order, you run DFS on its outgoing edges, and after it returns for the current node, add the vertex to the solution.

If you first call the vertex at the highest level, then only after it traverses through the depths will it be added. Alternatively, if you first call a vertex with no outgoing edges, it is immediately added to the output. Both will yield the same solution, though vertices with the same degrees may not return in the same order. With this approach we get to ignore in-degree and out-degrees !

📖 Assignment 7 - NP-Completeness

There are many great resources out there which define and provide examples for complexity classes P, NP, NP-Complete, and NP-Hard, so I'll instead touch on the main topic for the class, which is reductions.

We can prove that a problem is NP-Complete by demonstrating that it is in class NP (can it be verified in polynomial time?), and showing that it is at least as hard as a known NP-Complete problem, by reduction.

A reduction from problem A → problem B can be done by showing that A can be converted to B, converting the solution from B back to A, and showing that a solution to B exists iff a solution to A exists. The conversions must be done in polynomial time. In this case, problem A is the known NP-Complete problem, and B is what we are trying to prove for.

Let's say we want to prove that the problem, clique , is NP-Complete. Given an undirected graph find the a set of vertices of size k where an edge connects every pair together. Application: what is the largest set of friends on Facebook where everybody is friends with each other?

We first prove that this is in class NP by showing a given result is a valid clique. For every vertex, we check that there is an edge connecting to every other vertex, and if any are missing, it is not valid. This runs in O ( ∣ V ∣ 2 ) O(|V|^2) time, where ∣ V ∣ |V| is the number of vertices.

Let's consider the known NP-Complete problem, independent set . Given an undirected graph, find a set of vertices of size k where there are no edges which connect any pair. Application: alternatively, what is the largest set of users on Facebook where nobody is friends with each other?

To finish the proof that clique is NP-Complete, we can show a reduction from independent set to clique. I won't prove all steps here, but at the high level, an independent set of graph G G is the clique of complementary graph G ′ G' . This conversion can be done in O ( ∣ V ∣ ∣ E ∣ ) O(|V||E|) time.

The homework problems and exams required some pretty clever conversions that are not as clear as the case above. We were provided a list of NP-Complete problems we could reduce from. There was a large focus on proper proofs that cover all the steps.

We're not exactly going to demonstrate a reduction proof here, but there are some NP-Complete problems on Leetcode. Find the shortest superstring is a problem that can be converted to the Travelling Salesman Problem . Given a list of strings, find the smallest string (the super string) which contains each string as a substring.

I'll first mention that the reductions we had to do for the course were not nearly as abstract or complicated as this.

So how is this a search problem? In constructing a minimum superstring, we want to maximize the number of overlaps that occur. By brute force, we can solve this in N ! N! time, so for the example we have, this would be 5 ∗ 4 ∗ 3 ∗ 2 ∗ 1 5*4*3*2*1 , which is checking every combination of the 5 strings and calculating the overlap.

Instead, we can represent this as a graph. Each input string is a vertex, and the edges are the overlaps from each vertex to the others . Once we calculate the overlap between every single string, we find the path between every string that has the highest value. This is because the highest overall overlap results in the smallest string. Now, this is the TSP, except we want the longest path, and we don't need to return to the original location!

This is as far as I'll go. A dynamic programming solution is the Held-Karp algorithm , which runs in O ( n 2 2 n ) O(n^22^n) time. This is still not ideal, but it is better than factorial time. I believe most deployed applications of TSP utilize an approximate solution when the graph becomes too large.

📖 Assignment 8 - Linear Programming

Linear programming is an optimization task where you are given an objective function to maximize, as well as a set of constraints, all of which are linear functions. We didn't spend too much on this topic in this course, but the focus was on breaking down problems and converting them to be standard form for linear programming, as well as some theory. Not so much on algorithms to solve on them.

A common problem that can actually be expressed by linear programming is finding the max flow of a graph. We are given a graph where each edge represents a maximum capacity of flow, and the source + destination vertices. What is the maximum flow that can be achieved, given flow never surpasses the capacity of an edge, and the outgoing flow at a vertex is always equal to the incoming flow (except at the source and destination).

Ford-Fulkerson is a well known algorithm to solve this problem optimally. We can formulate it as a linear program.

∑ ( s , v ) ∈ E f ( s , v ) \sum\limits_{(s,v)\in E} f(s, v)

subject to:

∑ ( u , v ) ∈ E f ( u , v ) = ∑ ( v , w ) ∈ E f ( v , w ) \sum\limits_{(u,v)\in E} f(u,v) = \sum\limits_{(v,w)\in E} f(v, w) for all edges except source & destination

f ( u , v ) ≤ c ( u , v ) f(u, v) \leq c(u,v) for all edges

f ( u , v ) ≥ 0 f(u,v) \geq 0 for all edges

Here, we want to maximize the sum of the flow. The first constraint means that, for every vertex, the incoming flow is equal to the outgoing flow. The second means that the flow at any edge is less than the or equal to its capacity. Finally, we want to ensure that the flow is non-negative.

We had a mix of higher-level problems to formulate into linear programs, as well as more algorithmic based, and taking existing linear programs and reworking them to fit under a modified problem.

⏩ Next Steps

Graduate Algorithms provides the theoretical and practical structure to begin to think about more complex problems. For further work, there are many directions one could go into. In addition to a breadth of topics, you can look into further mathematical analysis. Also, it would be interesting to find algorithmic optimizations not just for runtime complexity, but considering computer processor characteristics as well.

CS 7646 - Machine Learning For Trading

A comprehensive review of the content, assignments, and deliverables for the course, including technical indicators, optization, and application.

CS 6420 - Bayesian Statistics

A comprehensive review of the content, assignments, and deliverables for the course, including math, estimation through sampling, and real datasets.

Melon - Food Delivery

The improved food delivery service I tried to scale, but ultimately shut down after a few months of operations.

Georgia Tech OMSCS CS6515 (Graduate Algorithms) Course Review

To pass this class, you should

• digest everything written in Joves’s notes (he’s a TA and will release these notes gradually throughout the semester so pay close attention to his Piazza posts)
• join or form a study group of a handful of students
• dedicate at least 20+ hours per week to drill, memorize, and apply algorithms
• complete all the homework assignments, (easy) project assignments, and quizzes (these are all easy points and you’ll need them given that exams make up 70% of your final grade)
• drill ALL the practice problems (both assigned and extra ones published on the wiki) over and over again until you’ve memorized them

Almost failing this class

This class kicked me in the ass. Straight up. Words can barely described how relieved I feel right now; now that the summer term is over, my cortisol levels are finally returning to normal levels.

I’m not exaggerating when I say I teared up when I learned that I received a passing grade. I barely — and I mean barely (less than 1%) — passed this class with a B, a 71%. Throughout the last week of the summer semester, while waiting for the final grades to be published on Canvas, I had fully prepared myself (both mentally and emotionally) for repeating this class, level of anxiety and stress I haven’t felt throughout the last 3 years in the OMSCS program.

Other students in the class felt the same level of despair. One other student shared that he has:

never felt that much pressure and depression from a class in [his] entire academic career.

One other student definitely did not hold back any punches on Piazza:

I am going to open up a new thread after this course finishes out. I am tired of the arrogant culture that is in this program and specifically in this course! There is a lack of trying to understand other perspectives and that is critical for creating a thriving diverse intellectual community.

So yes — this course is difficult.

All that being said, take my review with a pinch of salt. Other reviewers have mentioned that you just need to “put in the work” and “practice all the assigned and wiki problems”. They’re right. You do need to do both those things.

But the course may still stress you out; other courses in the program pretty much guarantee that you’ll pass (with an A or B) if you put in x number of hours; this doesn’t apply for GA. You can put in all the hours and still not pass this class.

Before getting into the exam portion of my review, it’s worth noting that the systems classes I mentioned above play to my strengths as a software engineer building low level systems; in contrast, graduate algorithm predominately focuses on theory and is heavy on the math, a weakness of mine. Another factor is that I’ve never taken an algorithmic course before, so many of the topics were brand spanking new to me. Finally, my mind wasn’t entirely focused on this class given that I had quit my job at FAANG during the first week this class started.

Okay, enough context. Let’s get into discussing more about the exams.

As mentioned above, do ALL the practice problems (until you can solve them without thinking about it) and really make sure you understand everything in Joves’s notes. I cannot emphasize these two tips enough. You might be okay with just working the assigned practice problems but I highly recommend that you attempt the homework assignments listed on the wiki since questions from the exam seem to mirror (almost exactly) those questions. And again, Joves’s notes are essentially since he structures the answers in the same way they are expected on the exam.

Exam 1 consists of 1) dynamic programming and 2) Divide and Conquer (DC)

Read the dynamic programming (DP) section from the DPV textbook. Practice the dynamic programming problems over and over and over again.

Attempt to answer all the dynamic programming (DP) problems from both the assigned practice problems and all the problems listed on the wiki. Some other reviewers suggest only practicing a subset of these problems but just cover your bases and practice ALL of practice problems — over and over again, until they become intuitive and until you can (with little to no effort) regurgitate the answers.

For the divide and conquer question, you MUST provide an optimal solution. If you provide a suboptimal solution, you will be dinged heavily: I answered the question a correct solution but was O(n) and not O(logn), I only lost half the points. A 50%. So, make sure you understand recursion really well.

Exam 2 focuses on graph theory. You’ll likely get a DFS/Dijkstra/BFS question and another question that requires you understand spanning trees.

The instructors want you to demonstrate that you can use the algorithms as black boxes (no need to prove their correctness so you can largely skip over the graph lectures). That is, you must understand when/why to use the algorithms, understand their inputs and outputs, and memorize their runtime complexity.

For example, given a graph, you need to find out if a path exists from one vertex to another.

To solve this problem, should know explore algorithm like the back of your hand. You need to know that the algorithm requires both an undirected (or directed) graph and a source vertex as inputs. And the algorithm returns a visited[u] array, each entry set to True if such a path exists.

That’s just one example. There are many other algorithms (e.g. DFS, BFS, Krushkal’s MST) you need to memorize. Again, see Joves’s notes (recommendation #1 at the top of this page). Seriously, Joves, if you are reading this, thanks again. Without your notes, I would 100% have failed the course.

Understand the difference between NP, NP Hard, NP-Complete.

I cannot speak much to the multiple choice question (MCQ) since I bombed this part of the exam. But I did relatively well on the single free-form question, again, thanks to Joves’s notes. Make sure that you 1) Prove that a problem is in NP (i.e. solution can be verified in polynomial time) and 2) You can reduce a known NP-Complete problem to this new problem (in that order — DO NOT do this backwards and lose all the points).

Some students will cruise this class. You’ll see them on Piazza and Slack, celebrating their near perfect scores. Don’t let that discourage you. Most of students find this topic extremely challenging.

So just brace yourself: it is a difficult course. Put the work in. You’ll do fine. And I’ll be praying for you.

Intro to Grad Algorithms

CS 6515 - Spring 2021

CS-6515 - Introduction to Graduate Algorithms

Ai generated title.

The course could be lot better. You will learn how to format the your algorithms in the specific way they want it.

This was my 8th course in the OMSCS program and it was the hardest course so far with one other class a close second. My undergrad was not CS or CSE but I am a self taught programmer with 13+ years experience as a software developer. Thus, the coding projects were quite easy and essentially help your grade, the hard part is the exams.

This course was quite difficult for me due to a few factors: the pace is fast unless you’ve already done an algorithms course before, the grading seems harsh — easy to lose almost all the points on a problem with a simple mistake hence some students repeat the course, it’s essentially like a math class, lastly not know how much to study (burnout). The HW and practice problems help you for the exams. Master them and Joves notes.

My suggestions for success is understand the fundamentals, no, master the fundamentals of each topic: DP, Divide and Conquer, Graph algorithms, Linear programming and NP reductions. Also, don’t skip asking for a regrade on HW if something was incorrect in grading . It could cost you a letter grade if you’re not careful so don’t be too relaxed with a seemingly small grading issue. Also don’t just do it for spite as you can lose even more points.

For exam prep do all homework problems and practice problems then do more. Understand the fundamentals of the topics for the essay questions as you will have to know the algorithms like the back of your hand or you will miss a lot of points. This is not a class where you can get by with a high level overview of the topic, you need to be thorough. For MCQ review the lectures and the book chapters.

Exam Difficulty for me was Exam 2 > Exam 1 > Exam 3

You will see some students boasting that they got 100% on the exam and saying it was too easy while the exam average clearly is a C or lower on the exams. Ignore the A plus boasting students and just study hard don’t let their arrogance throw you off if you are struggling or make you feel inferior after all the work you put in, they likely already knew most of the material before the course or are fast learners. Don’t compare yourself to them. Don’t sweat it.

Lastly, the class IS hard but not crazy hard so don’t get siked out by some reviews as I did and make stupid mistakes on the exams due to anxiety. Just study smart and you will do fine, believe in your work effort and don’t quit once you see the harsh grading for exam 1. You can still do it.

I knew right after the first midterm that I should drop. Normally I would have dropped and spent the rest of the semester preparing to repeat, but this was my last course and I didn’t want miss graduation. I had also heard that the first test was the hardest and that things could only get better. I have always been an above average student, even in my previous graduate studies at this same school. I knew I just had to try harder, so I went from 20 hours/week to 30.

There was some improvement in my second midterm, though I still came below the mean. I started questioning why in spite of my effort I’m still scoring poorly in every assignment. Come the third test and I bombed the worst. I asked myself, why do I feel like one of those kids who finishes high school unable to do algebra? The answer to this is that this was my first algorithms course ever. You see, the typical CS undergrad takes about 3 of these courses, and I walked into this not even knowing what a binary search was.

My disappointment isn’t with the course, nor with the instructor, it’s that the program was supposed to prepare me for this but didn’t. I was hardly the only person in this class taking his first algorithms course and we all did poorly. GT let people like myself into this program and knew that we’d hit this wall, yet they didn’t offer a way to bridge the gap.

How else could they improve this class? The grading is dastardly and inconsistent. Rubrics should be made known, test problems from past semesters should not be re-used, and TAs shouldn’t be grading 200 papers each. Was it all bad? No, Joves notes were great, Rocko’s office hours very helpful (I would say mandatory), and Dr Brito gets kudos for holding his own office hours (which hardly any professors do).

Any advise for passing? Yes, take a semester off if necessary and take Stanford’s 4 course sequence with Tim Roughgarden on Edx. Also, dispute every single point deduction. I hate to do this to the TAs, but their grading is error prone (how could it not be when you’re running a grading assembly line). You don’t want to end up getting a C on account of 0.1%, which is about as much as a point on a test. Finally, don’t wait until your last semester to take this class. Take it after your two foundationals are out of the way. Nothing in the curriculum will prepare you for this.

In the end I passed with a 70.02%. Did I learn much? Not as well as I should have. Does the grade reflect my effort? Not by far. What’s next? Well, I won’t be applying at Google, or even bothering with LeetCode yet. I will be taking my own advise and doing Roughgarden’s courses. After that, we’ll see… I hear Google also needs TPMs.

If you do not have a CS background or have taken an algorithms class prior this class can be quite challenging. Rather than leave my opinions or repeat things others have said about format, I will just leave a few tips.

• Study ahead of time. Look at the prerequisites and make sure you have some basic understanding of some of the topics. This will go a long way in relieving stress throughout the semester.
• If you have time, do some real simple Dynamic Programming, Divide and Conquer, and Graph problems before taking the course. If you find something particularly challenging study in advance and it might de-stress a week for you.
• Do a Big O notation crash course before you start.
• Do the practice problems. They really help reinforce the material and what is expected.
• Do the practice problems before exams if you didn’t get to them during the week, or even if you did.
• Be careful about spending your time on problems that are not assigned. They can be really helpful for basic understanding but also could touch on stuff that will never make it on an exam.
• Don’t stress during the exams. I messed up one of the exams because I was stressing over something silly. By doing so I missed a key point and did worse than I should have.
• I used online flash cards and they really helped for remembering things like algorithms, runtime, etc…
• Attend or watch the office hours. The TAs go over EVERYTHING in detail. Office hours also have exam prep sessions. The TAs want you to succeed.
• Avoid feeling demoralized by the folks in slack who seem to get everything immediately. Most of us didn’t get immediately and had to work at it.
• Finally and very importantly, get in a study group with people you can talk with. It makes the hard weeks easier and the good weeks even better. My group met once a week over discord and discussed the problems (within the bound allowed by the class). Without that group I would not have made it through.

This class stretched me further than most others but I feel like i have learned a ton and it has already benefited me in the way I solve problems.

This course need significant re-structuring.

Overall, if you don’t give up, can keep your frustration in control…….”B” doable, “A” might be little tough. Your grade do not reflects your understanding….it only reflects if you screwed up in a exam or not.

Rocko, Jove & Professor were very helpful. Like the lectures, TA Office Hours, Projects, Quizzes, MCQ section of exam.

HW & Written section was worst…..encourages memorizing, writing in a particular way to get good grades. Students get punished severely for outside the box thinking, writing style. Students who’s first language is not English, puts them in dis-advantages. Here are my logic for removing/significantly changing the written section of HW & Exam.

• Due to writing style, it creates confusion what student writes & what grader interprets. Similarly, student can easily go off the track if they interpret the questions differently. No matter how well written the questions is, it’s very easy to get confused in exam since no option to clarify what actually been asked.
• Had so many “Tomato” vs “Tomata” situations. Since, for a given problem can have different solution……..it’s easy to get punished if Grader don’t buy your solution. Too much Human Factor.
• For the similar mistakes, different grader gives different deduction. Understand, it’s honest judgement/mis-judgement by grader. It’s very difficult to maintain the rubric for problem with open ended or too many different types of solutions.
• All those proves have little use in real world outside academia. The amount of time students spent on this, could be used for learning something useful.
• I was in a study group where noticed most smart student or student with conceptually better understanding…..do not get good points in those written HW/Exam questions. Student’s who memorize the Jove’s template do much better.

Suggestions for improvement:

• 75% points on Exam is too harsh.
• Either totally remove / significantly reduce written HW & exam questions.
• Exam should be MCQ, fill in the blank questions OR questions with unique answers. It can easily be done, just need creative thinking & willingness to change.
• Quizzes & Coding Projects were very helpful. Forced to revisit lecture contents & understand to solve those. These should have more weights. May be add more quizzes and complex coding projects.
• In every assignment, HW, quizzes, exam questions……….. Please justify, how this will be useful in real world.

Some graders are there just to fail you. If you take this course, you will see what I mean.

This was my last class of the program, and also the first class I’ve had to repeat. In Fall 2021 I failed with a C, and in Spring 2022 I passed with a B. If you don’t put in the time to understand the material, you will not do well. That part is on you.

Now for the part that is on the instructional team, grading. You’ve seen it 100 times already, grading is inconsistent. The staff contend that they “calibrate” errors they’re seeing in submissions to come up with a rubric and the corresponding penalties. There was also mention that while you’re not told which TA graded your submission, they are assigned randomly instead of grading the same students the entire semester. Nonetheless, be ready for hefty penalties that are seemingly at the command of the grading TA’s discretion. Clearly, a published rubric would solve this problem, but the staff refuses to provide one for any assignment.

Also, the staff said very contradictory things such as: “this is NOT a math class”, then, “this IS a math class!”, then “we will not try to trick you on the exams”, we had several tricky questions both semesters, clearly aimed at mass confusion. Don’t expect points back if you’re confused and select the wrong answer, you’ll be the “dumb one”. Be prepared to hear “you’ll be sad” a lot.

This class was designed to be difficult, and as such, prepare yourself for a stressful few months. The 75% exam weight will be your biggest enemy. The first time around, I took the final exam hoping to get my grade up to a B, but that was a bust. This time around, I didn’t need to take the optional final because I had a B before the final exam window opened. If you’ve taken an algorithms class before, you may breeze this one, but, you must answer in the expected format or “you’ll be sad”.

Tip: If you feel that you may be in a position to repeat the course, do not drop, and save EVERYTHING (if your GPA can take the hit). Save all the examples so you can study them and understand the details. Write down all exam questions, save office hours videos, save your homework answers, save your quiz answers, save your project code. Having this available to you the next time around will save you a lot of time, and allow you to practice more problems and understand the concepts.

This was my eighth course in the OMSCS program. I took it during the Spring 2022 term. I didn’t have any real algorithms course during my undergraduate, and if I did, I probably forgot most of it in the 15+ years since getting my degree. It is encouraged to form teams to work on homework concepts, and this is definitely crucial as you will need a support system. The class has 7-9 polls (quizzes) projects, 3 exams, 10 homework assignments, and 3 coding projects. There is an optional final exam. This course is definitely a struggle and battle for the grade you will get. Unless you work with algorithms in your profession or have taken the class (or similar class) before, be prepared to work and invest some serious time into catching up and keeping up.

• Homework (10%) : There are 8 homework assignments. These are focused on the lecture and reading material for the current week. Normally, there are some ungraded sample problems as well as 2 graded problems. During the mid-week office hours, the answers for the ungraded questions are discussed and released, to give you an idea of how to find a solution as well as the expectation of the structure of your answers. You have 1 week to complete the homework, and the solutions must be typed and submitted…. you are not allowed to turn in handwritten solutions. This can be a challenge when trying to type out algorithms and graph information into Word or in Latex format. You are not given a rubric or expected performance of your algorithms. If you come up with a solution which takes O(n log n) and they expected better, no matter how correct your answer is, you will lose points for having a suboptimal algorithm.
• Polls/Quizzes (6%) : There are 7-9 quizzes (sometimes referred to as polls). These normally consist of 1 question, and each poll/quiz is worth 1 point. There is no time limit and open everything. You can actually start the quiz, navigate away from it, and finish it later. Also, you get 2 attempts at the quiz, unless it is a T/F quiz, in which case you only get 1 attempt. Mostly easy points, if you understand the material. An RSA quiz was added, consisting mostly of modular arithmetic. It counted for 2 of the total points available for the polls/quizzes.
• Coding Projects (9%) : There are 3 coding projects. These are very simple and straightforward projects. They involve implementing some algorithm discussed during one of the weeks. The language of choice is Python. You are normally given empty functions, and you just have to fill in the details pertinent to that function (with limited guidance and vague expectations I might add). Project 1 was the Knapsack algorithm. Project 2 used Divide and Conquer to find a given index within a sorted, infinite array in a given number of lookups or less. Project 3 was using path compression and Kruskal’s algorithm.
• Exams (75%) : There are 3 required exams worth 25% each. These are not cumulative and cover material since the last exam. They are closed everything. You have 2 1/2 hours to answer 8 multiple-choice/true-false questions and 2 open end (free text) questions. These questions are very similar to what was asked on the homework assignments. You are allowed 5 sheets of paper. The exams are proctored through Honorlock.
• Final Exam : The format of our final exam only consisted of 3 free-text responses with a 3 hour time limit. The only difference is the final exam is cumulative. If you have an A at the time of the final or taking the final won’t bump you up to the next letter grade, you are not allowed to take the exam. However, if you don’t have an A, you can take the final, and it will replace the lowest of your other 3 exams (if you score higher on the final than one of the other exams).
• Miscellaneous Stuff : There is a curve in the class, which can get larger if need be. Initially, A=100-85, B=85-70, C=70-50, D=50-40, F=40-0. They do not round, so if you get an 84.9999, you get a B. Again, the “cutoffs might be adjusted, but only in the downward direction (to make letter grades higher).” The final letter grade cutoffs for Spring 2022 were: A=100-82, B=82-67, C=67-47, D=47-37, F=37-0.
• Homework : The homework can be a nightmare. Be prepared to read a couple hundred comments in Ed for each homework problem and what is being asked. Be sure to type out your answers and not not write and scan them into a document. The tasks are normally: explain your algorithm, explain why it is correct, and analyze the runtime. For some of the questions, you will have to decipher what the question is asking as some questions can be a nightmare due to the wording.
• Lectures : The lectures are from when the class was originally created. They seek suggestions on making it better, but it is obvious they have no intentions on updating it any time soon. Several of the lectures are nothing but proofs, but when you get to the homework, you are expected to know how to solve a problem after having only been exposed to proofs. You may find yourself many times trying to learn the material on your own as the lectures may be close to useless.
• Textbook : There is a required textbook. It is Algorithms by Sanjoy Dasgupta, Christos Papadimitriou, and Umesh Vairani, often referred to as DPV. The ISBN is 9780070636613. There is also a book some people will reference to help in understanding algorithms. It isn’t required, but can be helpful. You may be able to find PDF versions of these books online, if someone doesn’t post a link in Ed.
• Projects : The projects are interesting and relevant to the course. They show how to take various algorithms and implement them. Most of the coding can be done in a fairly short amount of time. This is especially helpful because the week the project is due normally has a homework assignment due as well.
• Exams : There are 3 exams, and they are killers. Each exam counts for 25% of your grade. If you are able to take the final (do not have an A average at the time of the final), the final will replace your lowest exam if it will bring your grade up. The difficult part about the exams is they are similar to the homeworks. If you don’t understand the homework, it will show on the exam. Also, it is stressful knowing that, while you may have spent 4 hours coming to the correct dynamic programming solution and typing it out in Word, you now have about an hour to do the same thing on the exam. That is, the exam is 2.5 hours long with 8-10 MC/TF questions and 2 free text answers. If you spend 0.5 hours on the tricky MC/TF questions, that leaves you 2 hours to solve 2 questions by finding their formula and typing out your response.
• Professor and TAs : The entire teaching staff was pretty decent. Rocko definitely has a passion for the course, but he can be pretty blunt and short at times. Joves is amazing. He releases the notes he took when he was a student in the course. They are vital and should be studied and understood in depth.
• Overall Grade : I put a considerable amount of time in this course (over 293 hours to be exact). In the end, my grade was 68.46, which got me a B.
• The average for exams is barely the cutoff for a B (i.e. the average for Exam 1 was 71.9, Exam 2 was 75.7, and Exam 3 was 73.98)
• You use the original videos created for the course and do not update to fix identified problems
• Students have to go watch videos and read articles on how to accomplish tasks because explaining proofs doesn’t really explain how an algorithm actually works
• Students have to read through 300+ comments to understand a homework spec because the provided spec is so vague, or students have to dig through the comments in 1 of the 3 Ed posts for a given homework just to find out the expected format of the answers because they were not outlined on the homework
• Lectures incorporate a “quiz” with no explanation on what is expected as an answer and the “answer” to the quiz is a screen with the answers and zero explanation on how to solve before or after the quiz
• You accept 0 reasons for not being able to take an exam
• A student is looking forward to having a medical procedure performed instead of dealing with the class
• You have to curve a class to where at least a 67 is a B

Get ready to have little to no social life, put stress on you marriage (like myself), and spend time teaching yourself concepts just to grasp the material just enough to edge out with at least a B. This class is completely theoretical. Don’t expect it to be a lot of coding or application of concepts. Be prepared to think from a higher, more conceptual level. If algorithms, Big-O notation, logarithm, graph theory, modular arithmetic, Dynamic Programming, Divide & Conquer, algorithmic proofs, Linear Programming, or NP-Completeness are new or rusty to you, brush up. I cannot express this enough… review those concepts. If you come up with a O(n log n) solution and the instructional staff expected O(n), you will lose points, even if you have a correct solution. Listen to Joves. Study, understand, and maybe even memorize his notes. Give him thanks for all his help and work. Be part of a good team, and communicate with them. Do the ungraded sample problems. Do some of the exercises at the end of the chapters. Stay up-to-date or work ahead. Be prepared to spend a considerable amount of time dedicated to this course. Prepare for the stress and sometimes morale crusher. Prepare to spend a lot of time studying for the unfairly weighted exams. In the end, the course teaches you a lot of concepts and alternate ways of improving on performance and efficiency of algorithms. Don’t judge your competencies by your grade or the grade of others. Some people get it pretty easy, and others will struggle. Just push through, learn, curse, kick, and scream along the way. Just keep going.

Honestly, the class is not nearly as hard as some of the other reviews have made it out to be. This semester I worked full-time, was enrolled in another class, and was traveling a good number of weekends to interview at various graduate programs - I devoted ~7 hours a week (about an hour a day) on average to this course, including watching the lectures. It was certainly a difficult class but totally manageable as long as you study the provided material. My background is not in CS but I have about 5 years of SWE industry experience so YMMV.

For the exams I reviewed Joves’ notes and skimmed the homework for the unit. I didn’t do a single practice problem for an exam and ended up earning a strong A (not endorsing this approach by any means, just pointing out that targeted studying is all that’s needed for exams). I also didn’t read any of the assigned chapters in DPV and was fine. Exam grading was fair, expectations for answer format for the long-form questions was clearly stated (contrary to what some other reviewers are saying…)

I found the lectures engaging and they piqued my interest in algorithms in general. In particular the FFT module was eye-opening for me (is there anything that algorithm can’t be used for?). The content on NP completeness was also of great quality. This was my last course in my OMSCS degree and I can confidently say it was the best of the 10 classes I took.

The only minor gripe I have with the course is the TAs. HW grading, as mentioned in many other reviews, is really all over the place. For example, on two separate HWs I was docked 6 points and 2 points for making the same mistake: analyzing the runtime wrong. Didn’t affect my overall grade, but annoying when each hw problem is out of 20. The head TA has a bit of a superiority complex that shows up in responses on Ed Discussions (many of my classmates made the mistake of asking stupid questions).

This was definitely a difficult course, but I enjoyed every bit of the material. This is the type of quality course that I expected from a graduate degree.The grading is definitely tough & requires a keen attention to detail.

Keys to success:

• watch the lectures multiple times.
• YouTube some of the concepts as they are presented better there in many cases. FFT, in particular, is presented really well in some YT videos. Also, Abdul Bari has a great series of videos on a lot of the algorithms from the course.
• attend/watch the OH with the TAs & Dr Brito.
• do not let yourself fall behind in the material.
• practice, practice & practice the problems thoroughly until you get it.

Don’t let the negative Nancys & Nicks in the reviews scare you. This is a good course & you will learn a bunch!

In order to ace this course one needs to deeply understand the topics. The exams test one’s ability to generalize, and apply the concepts. Anything that is shallow will get exposed by the exam and cause sadness. Dr. Brito keeps the exams fair, and focuses on fundamentals. If you cover the fundamentals(not the fancy stuff) really well, and manage exam related anxiety/stress then you’ve got this! There is a lot of misinformation about this course in the other reviews related to grading, unfair nit-picking, study group is a must etc.

TA/IA team is rock solid, just pay attention in OH, practice a lot, and have faith that everything is designed in order to help you succeed. I had a complete mental breakdown on the first exam(my fault), and still ended up with a grade I wanted without needing to take the final exam. Please do not panic, you’ve really got this! Just have fun with the course, and a delightful team of instructors, optimize on learning (grades will follow).

I put difficulty as very hard but it’s not from the lecture materials. The contents they cover during the course is not even challenging. The “very hard” part is the way they evaluate students. It’s my “strongly disliked” part as well. The exam grading is extremely harsh on purpose and random. They will force you to write the answers in a specific format and if you miss any, they will simply take off points. When each exam weights 25 percents of your final grade. The point reduction from formatting mistake hurts. I understand there are thousands of pages they need to grade, so a certain formatting is set for their convenience. But, I am just curious why they don’t make the exam having all multiple choice questions with various level of difficulty. That way, there is no confusion and fury on highly randomized and subjective grading. They will probably defend their current system with numerous pretty-sounding reasons like how they do when it comes to regrade request. Simply a worst learning experience during the OMSCS.

As my 5th course in the program, I can say I learned a lot from this class, while it’s also my least favorite.

What’s good:

Lecture videos and textbook; Rocko’s Office Hours; Joves’ Notes; and some comments left by TA in my HW and exam grading.

What’s bad:

In general, the instructing team gave me an impression that they hold students as their opponents. They habitually talk down to students. For example,

“A reminder that the exam is considered confidential - information regarding the exam content may not be shared in any public forum (#slack, WeChat, etc).” This is a blatant violation of 1st amendment right. I do not believe the TAs have the legal power to stipulate what students can and cannot say.

“You are prohibited from discussing the content of the exam in any public forum such as #slack. Please restrict your discussions to this forum”: Same as above.

Also, TAs’ grading is wildly unpredictable. I guess they feel free to say whatever they wanted to say, because they don’t have to reveal their identity. This anonymity might seem a safe harbor for TAs, but eventually it hurts their performance and their reputation, badly. They can sometimes even get verbally violent if you challenge them about your grading.

I feel working as TAs for this class is tedious work. They have to deal with hundreds of students, and not all students are smart. A lot of them ask dumb questions. I get it. I would lose patience too. This might probably the reason why TAs are so easily irritated in their interaction with students.

Many sentiments reflected in the reviews are very accurate.

Grading: haphazard There is no consistency in grading. Even if your answer is correct, but they are expecting a specific word, you’ll lose a lot of points. e.g. if more than one solution is correct, “Any solution obtained …” is docked 4 points off. Expected word is “Pick one of the solution …”

Exams: It all boils down to whether you can come up with relevant transformations or not and whether you can remember and follow exact steps expected by Grading team. Even if your answer is correct - but does not match Rocko’s solution, you’ll be docked points heavily. While Rocko states that we will consider the solution, you’ll have to present your solution to peer feedback. Once assessed, there is very little chance that you may get a upward grade movement, but there will be a downward movement. The TAs will say anything to defend their comments. That said, some TAs provide proper feedback.

Practice homework assignments in “notepad” - single font, no size difference – no formatting. The graders may not read through the entire solution or make an effort to understand it. They have 100s of assignments to validate within a few days. It is your responsibility to make sure you present what you want them to see.

In exam, table in canvas for demonstrating the working of algorithm logic, exported to gradescope messed up completely. The grader knocked off points severly and commented “I do not understand this, hence this must be wrong”. Did not even make an attempt to read through the content.

It always helps to get full points in Projects and Polls as they are not subjective.

Make sure to pray you get a good grader.

If you perform bad on the first exam, there is always chance to recover, but if your assignments and exams 1 have been class median or less, it is recommended to register for the upcoming terms.

The attitude of TAs and Graders are bad if you ask clarifying questions or want to understand more.

From earlier statistics, about 10% of students drop after exam 1 and about 5% get grade C or less. In a class of 900, 15% that is about 135 students !!

This class leaves a very bad taste at the end of OMSCS.

Anyhow, Good luck with your course.

Honestly, this class was both terrible and good at the same time, but my main takeaway was that it was much easier than I expected (based on the reviews here). I was stressed out the entire semester because I was dead set on getting an A (getting an A is not easy), but you can very easily get a B with minimal effort. All you need to do:

• Keep up with the lecture schedule and homework. Make sure you have a high level understanding of the lectures when you watch them. You don’t need to understand the math in detail, a high level understanding is enough.
• Cram Jove’s notes during the weeks of the exams. This is really all you need for this course.
• You should at least get a B or higher with only 3 weeks of intense studying.

I put in 30 hrs a week (homework, lectures, studying) leading up to the first exam, 10 hrs a week before the second exam; I was burnt out by then, so I only studied a day before the third exam. I still got an A in the class. And I’m not good at Algorithms. I’m not stupid, but I’ve bombed every technical interview I’ve ever had. In fact, I’ve never gotten a job offer from an algorithm-based interview. Also, I did not study CS undergrad, so I had never taken an Algorithms course before this one.

This was actually my least favorite class in undergrad or graduate school, but most of my issues with the class are really GT’s fault, rather than the class’s fault. My main complaint about the class itself would be that the grading was too subjective and random. Otherwise, this course is ok overall. I did enjoy the material. The TAs that you see (posting and OH) are active and generally helpful. Students in this class are generally more helpful than they are in other OMSCS classes.

• Easy to get a B or higher
• Helpful and active TAs on Ed/Slack (especially Joves)
• Grading is too unpredictable
• Having most of your grade depend on having 3-4 good days, rather than consistent effort over the semester (a lot of other OMSCS classes are project based, and I’ve come to appreciate that)

I spent my entire degree worrying about this class and it turns out it is actually OK. Not too easy and not too hard. I got an A in it with a moderate amount of work put in. But whether you find this class difficult and stressful will depend on a couple of things:

Are you familiar with DP and Graph algorithms already? This class goes over these topics quite quickly. DP was only 2 weeks of the entire semester, yet you are expected to be an adept at it by the time you take the exam. Luckily I already knew quite a bit of DP and Graphs before coming to this class so I did not find this very challenging.

Can you clearly explain your algorithm in english? 3/4s of the class is about writing essays where you explain your algorithm in words instead of pseudocode. If you are not a native english speaker you may struggle with this. Even if you know the answer to the question, you need to be able to properly explain it in words clearly and organized so that the TA grading you can understand your logic. TAs are not magical beings who can read your mind, you need to explain your algorithm as well and simply as you can.

Below I give a couple of tips to succeed on this class

• Watch the lectures a semester ahead before taking the class. Part of the reason people struggle is because there is so much material covered in the class, and they go over it quite quickly. There are like 10 topics and the go over each in a week or two. Watching the lectures ahead of time (and taking notes so that you can review them when class starts) will allow you to focus your time on doing practice problems and preparing for the exam instead of watching lectures.
• Study DP and Graphs before starting this class. You do not have to be an expert, but having a good overall understanding of these topics before the class even starts will make things less stressful and give you more time to practice as well.
• Practice as much as you can. Algorithms is a topic that only comes with practice.
• Do not waste your time on leetcode. I personally think leetcoding is useless for all topics covered in this class except DP.
• Read Joves notes very carefully. He goes over every nook and cranny of all topics covered in class. Pay attention at how he writes the algorithm solutions and pseudocode, you will want to mimick it on the exam.
• Study very hard for Exam 1. If you do well on Exam 1, you will not be too stressed for Exam 2 and Exam 3, allowing you to be less nervous and perform better. Your experience and stress in this class will probably heavily depend on your score for exam 1. However, do not be disappointed if you perform poorly on it either. I saw many people do bad on it and still pass the class no problem.
• Join a study group. Everyone is on the same boat as you, and their encouragement can help you keep going in times of stress.

Overall I enjoyed the class. I thought it would be much harder than it actually was. In fact, i think it was a pretty easy class, but I think a medium score is more representative due the wide range of student backgrounds and due to the stressful nature of an exam-based class. It is easy but stressful, if that makes sense.

Least favorite class in the entire OMSCS (will get an A in it). At most this is a half-hazard undergrad intro to algorithms course. The idea this is a graduate class is laughable. If you struggle in this course, it is not a representation of you or your ability to learn algorithms properly but rather a representation of how poorly designed this course is.

• Grading is all over the place. 100% guarantee you could turn in the same assignment to different graders and get completely different outcomes
• Lectures are terrible and outdated. Also tons of material that the class doesn’t even bother touching upon. The idea that this class relies so heavily on Joves notes is telling of how lazy the instructors truly are
• Instructors are more interested in you memorizing patterns rather than you learning actual algorithms
• Like 90% of the class ends with an A or a B so we can all pretend we are smart and learned a ton when in reality it couldn’t be farther from the truth

Overall: Unfortunately most people need this class to graduate so you can’t avoid it but if you are at all interested in actually learning algorithms and applying your knowledge, this class is the farthest thing from it. Once again, this isn’t a shot at the TAs. I enjoyed them overall if there was any silver lining to this course

This was my 8th class in the program (CN, IHI, GIOS, CP, AI, KBAI, VGD, GA). I’ve only taken 1 undergraduate data structures course. My only preparation was buying & reading the textbook early. I am not a math/CS/CE major. I did not need to give up my personal life (I bought a condo & moved early in the semester). I achieved a strong A . I say all this to emphasize that you don’t need to already be an algorithm expert to perform well, you just need to dial in to expectations & get it right the first time .

I am in the Interactive Intelligence specialization and had many internal debates about voluntarily facing the stress & grading of this class. My justification was: a B or even a C in GA is more valuable for my career than an A in SDP. This is a rigorous & demanding math class, but I’m pretty sure the undergraduate algorithms at UCSD & Berkeley (same content & textbook) use much harder problems.

I want to address the main question first: what is up with the grading? The TAs have explained that every deduction is calibrated based on the frequency across the class, the severity of the error, and the magnitude of runtime impact (if applicable). Multi-part questions grade each section independently which can help or hurt your grade based on the nature of the error. The TA team makes an honest effort to mitigate trivial & common errors. This also means there is no answer to whether “correct & slow” is worth more/less credit than “incorrect & fast”. For some problems there are near-infinite possible solutions if the solution is correct & intelligible, established through proper formatting. The best option is to choose the obvious & simplest approach to maximize partial credit because it’s way easier to understand where the solution falls short. Yes, this system includes subjectivity and variability, but I haven’t seen anyone offer a better alternative without full autograding.

If you need to submit a regrade request, you should strive to be as objective as possible. The TAs are not antagonistic, but they will reject any appeal to “fairness” if you cannot construct a logical argument to counter the deduction & grading comments. Implications do not exist in this class . Required info is either provided in the solution or it isn’t, so “I meant…” arguments will almost always get rejected.

The grade cutoffs for Spring 2022 were adjusted by -3:

• A = [82, 100]
• B = [67, 82)
• C = [47, 67)
• D = [37, 47)
• F = [0, 37)

General Tips

• Joves’s Notes. Joves remains a TA as of Spring 2022 and his notes are still unofficial. Joves asks that they remain private to the class. They are so useful because they demonstrate the minimum content required for full credit , whereas the official solutions provided by the class are verbose & unorganized (and occasionally had mistakes or missing required info). The fact that these notes aren’t an official resource is frustrating and jeopardizes future iterations of this course if they ever become unavailable.
• Yes to Office Hours. The Head TA & the Instructor each hosted a Office Hours section most weeks to review the content and solutions from the previous assignments. You should treat these as mandatory: they provide many additional hints on expectations & potential problem scope.
• Don’t sweat most of the proofs. For the in-depth topics (FFT, Image Segmentation, Approximation), you don’t need to master most of the proofs demonstrated by Dr. Vigoda; understanding the implications is sufficient. This is not a proofs-based course. The exception is NP-Completeness with reductions.
• Study Groups… You’re allowed to talk about answers “at a whiteboard level” with a private group. Most of my peers couldn’t eloquently explain their approaches, so the quality of the discussion was usually better on Ed.
• Carve out time. I took a day off work to study for each exam by rewatching all lectures & reviewing all relevant problems from DPV. You could get lucky and review the exact problem in DPV used on an exam…
• Find the “expected” approach. Our toolbox is limited enough that any given problem has only 1 or 2 straightforward solutions, with minor variations. There are near-infinite possible solutions, but most will be very hard to explain clearly for full credit. Creativity will almost always hurt. For most in-scope problems, it should be immediately obvious which approach is expected; the other half is simply executing on the template details.

Each of the 3 exams during the semester covers 4-5 weeks of class content, weighted 25% each. They are proctored with the infamous “room scan” rules and no books, no calculators, no notes, 5 sheets of scratch paper. 150 minutes per exam, no bathroom breaks (unless you have an approved medical accomodation). All answers are provided through a Canvas quiz, including the free-response answers. No handwritten answers allowed.

The TAs actively discourage using the LaTeX tool provided by Canvas because the exam responses are exported & graded in Gradescope. This mangles the formatting. You should be comfortable with the approved plaintext syntax. The export will even mangle standard Unicode (e.g. ≤), so you should practice without them.

This exam is the most intimidating because students can’t predict the expected level of difficulty (the Homeworks & Practice Problems are inconsistent) and most reviews suggest that this is the most difficult exam. Many reviews say “it’s just like the HW or practice problems” without explaining how similar .

From my experience, the Dynamic Programming and Divide & Conquer problems were not recognizably similar to the homework problems. They weren’t difficult , but the application of the pattern was unfamiliar to me.

You should not expect a free-response question to require Chain Matrix Multiplication, Bellman-Ford, or Floyd-Warshall. Focus on LIS, LCS, and Knapsack for the exam.

In contrast to Exam 1, these problems did mirror available problems. P1 was a variation of a homework problem which used a different blackbox algorithm, but the same interpretation of the output topological sort. P2 was a reworded problem from the book which was not a Practice Problem, but is listed on a old OMSCS Wiki . Due to this similarity, I felt this exam was the easiest of the 3.

Exam 3 featured 2 NP-Complete reductions. The scope of known NP-Complete problems was limited by Dr. Brito down to a very small set covered in lectures and the transformations were simple (e.g. graph → graph reduction).

Similar to Exam 2, 1 problem used a similar technique to a graded homework problem and 1 used a similar technique to an unassigned problem from the book.

For practice, I strongly recommend reviewing George’s Notes which contain (partial) solutions for most of the NP-Complete DPV problems (although his 8.19 solution is insufficient).

The format is slightly different for this exam: 3 long-format questions, cumulative, 180 minutes. I didn’t take the exam, but based on solutions posted in Ed, I’d rate the problems similar or slightly easier than the previous exam questions.

This exam cannot lower your grade : if the Final Exam is lower than the 3 Exam grades, then the Final Exam grade is not used. Otherwise, the Final Exam grade replaces the lowest of the first 3 Exam grades. Grade cutoffs were announced the weekend before the Final Exam.

We had 8 homeworks total, 2 questions each. The level of challenge & depth was inconsistent: some problems were reasonable on the level of exam questions, while others were substantially harder and mostly irrelevant (e.g. FFT applications which would never appear as free-response exam questions). I also felt that some questions required unintuitive “tricks” where you’ll need to rely on online material or sharp teammates to discover the “expected” approach.

• Learn the format early. Due to the size of the class, the TAs cannot return grades for HW1 before HW2 is due. This means that students do not recieve formatting feedback on a graded assignment and risk making the same avoidable mistakes on both assignments. When in doubt, copy Joves.
• Practice in plaintext. Write the answers to the homework problems in a monospace font in a word processor. LaTeX answers are nice and looks great on Ed (class forum), but disallowed for the exams, so this is an opportunity to practice the exam format.

Coding Projects

These 3 assignments were among the easiest coding projects I’ve completed in the program. These can be completed in ~1 hour each with less than 50 lines of code, translated directly from pseudocode in the book.

Unfortunately, they don’t run all unit tests until after the submission deadline. I think it’s mean to have “no-feedback” grading for the code, just like the homeworks & exams. The class does allow sharing unit tests, so your generous peers will likely share enough to build confidence in the implementation.

Nicely organised course.

The content thought in the class closely follows the DPV Algorithms book. The video lectures are good and Prof Vigoda nicely presents the ideas. TAs are helpful and post helpful content on Ed. Joves’ notes are very useful for review after watching the lectures. Rocko’s office hours can also serve as good review of the lecture content. I felt the course is scheduled properly to cover the course contents.

Since most of the work is graded manually, it is expected that students follow certain guidelines while writing homework/exams. The guidelines are posted for three sections of the course. This is important and if not followed can result in penalty (can be large). Joves’ notes contain review of the lecture as well as solutions to the practice problems. I tried to mimic the format of the solution in Joves’ notes (also used same font) and that worked fine for me.

Questions on the three exams seemed fair. Although homework have less weight, they are helpful to understand what kind of questions can be expected in exams. For the exams preparation, I felt it was helpful to also solve questions from the textbook. Coding projects are easy but it is recommended to test your solutions with student curated test cases.

Workload is constant through the length of the semester. There is a Homework/Coding Project/Poll/Exam due every week.

Interesting content with good lectures, the key to success in this subject is understanding the answer requirements and formats for each section of the course, following the homework discussion threads on Ed, watching Rocko’s office hours and completing all of the assigned DPV questions without using solutions.

Grading can be strict with certain mistakes, but most of these can be avoided by following the advice from above.

Great lectures and instructor team, but grading is unnecessarily way too harsh on purpose. The intended stress did not improve my learning experience at all.

I understand there are a lot of frustrations with this course in the Spring 2022 semester. I am also one of the students who have a terrible experience.

First of all, this course is no way near being a bad course. The lectures are very well-organized and easily one of the best in the entire OMSCS program. TAs are very responsive in ED Discussion. Homeworks and coding projects are helpful for you to understand the materials.

The only terrible part of this course is GRADING. I believe most of the TAs are good but some grading TAs among them are very careless, unprofessional, and so sometimes very irritating when you read their comments. What is wrose, any regrade request is sent back to the same TA who graded you before, and they are usually very defensive about their statement.

Don’t be afraid of this class. It is not that bad! Yes, you will have to study for exams, you will have to do the practice problems even though they aren’t graded, yes you will have to watch office hours, especially the ones where they go over the homework answers. And yes, you will have to complete you assignments/exams in the exact specific format that they require, but they tell you all this so you just have to suck it up and give them what they want. It’s not hard! People have complained that the graders and biased or that certain graders are more nitpicky than others, but I haven’t experienced that, and I don’t know how anyone would know, as they don’t tell you which grader graded your assignment. The only negative I really have about this class is that it is non-stop the entire semester. Every single week there are lectures to watch plus an assignment & quiz, or an exam. No down time the entire semester. But otherwise it’s totally doable, even if you don’t have a CS undergrad (by the time you’re in GA, you’re pretty much done with you CS masters so no excuses there). Don’t let these other reviews scare you away, and don’t settle for an II specialization just because you’re nervous for GA. You’ve got this!

This class was… fine. I’m better off as a programmer now that I’ve gone through it, but did I get $800 worth of content? Doesn’t feel like it. I enjoyed the book and the lectures and I recommend using both. Everything else was forgettable. The Slack channel is useless because you’re not allowed to talk about problems. I didn’t get much out of Ed besides some guides on how they want us to do write-ups. TA’s seem to know their stuff which is always good. Rocko is very active on Ed but it’s a coin toss on whether or not he’s helpful. I tried to attend his OH but his attitude is off-putting so I stopped and haven’t felt like I’ve missed anything. I didn’t know the professor’s name through most of the semester, he doesn’t have much of a presence on Ed. He has OH sometimes but I never went.

I was able to get nearly perfect marks on all the homework. To that end, I strongly advice reading and rereading the posts the TAs provide on their expectations of homework format. The projects were quite easy and I didn’t feel like I got anything out of them. However, given how many hours I had to spend on homework, I didn’t really mind.

The exam difficulty is fair and I recommend doing the practice homework and as many book problems as you can. However, the actual exam questions could be better written and the grading rubric disincentivizes you from trying to get an optimal solution; if you are not totally sure of your solution you are better off giving a suboptimal one rather than one where you try but fail to be efficient. In my opinion this decision makes for subpar educational content. That is, a decent study strategy is to ignore learning all the interesting algorithms and just be sure you can give a brute force solution because that is worth about 14/20 points, but if you give an almost correct efficient solution, that is worth about 7/20 points.

As far as how this course relates to job interview questions: I’m happy with what I have learned but I take it to be a just good first step on my way to getting better at interview algorithm questions. That is, I now have a decent foundation upon which I can build. I did not mind the formats of the homework because they are designed to help you solve the fundamental algorithm problem at hand. In other words, understanding how to solve the algorithm question and how to implement a solution are two different problems and the class will only try to help with the former. I think this is the way it should be and for all the reviewers who disagree; we already have leetcode, take the theory you learn in the class and go practice problems there like you would have anyway. Even if the class did try to teach to the interview questions, do you think it would do a better job than leetcode? No it wouldn’t, and we would all just be worse off. I can understand all those frustrated with having to solve the problems via writing, but that just tells me you have not done much technical/academic writing. Expressing yourself clearly and precisely to explain a technical solution is an important skill and I strongly advice taking this as an opportunity to practice.

This course is very helpful to help you prepare for an algorithm interview. It touches some categories of medium+hard questions on Leetcode. It helps you establish a paradigm for solving those type of problems, instead of just memorizing the solution for any particular problem. The TAs are also helpful. They created study notes and helps clarify questions on the Ed. The lectures explains things well enough so that you rarely need to reference the textbook. Before taking this course, I thought this is just mandatory course you have to take no matter what. But it turns out to be far more useful than I thought.

The workload is light and well spaced over the whole semester. Each week you either have a Homework, a coding assignment or an exam due. So you can focus on one thing at a time. You don’t need to worry about lagging behind either as the deadline for every item is exactly one week. One thing to be careful is the quizzes. Their due dates are not published ahead of time, so you have to follow the weekly announcement very closely.

My only complaint is that TAs in this course tend to make mistakes when grading homework or exams. I totally understand this as it is a huge amount of work given the amount of students in this course and the solutions are like a small essay, which are tedious to read if it is not close to the solution. For students, this means you need to routinely check if there is an error in the grading and request for a regrade whenever it is warranted. Be prepared to argue with the TAs to get the points back.

This course is a disaster. The professor is absent and the grading scheme basically allows TAs to reject correct solutions because you didn’t present the solution in the specific way they wanted to hear it. There is a clear aura in this course that belittles the students. I felt the persistent tone of - “We are the staff, and we are god’s gift to earth. You are just a dumb student”

You can’t use real code to answer the solutions like in a FAANG interview. You have to use their arbitrary notation when “coding” the answers. Why even bother coding then?

My biggest concern is that this course is required for graduation. A small group of elitist TAs should not be the sole deciding factor towards who gets a degree and who doesn’t.

For full disclosure, I escaped with a B. I am an interviewer at FAANG and I am a guardian on leetcode (2000 minimum contest rating). The way this course tests you is not aligned with what you should expect in the real world.

I enjoy learning in this course but the grading practice of TA’s of this class is capricious, which is the only thing negative thing of this course, but unfortunately it does the most damage to my experience in this class. The TA did not seem to bother to read what you wrote. They often make up excuses to deduct your point. They don’t have a clear rubrics to grade. Very sad!

I found this course challenging but rewarding. I didn’t have background in Algorithms and Data Structures before. This was my 4th course in OMSCS program.

If you have a good study group, understand homework problems, spend enough time to understand lectures and prep for exams then you have high chances of getting either B or A. Overall, the course covers dynamic programming, graph theory and some NP theory. If you like solving problems you might like this class.

After finishing this course, I was able to start doing DP and some graph, tree leetcode questions. I spent 30 hours per week on average to practice and understand homework, lecture problems and prep for exams. I would suggest to join study groups. I was lucky to have great study partners who explained their approach to tackle the problems.

As someone without extensive algorithmic experience or background, but having refreshed an undergraduate algorithm course before starting OMSCS (you won’t need much from there on top of basic graph theory and Dijkstra), I found the material being very manageable, straightforwardly structured and study process well managed. It has turned out very much more approachable than what the story told, with no extra preparation or upfront reading required on top of general background as mentioned. The course is not too deep or too broad, I’ve learned quite a bit of new material and was also able to cover and understand some previously met topics better. I joined the course mid first week of the semester, prepared nothing upfront; this was my 7th OMSCS course. And yes, I do think this course is compulsory for a MSCS degree, I would consider it basic (which does not necessarily mean very easy) and covering some necessary material.

The professor was involved with office hours, the TA staff, especially those active on Piazza and Slack, are knowledgeable and do their job professionally.

This was also the first time the course had 800+ students (started with 900), and it was running smoothly, with instruction staff’s involvement being of high quality.

To be on a concise side and avoid duplication, here are my tips for a stable good grade in this course, including good feeling and useful learning outcome.

The course demands some writing “skills” involved in the assignments which seems to sometimes source confusion and frustration from some people. The main thing to understand here is that you should write your solution in a way which is unambiguous to understand, precise, correct and contain all the necessary ingredients. The format is not very picky as such, you just need to understand that it should follow the requirements.

The details on those requirements are well explained in Rocko’s (one of the head TA-s) office hours. I would say, never miss those, or watch recorded - you will understand the needed details of what to do and what not to.

Be sure to present your solutions in a clear way, pay attention to details, cover the needed points. Extra text with no substance adds nothing, your solution can be quite short but cover everything needed. In some cases it might be longer - still to cover everything including the proofs if needed.

• DP: the structure is generally given: table definition - recurrence - pseudocode - running time;
• DC / algorithms design: solution(algorithm) - correctness - running time
• NP-complete reductions: 1) NP proof (verify a given solution in polynomial time, show every step time in O notation) 2) Correct direction - known problem A to the reduced one B: - input transformation, polynomial time in O notation - output transformation, polynomial time in O notation - solution to A ==> solution to B - solution to B ==> solution to A

Pay attention to requirements: pseudocode yes-s and no-s (Rocko’s OH, again); no pseudocode (i.e. outside DP) means exactly that, use your wording as mentioned earlier, to produce clear and correct description; if no blackbox algorithm modification - do not modify any detail of the blackbox, learn and use its input and output, no extras inside; etc.

• For the homework, do get someone to study with or at least discuss the homework solutions. If you know some reliable peer from previous course(s), that would work great, even a single person.

This way you’re done with free form answers for the exams.

Watch the lectures and practice the material for good MCQ results.

Do the recommended practice problems, all of them - there are not a lot. Do some extras from the DPV textbook when preparing to the exams.

Follow Piazza threads, may also on Slack.

Follow the regrade request threads, they give a good feeling on how the expectations go on the solutions. If you comment on other solutions, do it as a peer, no patronizing. If posting your solution when you think a deduction was genuinely incorrect and something that was clearly present in your solution was missed - have a valid case. There have been quite a few of valid regrade requests. There have been also a lot of invalid ones, or those coming out of frustration - those won’t help anyone. The statements about peers commenting on solutions just to disqualify and throw the stones on the correct ones - just a load of nonsense. A peer comment is also not a final verdict of whether a regrade request would be valid, so everyone should make an informed judgement - the system will work for those taking the comments seriously, and won’t for those who would try to bend the system. I personally found it pretty efficient.

The polls (Canvas quizzes) and the coding “projects” are basically free points, make the most out of those, also in terms of study and exercise. Very straightforward, bordering on trivial - but still useful, especially the coding exercises.

All in all, given that there is a final exam option to replace a lower exam grade, like some past review said - congratulations on that A or minimum high B, you’ve done well. Good luck!

This course is set up in favor of the students. While the grading can be inconsistent at times, in the grand scheme of things it should not matter. I personally felt challenged and learnt a lot. We are here to learn and this course will reward your work.

Two key points: find a strong working group; work through all the similar problems in the text book and Skiena as well. If I had done this, I could have skipped the final.

The instructors are top class. Period. We get to learn from the best and should cherish the opportunity. Enjoy the journey.

The course is interesting, but the instructor team ruined my interest completely. The instructor Gerandy Brito appears in the office hour only several times this semester, which is far from enough. Also, he does not reply to students email. I sent him several emails this semester, but none of them was replied. A head TA named Christian Stober is always patronizing to students and does not show any respect to students. The regrading process is threatening. If you wanted to request a regrade, you first need to publish your answers in Piazza and ask your colleague students to help review. Then you can request a regrade. I do not understand why the instruction team puts the burden of reviewing students’ solutions to students and glorifies the process as “helping students to learn”. If students only need to learn from each other, then what’s the reason to hire you TAs? We can grade each other’s homework, we can answer each other’s question. I do not accept such a way of treating students. Also, if you request a regrade, it is possible you will lose more points as a punishment of wasting TAs time. I guess TAs’ time are more valuable than students’. I really cannot understand the logic behind losing more points when requesting a regrade. If my original solution is really poor, then why does the grader give me points that do not match the quality of the solution? It only proves the grader did not spend enough time reviewing the solution carefully. I only request a regrade once and I lost 10 more points as a result. The TA team governs the students’ final grades. So I prevent myself from requesting regrade no matter how unreasonable the grade is. Also, there is a huge standard deviation between the rubrics of different graders. So in this course, you might want to pray not to encounter some harsh TAs. Luckily, this is my last course and I can escape from the instruction team now.

One of the best class of OMSCS. The TA are helpful and the content is both fair and challenging. Practice as much as you can, it will help not only with GA but also with interview prep if you are aiming for a job change soon. Honestly, if you understand the algorithms well, you do not need to memorise anything.

DPV is an excellent book but do not hesitate to refer other books. I liked Steven Skiena’s book for additional practice.

Assignments-

There were 7 assignments in the Fall 2021 semester. The assignments gave a good practice for the exams. Although the rubric was not disclosed but if you write a correct solution and correctly explain your choices you would not lose any points. I found that students struggled with proving correctness the most. My tip is that explain all your choices in detail, if you assumed anything explain why, also explain what made you selet a particular alogithm (for example, you would select binary search over linear search only when the data is ordered.). There is no penalty for long answers, so explain as much as you can. Review your answers as if you do not have any background knowledge. This will not only help with the assignments and exams but also help with understanding of the material and algorithms in general.

Do not forget to take all polls. They give a good understanding of multiple choice quistions and may help solidify understanding of the subject.

Coding Projects-

Coding projects are simple but do not forget to test them thoroughly.

The exams are fair and if you have practiced and understood the material you should not have any problem. The homeworks and polls will prepare you well for the exams.

Last course in OMSCS and the only one in my set that’s terrible in terms of quality and learning outcomes. Unless you’re interested in pursuing theoretical subjects in academia in the future, the material leaves you disappointed. This course should not be made mandatory in its current format as it is designed for a particular type of student who thrives on memorizing theory and it does close to nothing for some interested in practical applications or knowledge relevant to the job market (something that fortunately lots of OMSCS courses do right).

• if you are keen on getting the best grade, then you must absolutely enjoy memorizing a lot as the whole course is only about this
• follow the same terminology as in the lectures and class or you will get lots of points deducted from homeworks and exams or worse, you will interpret the ambiguous MCQ questions in the exam in the wrong way thus losing yet more points
• inconsistent grading in homeworks and exams makes the experience frustrating and deters from enjoying the subjects taught
• writing essays (instead of code) to describe algorithms leaves room for interpretation and allows graders to deduct points as they see fit
• TAs general cold attitude towards students and their issues with the material and grading leaves lots of room for improvement; the whole experience is quite the opposite of any ‘community-building’
• knowledge presented in this form is hardly applicable to the real world and makes you lose all motivation from the first few weeks
• Joves’s notes are an encouragement to put up with the dry theory and to find shortcuts for memorizing a ton of information which you’ll need in the exams. He’s done a better job at presenting information in a more pleasant way compared to the lectures, books and office hours in this course.

Conclusion: students should be allowed some flexibility to pick their courses to meet their professional goals and this course should have never been made mandatory without at least another alternative presented that is different to this niche-type of theoretical course

This class is a lot easier than its reputation. Most of your grade comes from the exams and on each exam there’s two written questions worth about 2/3 of the exam grade. This semester these questions were almost always variations of problems from the homework. If you do the homework and make the effort to understand what you’re doing you are pretty much guaranteed a B. The other third of the exam points come from multiple choice questions. You can learn most of this information by doing the ungraded practice problems on the homework.

As for the course materials, I probably watched around 2/3 of the lectures. They are generally well done but there’s a lot of information presented that you don’t need for the graded parts of the class. After the first exam I only watched the videos that were related to homework problems I was struggling with. The textbook is useful as a reference and additional information if the lectures don’t answer your questions. Personally I never attended or watched an office hours recording but if you need help I’m sure they’re great. The TA’s and professor for this class are excellent and I have no doubt they do a great job of answering questions in them (they do a really good job on Piazza).

Overall I found this class to be well run and a lot less stressful than I expected. It’s not a bad way to end the program at all.

Fist off, this will be the last review I will ever leave seeing as this is pretty much the final class for everyone, and I did in fact pass without the final exam. Thank you everyone who is a part of this site, it truly made my GATech experience better and helped with my anxiety. My advice for the people coming in, start off strong and it will help with stress levels. Dynamic programming is an interesting concept, but just do every problem you are presented with, over and over and over and over again. Memorize them, how they work, why they work, and exactly how to complete each one. The exams are not far off from the assigned problems.

Now for the real review, the class is rough. I tried not paying attention to grading because of all the awful reviews, but I think my number score was often fair in homework’s, because I typically had no clue what was going on. The exam, eh. I got the two long response questions right, on the first and second exam, and don’t think I scored above a 27/40. But I never even looked to see why, but I got them right, so 13/40 points were lost due to the grading or small mistakes which I’m not sure should make you lose almost half credit.

Course load is a lot if you try to read, attend office hours, and watch lectures. I would suggest skipping office hours, lectures, and reading if tight on time. Read Joves notes. Memorize them, record them, listen to them at night, turn it into a movie. They deserve an academy award. Understand how Joves does the problems and memorize it. You could pass this class by only reading his notes. He is an angel sent from heaven, sent here to help students graduate from GATech.

I think that’s it for my review. You get the details of this class from all the other novel like reviews for this class. To recap my two main points: practice practice practice, and Joves notes are king.

First good things about the course:

1) Topics are interesting. Dynamic programming is covered quite well. I also liked the focus on FFT, RSA, MAX-SAT proofs etc. 2) Video lectures are great. I like Prof. Vigoda’s style of building the intuition behind proofs 3) The DPV textbook followed is a great book. 4) Grading is fast and on time. 5) The TA team is active on piazza/slack and try to help the students with the course.

The bad things about the course:

1) Questions (specially in homework) are way too easy. I expect more difficult questions in a graduate level course. The exam questions are also kind of easy. The homework questions are embarrassingly easy.

2) The strict rules set for answering questions. The rules are totally made up for making it easy for TAs to grade and have no connection with learning. The TAs enjoy nitpicking on tiny details and even a 100% correct solution can get a low score for violating any of the rules. This kind of reminds me of my high school math class in which the teacher would give me low score because they didn’t like my handwriting.

3) Too much focus on memorization. We have to strictly memorize the input and output of each algorithms and any minor deviation in the usage of algorithm will attract a huge penalty. I found memorization the worst aspect of this course.

Advice to students: The homeworks carry very less weightage. Dont get discouraged when you get bad scores on them due to mindless nitpicking by the TAs. Use the homeworks to understand the TA’s expectations.

I hope Gatech in future will offer a more advanced version of algorithms which feels like a graduate level course.

This was my 9th course in the program and is by far the worst course I have ever taken. The course has fundamental issues that have been reported for years and are not being fixed. The professor refuses to believe he is a problem and will instead put all blame on the students or band aid fixes. For instance, the grading this semester was as follows: A [85,100], B [65,85), C [50,65), D [40,50), F [0,40). If the course was run appropriately there would be no need for such a drastic adjustment.

The material is interesting. It’s challenging but not in a way that isn’t easily understandable with practice. The text book is really good and explains the concepts well. However, an understanding of the material is not what is important to the teaching staff of this course.

Your grade is almost entirely dependent on what grader you get. The experience is largely inconsistent. There are often homeworks that are nearly identical and one will receive a 95% and the other a 65% because the graders are that inconsistent. For example, a student this semester that was in this course a previous semester submitted their same homework as they did from the previous semester but fixing what they had gotten wrong. Their score this semester was significantly lower than when they had submitted the homework the previous semester. And that is with valid corrections! Totally incorrect solutions often get a higher score than mostly correct solutions because solving the problem in a different way than the instructors want you to results in less specific deductions from the rubric.

The exams are worth 75% of our grade, are completely closed book and notes, and are poorly put together. Questions are often poorly worded resulting in a lack of clarity. The exams often require us to have arbitrary, class specific knowledge memorized that you will be largely penalized for not knowing. Furthermore, the instructors don’t even tell you what that is, you often have to guess, or use Joves notes. Joves notes are notes that one of the TAs created as a student, that he volunteers for the course. Frankly the course would be impossible without them. The information provided in them should be provided by the instructors, but isn’t. They fill in a large gap that frankly it shouldn’t be a TA’s responsibility to fill.

The head TA and many other TAs are rude and arrogant on Piazza. They belittle students questions if they deem them not good enough. It’s unacceptable behavior and is awful that Georgia Tech allows such behavior. I have had questions that were directed to instructors and only visible to instructors ignored and even marked resolved over 4 times despite them not being answered and me reiterating that they hadn’t been answered every time they marked them resolved.

The power dynamic in the course is largely flawed. For any grade we can submit a regrade request and it can cause our grade to be lowered. This would be okay if we had the rubric that the graders grade against, but we don’t. So to request a regrade the process is as follows. First you have to publicly argue why you deserve certain points back on an assignment. Students then do anything they can to prove you wrong, often being rude and aggressive. The professor refers to this as “community building”. Being stoned is community building for those throwing the stones I suppose. If you manage to make it out alive you are then “allowed” to present your argument to the instructors. They will then regrade the entire question and not just the points you argued for. Keep in mind you don’t know if the grader didn’t take away other points they were supposed to because we don’t get a rubric. When I went through this process on my exam I ended up with a grade over 15% lower and it was very clear they didn’t even read what I was actually asking for points back on. Furthermore, the section they magically found wasn’t marked wrong enough was already marked wrong. To top things off, this exam is worth 25% of my grade. When I tried to have a discussion about this and ask for more clarity from the professor, he brushed me off and even blatantly lied to me. This incident is currently being reviewed by Georgia Tech as it is entirely unacceptable.

You’ll see lots of reviews saying that the course isn’t that bad. And for many people it isn’t. Your experience almost entirely depends on what grader you get. If you can avoid this course you should, which is a shame and unacceptable as an algorithms course should be accessible and well run in a CS program. Until the professor realizes that he and his team are a problem it will not change. He will simply change the grades so that enough people pass.

I write this review since I think the other reviews are not representative (they are just too bad). This class is rather hard and I wouldn´t let me fool be things other wrote. They should be lucky that there is such a curve and what they are writing is more a summary of themselves than the course. Why can people get angry? You are writing tons of text and you get critized for it. Some take the criticism as a chance to grow other feel offended.

If you are doing nothing, you are lost. If you are doing too much, you are going to burn out. I think you are learning a lot if you want to.

I keep this review short, since every hint you can get has already been giving in other reviews

Do not try in this class. Put in minimal effort. They will adjust the letter grades so they don’t have to fail people. They can’t afford to enforce their own grading policies because this class has become such a bottleneck. It’s an unfortunate reality for this program.

The best advice to do well in this class is to drill the homework a lot. The HW is a few ungraded problems and then 2 free response questions that get graded. If you drill the homework and try to get a perfect score on each part you will be in great shape for the exams. You’ll have a bigger buffer and the exams are very similar to HW

In my opinion grading in this class is okay most of the time but there was a few instances where I have gotten feedback about missing certain parts even though it was written in the solution. In this case you have to ask on a public forum for someone to agree with you. Finally once someone responds to you you have to create a regrade request for the same TA that missed it the first time to regrade you. I was a little unhappy with that process because in one instance a TA admitted to a mistake on the second review but found a new issue. I disagreed with the new issue but the grading window closed so i just accepted a grade deduction. In a more ideal world a new TA would do the regrade.

Don’t worry though this class gives you plenty of opportunity to make up for a low grade! And TAs make mistakes but luckily the exam questions are similar to the HW so just practice writing the hw solutions a few times and you will be in good shape! (wish i had this advice myself)

there are some lectures in the class that are very proofy and confusing. I spent hours learning proofs on one exam and i think that was a poor use of my time, don’t do that, again stick to the HW.

Also props to soon to be Dr. Rocko & professor Brito for having weekly office hours. you have two hours to ask questions and listen to solutions to HW. take advantage of this.

This class should not scare you I think my biggest downfall was assuming knowing the right answer is enough. You are tested on knowledge of the course as much as you are tested on how to follow an expected template. There are times when you won’t get your HW feedback before a part on a test so thats when OH is a must! Normally this isn’t the case!

Don’t worry about this class that much and drill the HW. Create a study group (this is were i failed). Don’t be a jerk on regrade forums and help your peers out.

It will be over before you know it! Getting a 70% (before the curce) (b) in this class is more than doable! you can get a 0% on exam 1 and 2 and 100% on exam 3 and the final and still get a B in the class! (the lowest test is dropped by the final. except for summer semester) There is a ton of wiggle room just set yourself up for success. And at times there are curves.

Also this might go without saying but if you don’t need to take this class i wouldn’t. I don’t feel like i learned a lot i feel like a lot of my time was used in practicing how to format responses so the TAs won’t give me deductions.That might be due to stress since the material and lectures are pretty interesting.

Edit: i x2 what this review says https://omscentral.com/review/-MqGYvt3FJKFkALkbKCl

This was my final class for OMSCS. I barely earned an A in this course, but can highly recommend it.

GA has a bit of unearned stigma attached to it due to originally being CCA, which proved to be not the right fit for OMSCS. I believe CCA became another course which became GA, but I could be wrong there. Further this is certainly a course that you’ll find you either “get it” or not immediately. If the material quickly clicks for you you’ll do fine as long as you stay on top of the work. If you need to work to understand the material be prepared to spend a decent amount of time studying.

As usual, this breakdown and review is for the Fall 2021 semester. The course will change over time.

Course Breakdown

The course is “curved” out of the box with an 85+ being an A and a 70+ being a B. The instructors reserved the right to adjust the curve “down”, or in favour of better grades if needed. It is yet to be known if the instructors are doing this for this semester, but signs point towards no.

Grade Breakdown: Exams 75%, Homework 12%, Assignments (coding) 9%, Polls 4%

The course is broken down into three sections: Dynamic Programming and Divide and Conquer, Graph Algorithms and Fournier Fast Transform, and P-NP and Linear Programming. There are three exams, one for each section, followed by a cumulative final. Of these four exams the top three count for 75% of your grade, while the lowest is dropped. Note that if taking the final would not improve your grade you are not allowed to take it.

There were three coding assignments. For each we were provided an algorithm and needed to implement it in python. The challenging parts were getting the code to conform to the interface required as well as not having any instructor provided tests other than a simple sanity test or two. However we were allowed to create and share tests as well as test results, so the class will quickly come together and converge on some test suite with known good answers. Of all the courses I’ve taken in OMSCS the coding in the class was the least intensive and time consuming.

Homework, we had seven assignments. Each week we’re provided a list of problems, with two highlighted as being due. For the ones that are not due later in the week we were provided answers. The two due problems were submitted and graded, and later we were given solutions to those. The difficulty and amount of time needed for these varied depending on the questions.

Polls, we had eight of these. Every week we did not have an exam there was a single question quiz on Canvas. These were all either multiple choice (both select one and select N) or true/false. If the question was not true/false you had two attempts to answer, and were provided your score (but not the answer) after each attempt.

As we have not been given any information on the final, I cannot comment on it. As exams are 75% of your grade, they deserve their own section as they will make or break you. If you struggle here you will not pass.

Each exam was broken down into three sections. Sections 1 and 2 were each an individual algorithm question mirroring the kinds of questions we got on the homework. Section 3 was a series of multiple choice questions similar to the polls. Each section was worth 20 points for an overall point total of 60 for the exam.

For the exams: there’s a template of what they expect, though sometimes not explicitly stated (except for DP). Use this template or a version of it. When the grades come in before you can request a regrade you must submit for peer feedback. Most of the time when I saw someone who had good chance of getting points back, sometimes even the prof/TA admitting it was a miss, it was because they either were not using the template or had a critical sentence in the wrong section.

Sometimes less is more. A tricky portion of this class is you’re actually treated like a graduate student and don’t need to justify the small things. The issue is balancing saying enough that your point is proven while not saying too much because a small mistake in a statement you didn’t need to make counts against you.

Lastly, proofread! After doing the algorithm problems either review your multiple choice or do them, then go back and proofread. You’ll find mistakes, most likely in the wording. I hate to say it but this class might be more challenging to those who have English as a second language, while reviewing regrade proposals I’ve seen many that looked like they were doing the right thing but the grammar was ambiguous or poor making it challenging to understand what they exactly meant.

Non-Exam Work

Do the homework early, and proofread it. For some of the material if might be worth it to code it up and prove to yourself it works. While the exams will make or break your grade, the homework is what will either makeup for a mediocre exam grade or push you above the grade cutoff.

If you have experience programming the coding assignments will not be challenging. They are more a test of if you can take some algorithm from conceptual to concrete. No tricky edge cases, no gotcha’s, just take this algorithm and code it up.

Polls - I struggled with these. They’re the most conceptual of all the work, but are worth the least amount of points.

Advice and the Ugly

• Format your homework and exam algorithm questions to the “template.”
• “Jove’s Notes” should be available to you and are a godsend for this course. Very thorough, use them! However they cannot be shared as sometimes they cover the answer to homework questions, so those sections are pulled out.
• The homework has non-graded questions. Solve these by yourself before looking at the solutions. The struggle for the professor in this course is there’s a limited number of questions, so each question is very valuable to learn from.
• Your grade will largely depend on who is grading your assignments. From what I’ve seen some TA’s are stricter than others. This is rough but it is what it is.
• If you need to assume something, or want to do something that might not be extremely obvious at first glance, state what you are doing. For example in DP “I define T[0] as the result of making no choice”
• If you find yourself doing a number of weird things, or designing an algorithm from the ground up, take a step back and reevaluate. This usually means you’re going down the wrong path.
• For NP Reductions, remember you’re not solving the problem you have, you already have the solution. You need to transform a known NP-complete into this problem so your solution will solve it.
• It usually takes over a week to get grades back. This is stressful when starting new material as you’ll have to submit your second homework before you know if your approach taken for the first set is valid or not.
• It’s frustrating but missing something early in the process will result in multiple point deductions. While this seems unfair the justifications from the TA’s is that it allows them to give “partial credit” to people who got it right in the early part of the question, but made a mistake later.
• This class is a bit unique in the style of class it is. Most classes either go broad or deep, the survey style that covers different theories but doesn’t go deep into them, or the “let’s learn everything about X” kind of courses. This course instead is a survey course that requires you to actually implement and use what they are surveying. This is going to throw off a lot of students.
• It’s possible to get a bad question on an exam. The reviews from the summer semester talked about an exam problem that many students bombed because it was unclear. We had a homework question that said it was from the summer semester’s exam and it was worded ambiguously, I would have bombed the exam with my interpretation of the problem. Further we had on homework question that required a “a-ha!” moment that did not come naturally. This is why the professor reserves the right to adjust the “curve” downward.
• Lastly, they keep a significant amount of things, like the rubrics, secret. However the amount of things I’ve seen us be able to share, like our solutions to the exam questions, goes well above what I’ve seen in other classes. Read the stickies and communications - they won’t budge on sharing the things they decided not to share.

This was my last class in the program. Overall it was much less work than I expected. The bulk of the work is the week before the exam since you need to review many problems from the book and go over lectures and Joves notes.

• I don’t have a CS undergrad degree. I have not taken a formal algorithms class.
• I have gone through two job changes where I prepared using LeetCode so this background knowledge helped with the DP + Divide & Conquer unit. I also skimmed through the Coursera Stanford algorithms course before preparing for my SE job search.
• I didn’t do any prep work before taking the class. Don’t bother spending time preparing, you’ll learn the material as you go. Piazza, practice problems, and Joves notes are helpful. Make sure to also do all the relevant book problems to help prepare.
• The exams are not as tough as the reviews make it seem.
• Don’t try to combine this with interview prep since there is not much overlap with interview style problems and GA material.

Topics Covered

• Unit 1: Dynamic Programming and Divide & Conquer.
• Unit 2: Graph Theory - This unit is not algorithm design, it’s all about changing input and output and using black box graph algorithms.
• Unit 3: P - NP - This unit is also not about algorithm design, it’s all about proving that a given problem is NP-Complete.
• Weekly homework assignments (8 total)
• 2 problems per homework assignment. You are allowed to use any online resources to solve the homework questions and most questions can be found online. You just have to cite your sources and rewrite in your own words.
• Time spent: ~5-8 hours per week. The bulk of the time goes in writing up the solution since the grading is a bit strict.
• Weekly 1 question polls. Watch the lectures and then take the quiz. Doesn’t take more than a few minutes to answer the question.
• 3 exams, 150 minutes each. 2 free response questions and 10 multiple choice questions.
• Watch the lectures for the MCQ questions
• Go through all the assigned practice problems (each homework assignment will give a few practice problems to work on)
• Go through Joves notes
• Do all the relevant book problems from each chapter. This was key!! The free response questions are pretty much exactly like the book problems. If you review these, you have a good chance of succeeding on the exam. There are no published solutions from the teaching staff for these extra book problems but you can easily find solutions online.
• Time spent preparing for exams: ~30 hours per exam

Exam 3 grades just dropped, and I finally can feel my stress levels returning to normal. I had no algorithm exposure in my undergrad ( Electrical Engineering ), and managed just fine. While the class is stressful, it’s fair. The fact that a B is a 70, means that if you can get most points on HW, Quizzes, and Polls, then you literally just have to not get an F’s the exams and you will pass. This is not that difficult if you are remotely paying attention. Ignore the noise, buckle up, put in the time, and you will be fine.

Everything to be said about this course has already been said. Inconsistent grading, unnecessary stress, but a couple of good TAs (Rocko/Joves) help make it more manageable. If this class wasn’t required to graduate I doubt anyone would be taking it - not because the material is bad but the heavily weighted exams with ambiguous grading just make it a nightmare.

A browser error ate my review so here’s just a quick recap of my main gripes and advice:

• The second 2/3rds of the course is focused on written descriptions of algorithms with “proofs”. The proofs are not true logical proofs and so there is a lot of grey area to underspecify something. Best be safe and assume nothing without stating it up front
• The grading scheme is incredibly stressful and punishing. Have an “a-ha” moment on 6 short answer questions in an exam setting or you will lose up to an entire grade letter. You can take the final to replace an exam grade.
• You can pad your grade a bit with homeworks, afterthought coding projects, and the oh-so-generous weekly 1 point quizzes but you live and die by the exams.
• I cannot stress enough how volatile the grading is. We as working adults, some with dependents, have to pick our battles and there is not enough time to study everything to complete mastery. If one of the short answer questions is something you don’t have completely down pat, you might be screwed.
• As with most of the terribly designed courses in this program, the TAs carry the course. Joves Luo’s notes in particular are absolutely essential, study them well.

It just felt cruel. I passed, but I came away feeling like “I survived”, not “I learned some cool stuff”. Most people are taking this course as their last before they graduate. These folks have been on a long journey to get here and have endured what may be for them a grueling gauntlet destroying their personal lives. This course relies excessively on feelings of fear and uncertainty to get you to study because they fundamentally don’t do the work and get the human resources to use a humane grading structure.

Just think about it. If a student knows e.g. knapsack really well, but is iffy on chain matrix multiplication, should their grade be a coinflip on which one shows up, or should it be 50%?

The majority of this class is learning how to write text descriptions/proofs of algorithms, not code. Let that sink in. You must describe in words how an algorithm works and prove it is correct in words. Much like what the instructor does in the lectures. You are rarely implementing algorithms in code.

The grade is heavily weighted toward performance on the exam. I think they are trying to prep us for algorithmic thinking under pressure.

Here is my advice:

• Understand the grade weightings. A couple multiple choice questions on an exam are worth as much as an entire homework.
• Use Joves’ notes!
• Read and follow the instructions very closely.
• Relish in the homework and do the practice problems.
• Do not panic over a mediocre homework grade. Homework points don’t matter much, but they do reflect on how you might perform on the exam, which matters a lot.
• Be thoroughly prepared for the exam, including understanding the unusual way Canvas grades multiple choice.
• Get a perfect score on every coding assignment and weekly quiz (“poll”), because they are easy, and you are a graduate student.

I strongly disliked this course until I understood what they were looking for. Once I got on track it became reasonably enjoyable (but stressful), and I came to realize how easy the class actually can be. My ratings are based on an average of how I felt then versus how I feel now. To me, this class is easy in content but difficult in form.

tl;dr This is a good algorithms course with a reasonable workload. The grading is fair and A is achievable with right amount of efforts. Don’t fret because of all the negative reviews.

This was 13 week course with 8 HW, 3 coding projects, 8 polls and 3+1 exams. This is a theoretical course and so major emphasis is on formal proofs. The lectures are great and cover all the concepts in good detail.

The homeworks were tightly coupled to the lectures and assigned readings for that week. In each homework, there were a few non-graded practice problems followed by 2 graded problems. The solution to practice problems were released shortly. The graded problems mostly were some variation of practice problems or DPV questions. Collaboration is allowed. They serve as practice for the exams. All the HW’s need to be answered in essay-style and no pseudo code or actual code is allowed. The DP problems need to be answered with pseudo code only. The best way to get an idea how to structure your answers is to follow Joves’ notes.

Polls were basically a single MCQ on canvas. It was non-timed and open everything with 2 attempts available. It is hard not to get full points here.

This is a exam heavy course and has overall weightage of 75% (each exam is worth 25%). The questions on the exams were more or less variation of homeworks and polls. The stakes are quite high since a single mistake on any essay-type question could cost a letter grade. However there is an optional final exam at your disposal that can replace your lowest exam score.

My takeaways

I didn’t take any course this summer semester and instead spent time on brushing my data structures and algorithms. I practiced a lot of leetcode problems on DP and graph. I did this primarily because the reviews are skewed towards it being hard and I wanted to make sure I come prepared well. However now I realize this might not have been necessary as the course is very well self-contained. I did not join any study group. Before every exam I revised all the practice and HW problems and this was a good enough preparation strategy.

The exams were fair and there were no gotcha, or trick questions. The grading was even fairer. I did not experience any unjustified deductions in any HWs or exams. There were two OH in every week - one taken by the TA’s, other by Prof Brito. The instructors were active and helpful on Piazza. Joves’ notes were particularly helpful and gave a skeleton framework on how to answer the essay type questions. Overall teaching staff were keen to make sure everyone succeeds in this course.

This class reminds me of upper division math classes that involve proofs. It involves almost no programming - 3 small python programs that take a couple hours each. If you have a strong academic math background including formal proofs, you will likely find the reasoning and attention to detail required for the writeups fairly straightforward.

The HW assignments and exam free response questions are basically recognizing and manipulating known algorithms and providing proof that your solution is correct. The key is that you need to be very clear and cover all the required points - this is the input, this is how it is used in this known algorithm, this is the output, this is why I know the output is correct, this is the runtime of each step. Each section has a kind of template you can use for the proof and what you need to include to get full credit. One of the TAs includes his student notes. I used the templates he provided and did not miss any points on the exam free responses and very few on the homework. The people who did not follow the template or cover all the requirements lost significant points. If you are more of a big picture person than a tiny detail person, you will need to really focus on making sure you include all the details in your write ups - finding the right solution is only half the work.

I highly recommend attending all the office hours and joining a weekly study group.

If you take IIS before this course, the RSA portion will be a review.

I’m not sure if this is an unpopular opinion. I certainly hope not. I feel like 6515 is the worst class I’ve taken at OMSCS. The content itself (the book, and the lectures) is great, but every little detail about course logistics (the written assignments, coding assignments, and the exam) all are really the worst experience I’ve had throughout the program. I found this post from 2 years ago, and I feel like most of these points are still valid.. https://www.reddit.com/r/OMSCS/comments/c1xc97/ga_teaching_staff_are_infuriating/?utm_source=share&utm_medium=web2x&context=3

For the written assignments, I’ve never gotten a good sense of what the graders are looking for, and it seems that every grader has a different idea of what an acceptable answer is and what a 10/10 answer is. Which is expected if I was in a more writing intensive class where there is no answer, but for an algorithms course… really?

I don’t know but it seems like the grading for the class for both the assignment and exam is just being nitpicky and tedious for nothing. We are not being asked to do a formal proof by induction, yet small details missed when the solution and analysis is right gets me 20% deducted.. and for what? Just a small comment saying “missing minor detail but still correct answer”.

No feedback on the exam questions, and no solutions are provided. Coding assignments offer no traceback, and no real detail is provided when you get something wrong (even if you ask for a regrade).. yeah if I failed an edge case when I attempted to address it, how am I supposed to know how to improve to not be a shit coder?

Office hours are pretty much mandatory. I felt like this class is worse than ML in terms of enforcing monitoring every piazza thread, and watching every office hours if you want to get a good grade. At least for ML the assignments are open ended.. and you really learn something out of the process. For this class you are just spending extra hours trying to figure out what format or approach TAs favor when grading. If you want a specific format or a specific format leads to a higher grade, just stick that to the top of the assignment as a header instruction. Don’t make the course more time staking than it is.

Proctoring requirements are a pain and invasive, and some of the exam questions, although they emphasize that you don’t have to memorize, are really just that a question you get wrong if you don’t know the equation off the top of your head (especially RSA, Crypto). I feel like if they reduce the time allowed on the exam and don’t have students do such a invasive room screen, the worry that students will cheat will go away. Like really…? Would students be able to cheat through everything given 60 minutes if they don’t know jack about the subject at hand?

This is a mandatory class for most students, and its dealing with a topic that’s pretty close to employment since a lot of interviews go down the DS/Algo route, but this just makes me frustrated at DS/Algo and it honestly feels like a waste of time / tuition at this point. I’ve never been demotivated as much taking a class at GaTech. Seriously. I’ve always attempted to get an A in every class, but this one I’m hard settling with just getting a B.

There is a really great TA that caught my eye who is always available to help students on Slack, but really I think this course as a whole is horrible, especially because I had such high hopes for it because it was impossible to register for.

I feel like I would have learned the same amount without all the unnecessary stress by just reading The Algorithm Design Manual or just the Dasgupta book the class uses. But the only way to avoid this class is to go the interactive intelligence route (which I totally would if I were to go back to when I started the program). I feel like the only thing I got out of the class is to feel a bit more comfortable with Dynamic Programming. The program should really make this class an elective if this status quo is the standard intended, or really try to make the learning experience more meaningful.

Course is good, except the TAs.

I got an A in the end but I still feel it’s hard for me to like this course. This is the only course I have taken (this is my last course) that making me feel so bad because of TAs.

Initially I found myself enjoy watching the course video. But this good feeling being changed since I received the first homework grading result.

Some TAs don’t even spend time reading students’ answer but just trying their best to make as lower score as they can. They are the King of this course, ruling and controlling everyone. They have no mercy. They don’t understand students without their certain background of grading rubric and just trying their best to ruin the learning experience. Luck is very important in this course.

Today when I saw one of the graph problem questions I learnt from this course, the immediate feeling on seeing that is disgusting. I never had such experience in other courses. I may have Algo PTSD now. I feel I have to leave this comment for anyone who has the option not to choose this course: JUST RUN AWAY.

This is a solid course: You will have a clear mind map of the importance of each Blackbox algorithms, what you will learn, how you going to learn, how well you have mastered.

Very wonderful positive learning experience from lessons, piazza discussion. But very terrible grading feedback from some TAs (I will detail this in the end of this review.).

Overall, this course constantly reminds me that: those black box algorithms, created by those accent math genius, can be understood, mastered and discussed by us engineering students.

Thanks for this course creator and Part of Fall 2021 TA teams! (Although I passed Exam 1, Exam 2 with medium scores, I really wish I can pass this course without taking final exam(optional) Passed with a easy B; The minimum requirement to get A is to try your best for exams.

The grading feedback from Some TAs in the Fall 2021 semester are really horrible.

• I believe that there is some unspoken rules: (Homework weights are small(7 homework accounts for total 12% grading). Students are encouraged to discuss how to solve those problems without directly revealing answers.)
• But even based on the above expectation, grading feedback from some TAs are still not professional.
• If you have a hard time finishing homework or not confident you have nailed that homework, but you wish you can get positive grading feedback, you will end up with disappointment: because some of TAs contributed little effort to grade your homework (although there is nothing staying in your way of regrading.)

This class is like Uncle Leo. It thinks it is a lot better than it is, but it is quite boring and frankly average. But it means well, I guess. It is not very rigorous for a top CS program and the exam format emphasizes memorizing, but it is managed well and is easy to do well in. So, while this class is not good and could be so much better, I also think it is possible not to screw it up. Just read through tips from other reviews here. 

Also, I realize this review is pointless because you probably have to take this class anyway, so whatever!

• TAs are very active on Slack and Piazza. They also appeared to feedback well, at least based on their Piazza posts. 
• Brito runs regular Office Hours and seems to care about students understanding. The conversation is sometimes derailed by one or two students, but I respect his patient effort overall.
• The lectures focus on a small number of topics, but those topics are taught well. Vigoda is uninspired but manages to make things easy to understand.
• Quizzes are open-everything, unlimited time, 2 attempts, so it is easy enough to get full points on these. The questions themselves were sometimes pointlessly tricky and a precursor to exam MCQs.
• Homeworks are also weekly and open-everything, and you can work with a study group. They are often based on DPV questions for which solutions are available online, so you can easily get these right, even if you don’t get the full grade. Quizzes and HWs being weekly ensures you don’t lag behind on lectures.
• Joves’ notes should really be listed as the mandatory reference for this class. In terms of formatting and setting expectations, they provide everything anyone needs. 
• Teaching philosophy: The course aims to cover a few topics in depth but not too many of them. This often made the course feel like it was moving too fast, maybe made worse by this being the summer semester. Also, the lectures were not enjoyable and did not inspire any interest in me for the material. This was made worse by the testing philosophy.
• Testing philosophy: In general, the focus is on memorizing and remembering everything. The strict room scan guidelines, not allowing even cheatsheets etc. arise from this. But this is most obvious from the actual exam questions, which were minor variations of Homework or practice problems, instead of creative problems that test your ability to apply concepts rather than just remember the solutions. The exam MCQs were intentionally and unnecessarily tricky, favoring focus on wording rather than real understanding, and the grading was petty.
• Grading: The grading is uneven and its primary focus is nitpicking on minutiae. This would be acceptable if they were important nuances, but often they were silly details. Like someone else pointed out, this class tries to appear “cool” and “fair” by claiming many things are allowed when they are not. Like, they made a Piazza post saying “Does this class have a pseudocode convention? NO.” But they had somewhat unsaid expectations on what they considered pseudocode and what they didn’t. E.g. saying “for i in” is acceptable, but using “end” at the end of a loop is not. Distinguishing “=” and “==” was considered code in HW1, but in HW5, graders distinguished k=n and n=k. Since the TAs don’t seem to have math background, they didn’t know that math does not have directions in processing equations, only code does. Similarly, saying S’(I, n) similar to lectures was often misread by TAs but stating set k=n was not. Also, some homeworks required us to write the algorithm in words which is quite stupid. Consistency is NOT their strong point.
• More grading: When the instructors make a mistake, most classes would give everyone the full points or drop the question altogether. Not so this class. They had mistakes in 2 different exams and both times they simply changed the grade suddenly, so people had to see their grade drop. They did give free points on the final, but that doesn’t justify anything. The instructors are reluctant to admit their mistakes and have probably never heard of humility.
• Peer Review: This was obviously uneven and sad to watch. People who didn’t define “mid” in binary search had their regrades supported but people who didn’t define “left half” in binary search didn’t. They should really do away with it because more people seemed to enjoyed throwing stones than actually learning from peers’ work. It got rowdy sometimes and the power of rejecting peers’ regrades got to some student’s head, but at least they are not paid by the university to do this.
• Minor issues . It was unclear at the start of the class when the quizzes, HWs and coding projects were due. The syllabus was updated later with the coding project release dates, but not at the start. This really hurt my ability to plan ahead. Also, if you watch closely, there are some minor errors or misleading statements in the lectures. These are mostly clarified by reading the textbook, but could have easily been avoided.

Honestly, the real problem with this class is that it focuses on many things other than learning - memorization, following arbitrary rules, fitting yourself into a mold somebody else designed. It does not encourage curiosity or questioning or being a little different, and is not aimed to cultivate interest or even be enjoyable. However, if you follow the arbitrary rules and put in the work, you will do fine. Just don’t question. Be another brick in the wall.

My background: non-CS undergrad, have dabbled in but never completed a MOOC on algorithms, so this was my first real algo class. It’s my 9th class in the program, so I’ve seen DFS and BFS a number of times by now, and the graph algorithms were not strange-looking even if I didn’t know them very well coming into the class. I have seen FFT as a MechE, but not from an algorithmic approach.

I was worried about taking the class this summer after reading the reviews here. First of all, Dr Brito was great and Joves and the other TAs were great. The class was well run, even though no one seemed to know how to use canvas (not a huge deal but I did get caught out by a HW deadline that was a day earlier than most weeks because a test was scheduled for 4th of July weekend. I managed to get it done, but only cause I got lucky and didn’t have anything else going on. I feel like a canvas deadline instead of reading it off of a pdf of a word doc would have made it less likely that I would misread it…anyway).

Personally, I found Dr. Vigoda’s lectures amazing. As good or better than the highly rated MOOCs I didn’t complete. He explains things very slowly and step by step, repeating the main points at the beginning and the end of the video. While this may be very slow for someone with a better background, I found it very helpful. Also, as an aside, I found his voice very soothing (I wonder if he’s related to Abe Vigoda?)

I also read the sections of the textbook recommended by the class and for the most part any part of the text I didn’t understand was elucidated by the lecture and vice versa.

The HW’s (and quizzes) were basically guided studying. They recommend you complete, say, 5-7 specific problems, but only grade 2 of them. I ended up completely all of the recommended practice problems as prep for the exam eventually, but having the HWs due each week kept me on schedule. While it’s true they ask for a specific format, they do grade relatively fairly if you stick to it, and they certainly don’t try to trick you on the format. Also, Joves’ notes are invaluable (I hope he continues to TA and offer his notes in the future).

The tests were difficult but fair. The free responses were just like HWs (not trick questions) and the MCQs were very tough but fair (unlike GIOS MCQs).

The Python coding projects were pretty simple. I’m not really sure what the point of them was. They could have been a little more creative, which would have added a slight level of difficulty, but they were all very straight forward, with lots of skeleton code.

Overall, I found the class high stress, but very doable during the summer. I got an A with hard work, but not excessive time (I track my time very closely). It has greatly increased my understanding and confidence in analysis of algorithms and I’m ready to get studying on leetcode. Overall a top class in my opinion, like AI, HCI, and GIOS (of the ones I’ve taken).

If you have been reading the reviews for this class, you are probably confused whether it is super easy or super hard. Truth is, it is both. 

First of all, how difficult you find the material depends on how difficult you find algorithms in general. If you have never studied algorithms before, how much you like mathematics, puzzles or leetcode problems can be a good indicator. Like school math, people either find algorithms super obvious or find it impossibly hard, and you might fall at either end. But how well you do in this class is not correlated with the difficulty level at all. In fact, this class is positively easy if you do the right things. This review will focus on what those things are. Remember that if you find algorithms fundamentally difficult, you will need to put in that much more effort.

Prepare ahead of class to have an undergraduate level understanding of algorithms Before you start the class you should know some basic sort and search algorithms, what asymptotic analysis is, and should have at least seen a graph before.  This class would be super easy if you recently did a good algorithms course (where you had to understand and apply algorithms to problems). But if you are rusty, watch a free one online. Stanford and Princeton have great courses, but any undergraduate course should do. The goal is to learn basic algorithms and complexity analysis and feel “familiar” with the material. While watching these, if you feel you don’t understand it fully, I highly recommend you take a semester off to come up to speed. Some people have done Leetcode problems to prepare for this class. I don’t think Leetcode is necessary, but it can help if you have never ever done an algorithms problem before. 

Watch the lectures a few times and really understand them (not just watch them blindly) The lectures give you everything you need to know, if you watch them carefully enough. Vigoda is not a compelling lecturer, but he is surprisingly effective. If you keep at it and watch the lectures a few times, the concepts really start to click, more so if you pause and reflect on what he is saying, maybe even jot down stuff as you watch. 

Try to get full points on projects and quizzes The quizzes are worth 1% each and the coding projects are 3% each, so definitely try to get full points on those. Quizzes are untimed and open book so you can open the quiz, look at the question and then get to work on it. Watch the lectures before you open it, then read the question, and you can rewatch lectures and/or read appropriate sections of the textbook before you attempt. For coding projects, folks in our semester shared test suites which were more than sufficient to get full points on the projects. Remember that passing GS alone may not be sufficient for these.

Use the homeworks well Homeworks are open-everything, and for many of the problems solutions are available online. Learn from these (and cite appropriately). Have a good study group where you vet each other’s ideas/submissions and try to catch most of the errors yourself. Also, try to use Joves’ notes as the format if they are available. Ideally, you shouldn’t lose points for incorrect solutions on these, but if you do, remember it is better to learn from the mistakes in the HW than lose the same points on the exam which are weighted higher. Also, if you lose a few points for a correct submission, use the peer review process to verify/strengthen your case. Don’t hesitate to file regrade even for 1-2 points, these will come in handy later.

Do all the wiki and practice problems The homeworks, wiki and practice problems give you a good idea of what to expect on the exams, so do not miss out on these. Work out every problem on the list, and maybe even try to write it out and get your study group members to check. Compare with the published solutions and/or Joves’ notes and hone them. At the very least, you must be able to solve all these problems without looking up solutions before you start your exam. 

Study for MCQs: If you did everything above, you will be able to get most of the free-response points on the exams. However, many folks, including myself, underestimated the importance of the MCQs, which are a lot trickier than the quizzes. Watch the lectures carefully, especially the portions not covered by free-response (Fourier, etc.). On the exam, challenge your own answers and see what might make the answer wrong. If possible, get your study group members to quiz each other before the exam window. If you do badly on exams, good thing is the optional Final is all free-response. (not available in summer)

MOST IMPORTANT: Follow all the guidelines (the thing that trips many people up and leads to reviews stating “I knew everything but got a B because this class sucks”.) This class has a bunch of rules/guidelines which they follow very strictly in grading. Yes, this leads to a lot of people finding this class difficult or finding the grading unpredictable. But, honestly, there is no need to. 

Many people break one or more of these rules and then complain that they lost points. Or try to justify why the rule is invalid. But that’s the bad way to deal with it. Just assume these rules are written in stone. Work accordingly. It is really not that hard. Yes, I disagree with some of the rules and I wish it were otherwise. But this is grad school. If you plan on finishing the course this semester, be an adult and deal with it.

For those of you who are interested, here are the “rules”:

• State everything they want you to state (correctness, runtime, etc.)
• When they say no code, don’t write code.
• When they say no pseudocode, don’t write pseudocode (this is sometimes tricky, but really not that hard. I took care to make my for loops into full sentences describing a loop just to be sure.)
• When they say don’t modify a blackbox, don’t modify a blackbox. The whole point of the question is it’s possible to do it by tweaking the input (or the output). Think accordingly.
• Index starting at 1 (Except for fourier). 
• Don’t use hash tables. And no, hash table access is NOT worst case O(1).
• Go from known to new. The blackbox is always the new one - it’s as simple as that. Also, the transformations should follow the correct direction, it is insufficient to just write the names of the known/new algorithms correctly.
• A correct significantly slower algorithm will lose a lot of points for the first few exams (like 12-15 out of 20). So really try to keep your runtime to the expected value. (the expected runtime is pretty obvious based on the problem type btw). Runtime can be suboptimal for NP, but should match the algorithm you describe.  
• Read questions carefully. Directed graph is not the same as undirected. Connecting to every node is not the same as connecting to any node. These seem like minor wording issues, but some words are less minor than others.

And that’s it. Congrats on that A. (or the definite B). Thanks to Joves for the notes, they were gold. 

A lot of people have really strong opinions about this class one way or another. I thought the class was entirely average. I wasn’t a CS undergrad, nor did I have any experience with an algorithms class before. I managed to get an A by just watching/understanding (most) of the lectures, taking notes on some of the more involved stuff, and doing the homework. I used the Stanford algorithms class as a supplement for graph problems because it does a little better job at covering BFS and DFS (which I had never heard of before this class but the videos treat as “review”). I didn’t do any of the extra problems after the first two weeks (though maybe it would have helped me “for the sake of learning”…I don’t think the extra problems really helped with the exams.) I think I would have enjoyed the class more if I put more time into it, but I ended up doing pretty minimal work because the lectures bored me to death.

My suggestions for being successful in this class are: 1) understand the basics, 2) internalize the format given on Piazza for the homework…and then use that format on the exams, and 3) don’t mess up. If you mess up a single free response, it can make the rest of the class difficult and scary. (No pressure, since exams are 75% of your grade, right?)

Copy and paste from my blog

To pass this class, you should:

• digest everything written in Joves’s notes (he’s a TA and will release these notes gradually throughout the semester so pay close attention to his Piazza posts)
• join or form a study group of a handful of students dedicate at least 20+ hours per week to drill, memorize, and apply algorithms
• complete all the homework assignments, (easy) project assignments, and quizzes (these are all easy points and you’ll need them given that exams make up 70% of your final grade)
• drill ALL the practice problems (both assigned and extra ones published on the wiki ) over and over again until you’ve memorized them Almost failing this class

And I tend to agree with the other reviewers here:

• Grading is VERY harsh
• I agree that the format exam #3 changing 1 day before the exam threw me off completely
• You can watch all the lectures and still BOMB/fail the multiple choice portion of the exam
• This class needs to be recalibrated
• Unless you have studied algorithms before, or have a math background, this class will ruin your life for 3 months

On the plus side

• Professor Brito is a stud and really cares about the students
• You’ll learn a lot about algorithms that will sharpen your tools as a computer scientist
• Teacher assistants work hard and are very active on the forum

Barely surviving this class

This class kicked me in the ass. Straight up. Words can barely described how relieved I feel right now; now that the summer term is over, my cortisol levels are finally returning to normal levels.

I’m not exaggerating when I say I teared up when I learned that I received a passing grade. I barely — and I mean barely (less than 1%) — passed this class with a B, a 71%.

Throughout the last week of the summer semester, while waiting for the final grades to be published on Canvas, I had fully prepared myself (both mentally and emotionally) for repeating this class, level of anxiety and stress I haven’t felt throughout the last 3 years in the OMSCS program.

Other students in the class felt the same level of despair. One other student shared that he has:

never felt that much pressure and depression from a class in [his] entire academic career.

One other student definitely did not hold back any punches on Piazza:

I am going to open up a new thread after this course finishes out. I am tired of the arrogant culture that is in this program and specifically in this course! There is a lack of trying to understand other perspectives and that is critical for creating a thriving diverse intellectual community.

So yes — this course is difficult.

All that being said, take my review with a pinch of salt. Other reviewers have mentioned that you just need to “put in the work” and “practice all the assigned and wiki problems”. They’re right. You do need to do both those things.

But the course may still stress you out; other courses in the program pretty much guarantee that you’ll pass (with an A or B) if you put in x number of hours; this doesn’t apply for GA. You can put in all the hours and still not pass this class.

Additional considerations

Before getting into the exam portion of my review, it’s worth noting that the systems classes I mentioned above play to my strengths as a software engineer building low level systems; in contrast, graduate algorithm predominately focuses on theory and is heavy on the math, a weakness of mine. Another factor is that I’ve never taken an algorithmic course before, so many of the topics were brand spanking new to me. Finally, my mind wasn’t entirely focused on this class given that I had quit my job at FAANG during the first week this class started.

Okay, enough context. Let’s get into discussing more about the exams.

As mentioned above, do ALL the practice problems (until you can solve them without thinking about it) and really make sure you understand everything in Joves’s notes. I cannot emphasize these two tips enough. You might be okay with just working the assigned practice problems but I highly recommend that you attempt the homework assignments listed on the wiki since questions from the exam seem to mirror (almost exactly) those questions. And again, Joves’s notes are essentially since he structures the answers in the same way they are expected on the exam.

Exam 1 consists of

• dynamic programming
• Divide and Conquer (DC)

Read the dynamic programming (DP) section from the DPV textbook. Practice the dynamic programming problems over and over and over again.

Attempt to answer all the dynamic programming (DP) problems from both the assigned practice problems and all the problems listed on the wiki . Some other reviewers suggest only practicing a subset of these problems but just cover your bases and practice ALL of practice problems — over and over again, until they become intuitive and until you can (with little to no effort) regurgitate the answers.

For the divide and conquer question, you MUST provide an optimal solution. If you provide a suboptimal solution, you will be dinged heavily: I answered the question a correct solution but the runtime was O(n) and not O(logn), so lost half the points. 50% of my grade down the drain. So, make sure you understand recursion really well and solve for an optimal solution.

Exam 2 focuses on graph theory. You’ll likely get a DFS/Dijkstra/BFS question and another question that requires you understand spanning trees.

The instructors want you to demonstrate that you can use the algorithms as black boxes (no need to prove their correctness so you can largely skip over the graph lectures). That is, you must understand when/why to use the algorithms, understand their inputs and outputs, and memorize their runtime complexity.

For example, given a graph, you need to find out if a path exists from one vertex to another.

To solve this problem, should know explore algorithm like the back of your hand. You need to know that the algorithm requires both an undirected (or directed) graph and a source vertex as inputs. And the algorithm returns a visited[u] array, each entry set to True if such a path exists.

That’s just one example. There are many other algorithms (e.g. DFS, BFS, Krushkal’s MST) you need to memorize. Again, see Joves’s notes (recommendation #1 at the top of this page). Seriously, Joves, if you are reading this, thanks again. Without your notes, I would 100% have failed the course.

Understand the difference between NP, NP Hard, NP-Complete.

I cannot speak much to the multiple choice question (MCQ) since I bombed this part of the exam. But I did relatively well on the single free-form question, again, thanks to Joves’s notes. Make sure that you 1) Prove that a problem is in NP (i.e. solution can be verified in polynomial time) and 2) You can reduce a known NP-Complete problem to this new problem (in that order — DO NOT do this backwards and lose all the points).

Some students will cruise this class. You’ll see them on Piazza and Slack, celebrating their near perfect scores. Don’t let that discourage you. Most of students find this topic extremely challenging.

So just brace yourself: it is a difficult course. Put the work in. You’ll do fine. And I’ll be praying for you.

Hands down the worst course of the 9 I have taken in this program. Topics in the class were certainly interesting but the course was ruined by the way this was graded. The teaching staff were approachable however the “grading TAs” were some of the worst I’ve seen. Right from exam 1 there was a mad scramble to figure out which is right, exact template with the right amount of context required to answer the free-form questions(which constitute a bulk of your final grade). Many solutions require hand wavy explanations and proof and this is expected to be in a very particular format. There was one TA who was helpful enough to unofficially provide the expected template for these solutions. The TA grading was so inconsistent that they were happy to deduct 5-20 points for a 20 point question because they did not like the structure or wording of the answer. It becomes another uphill challenge to prove you need a regrade which for some weird reason has to be posted on Piazza for the whole class to judge? Basically to pass this course you are expected to highly memorize and regurgitate answers if a very specific template and pray you get graded by a TA not having a bad day. The learning experience could be made so much better especially since this is a core course for 3/4 CS specialization.

Good content but really poor execution of the class. Stress is so much on textual writing. Agree many could do well, but going by the reviews and even the commotion in piazza forum, one can easily guess people struggle. One other reason is, people who repeat will also mess up the avg and eventually the curve. So I see no one benefitting. People repeating would impact next batch and that will cause more new people repeating and vicious cycle will keep repeating. Grading was so harsh and lectures boring.

I don’t get what is the purpose of this course when there is 0 or 1% focus on application and 100% on writing skills. And with grading style you enforce people to repeat every single batch. As if gatech wants to make money but making people repeat this course. Just make it an elective course and lets see how many students continue in the course after first exam.

As the other reviews point out, grading is inconsistent. You would be much better off learning algorithms at a different school (CLEARLY this is not GT’s strength), but then again you probably need CS6515 to graduate. Getting a B is very doable, but putting in A work doesn’t guarantee you an A. On the other hand, putting in B work might get you an A. That depends on which grader you get and if you guess correctly on the multiple choice questions. So my advice is to get lucky. Don’t be like me and learn the material only to get wrecked by trick multiple choice questions and obstinate graders. I do recommend biting the bullet and taking this during the summer, because another 5 weeks of this would be actual torture.

Just to be 100% clear, the previous reviewer says “I don’t understand some of the reviews about subjective grading” and “I think I might get an A which is such an accomplishing feeling”. I’m sure they did work very hard and learn some things, but there is no question that they also got lucky (or didn’t get unlucky, depending on how you see it).

What a banger of a class. This is my 9th class and was by far my favorite class in the program. I had no algorithm background at all and only did the DP problems before the class started. I was so scared of this class and if you are reading this like me, I’m here to tell you if you put in the work you will be fine. I think I might get an A which is such an accomplishing feeling. I never felt like any of the material I couldn’t grasp, except for maybe FFT yikes. Be prepared to work tirelessly on this class if you have no background. Don’t get discouraged by the people who have taken an algo class before and know literally everything, try to learn from them and join a study group with them. This class ruined my life (In a good way) for 3 months or so.

I don’t understand some of the reviews about subjective grading. They literally give you templates and tell you what to expect. I feel like the “The grading was subjective and unfair” people are either lazy/didn’t try/dishonest/”I know better” or a mixture of them. You go into the semester believing this and then you read the Piazza regrade threads and realize they are one of the adjectives above. This isn’t to say the TA’s grading was perfect there were mistakes, but anyone who honestly answered correctly but in a different format got their points back (me included).

Our Piazza/OH was dominated by shitposters and that really took away from the class imo. I understand the high stakes of this class but 2-3 people dominated all of the channels of communications and wouldn’t quit until they got answered. They also hijacked OH and just asked questions that were self serving for them and really ruined the experience. However, though all of the noise, you could usually get some great hints on exams in OH.

Finally, I have to give a shoutout to Joves Luo and Rick Suhr. These two were model TA’s and I feel never sleep. They always were online answering questions and I felt they truly cared about students and everyone succeeding who wanted to. I am not dogging the other TA’s I just never interacted with them.

Joves’ notes are worth their weight in gold and use them if they are available. However, I would not be shocked if they are discontinued as our class was so whiny and needy that they probably ruined it for future semesters which is a shame.

These were great practice for the exams. They were about the same difficulty as the exam questions so be sure you understand them. Be sure to take advantage of the ability to review each others homeworks and use outside sources. Follow the templates and Joves’ notes if provided as these are the format you should follow. Don’t be a stooge and refuse to look at them and then whine about subjective grading.

These were fun and trivial. Be sure to use all test suites provided by other students as they can save you from losing points on edge cases. This is the easiest part of the class imo.

These were meh. They are a good indicator of what to expect on the difficulty of the MC questions, which are HARD. More on that later. I felt these were meant to trick not test but still got full marks on them.

This was the easiest of all of the material. I was prepared for both long answer questions and didn’t feel like either was unfair. The MC problems were BRUTAL and require a lot of studying to do well on. If you bank on this being the hardest test, you’re going to have a bad time. You’re going to want to nail this one.

By far the hardest exam. Graphs are just really hard imo. Both long answers were fair but HARD. Be sure to know graph terminology as well because the last thing you want is to not know how to answer a question because you have no idea what it is asking. The MC I did initially the best on but got 3.5 points stolen from me #stopthesteal. I am salty about this but it is what it is. They made this right at the end of the semester so no quarrels for me now.

This was a different format than the others in which it had 1 long answer and the rest MC. The reduction was very fair and straight forward but the MC WRECKED ME AS USUAL -_- NP-C reductions are by far my favorite topic. They are terrifying at first but once you get the hang of them they are fun. It is the most CS’y part of the class and makes up the “Science” in CS imo. LP is meh.

All of the wiki problems + other book problems I felt were similar in difficulty/covered material not covered in the wiki (you will know this). I did at least 5 problems a day, every day. Thats right, 5 or more a day, every day. I had every problem memorized by the exam I did them so much.

Joined a great study group. These guys and girl are the main reason I succeeded in this class. They were all way better/more intelligent than me and I definitely am thankful for them. One of them was sus though, he knows who he is… ¯_(ツ)_/¯. If you don’t join a study group you are doing yourself a disservice and good luck to you.

Spent a minimum of 3 hours every day on this class. It takes a long time to master this material if you have no background and you have to practice. I got burnt out about 3 weeks in but kept on pushing. This class will push you mentally and physically.

This was a great class and my favorite in the program. The material is challenging yet approachable. The MC is BRUTAL and I watched the lectures 5-6 times and still averaged 11/20 on them. Be prepared to work and you will pass this class. Get a good squad of people to #stopthesteal

This was a very unpleasant and stressful class. It reminded me of a long programming interview, which takes months to prepare for and once it is over, you will never have to use that information again in your professional career. The lectures did not explain the material well at all. I spent more time watching youtube videos to try and understand concepts and algorithms that were supposed to be explained in the lectures. Exam performance is mostly based on how well you can memorize all of the practice problems and how lucky you get guessing on the multiple choice questions. The instructors definitely did not make our life any easier. They changed HW due dates in the middle of the semester without proper announcement causing some of the students to miss the deadline. One of the exams had several errors in it (including multiple choice format errors) and they still expected us to answer correctly on those questions. The last exam had a format change literally 1-2 days before the exam window opened, which caught many students off-guard and caused unnecessary stress.

Overall, this is by far my least favorite class in the whole program. I know that 99% of the people reading this have to take this course to satisfy program requirements, but for the other 1%, please do yourself a favor and avoid taking this class!

The content is moderately harder compared to the rest of the classes I’ve taken (this is my 10th and final class in the program), but the grades have almost no relevance to how well you understand the material.

Their definition of “pseudocode” is actually very specific, and is so formalized you could probably transpile it into ruby. Any deviation from “pseudocode” and you’ll forfeit all or nearly all of your points.

The exams were riddled with typos, errors and subjective questions, then no exceptions were made when these issues were brought to the attention of the graders.

The expectations of what to submit for the homework was never clear, and the graders were absolutely brutal when they didn’t see a problem solved in the exact format they wanted.

The exams had open-format questions where you’d type out a short essay explaining your answer and multiple choice questions. The open-format questions completely dominated the weighting of points on the exams, so at the end of the semester there were only 5 questions (2 on exam 1, 2 on exam 2, and 1 on exam 3) that almost completely controlled your grade.

The lectures were downright awful. Even when he lectured about algorithms that I already knew very well, it was difficult what he was talking about. They felt like a recitation of technically true, yet unhelpful facts. I had to learn most everything from YouTube and reading the book.

Possibly the worst class offered in OMSCS.

Overall a great course on algorithms but A LOT to take in during the summer if you don’t have a solid background. I took this as a non-CS engineer with no formal courses in algorithms and learned a ton. I’m sitting on a razor’s edge grade wise after taking the final so I’m not sure I’ll pass this semester, but I learned a ton and have a pretty solid understanding of the material at this point.

Homeworks: Generally some problems from or similar to the book and worth ~10%. Depending on your grader you got most of the points or completely screwed over.

Exams: Tough but generally fair. The hardest part is the multiple choice questions and (generally) the written portion is graded fairly - unless you’re grader decided to screw you over.

Coding Projects: Fun little projects to implement an algorithm, would have liked to see more of them. Very easy to get 100% on all of them.

Quizzes: Small one or two questions quizzes to make sure you watched/understood the lecture material. Not worth much and you have multiple attempts.

My one complaint (and that of the study group I was a part of) was the somewhat lack of consistency in grading. My guess is that one or two of the TA’s are MUCH harsher than the rest so if you’re unlucky and have them grading your problems, you can expect even the tiniest of mistakes to drop your score by a lot.

No formal algorithm background but have taken plenty of math courses - the content didn’t feel all that challenging, but (some of) the graders are just hopeless. If you use a slightly uncommon method that the grader has not seen before, don’t expect him/her to be capable of understanding it. There are also those (unofficial) templates - stick to them, even though some parts do not exactly make sense and the question can be solved in fewer steps (some steps are somewhat overlapping) - just stick to them. Graders are not smart, so don’t try to be smart yourself. One advice would be to make those templates official. Otherwise, it gives you the illusion that you can try to solve it in some other format, but in reality chances are you’ll unnecessarily lose points if you try anything else.

In theory there are regrade Piazza threads. But a lot depends on luck. If the first peer to review jumps in and makes a baseless comment without even carefully reading your answer (which happens quite frequently, especially a few overly active classmates…), it greatly diminishes your chance of actually getting a fair review. Some super active classmates are actually helpful (they actually read and provide thoughtful feedback), but some are just out there messing around, making snarky comments without providing any substance (they probably spend more time thinking about how to compose the reply then actually reading your original post/answer).

All in all, course material is solid. Summer is probably not the best semester to take it since it skips some interesting topics, and (at least this summer) we didn’t have the make-up final exam. I’m most likely still getting away with an A unless I really fuck up the final, but I do believe there are rooms for improvements as others have mentioned.

This summer the weight was chosen to remain at 75% exams 25% quizzes, projects, and HWs. Unfortunately, on top of the weights remaining the same, we didn’t get a make up final like the spring and fall semesters. The worst part about the class is how interesting the material is, but the unnecessary stress and subjective grading overshadows the material. For exam 1, I understood all the material but misread one of the free response questions that was extremely easy and like one of our HWs. This one mistake dropped my E1 grade from a B to a D. I spent the rest of the semester stressed and worried about passing and graduating since the exams counted for 75% of our grade with no make-up final. To echo what others have said, to succeed in this class you need to grind out practice problems assigned and mimic your answers to match Joves’ notes. All in all, the class needs to be completely revamped in my opinion. I could have learned all the material without being constantly stressed and full of anxiety due to the weightage of the exams and the poor subjective grading.

This class has so much potential. Its learning objectives are literally the bread and butter of unfathomable achievements in computing over the last few decades. And how does this class attempt to live up to this legacy? By deemphasizing actual coding and judging understanding on high stakes exams graded by biased TAs with zero feedback. I came into this program to become a better software engineer so that I could make a difference in my field, not so I could feel good about surviving yet another weed out class. Whoever designs this class needs to seriously recalibrate the distribution of assignment weights. If a person can find the answer to a hard coding problem or conceptual problem, chances are that person could apply that knowledge to a real world situation. Being able to produce results under pressure still has its place, but that should not be seen as the end all be all of a student’s abilities.

As others have mentioned, the exams are worth a lot of points. This is made worse by the fact that they are graded somewhat subjectively and extremely harshly, in the sense that if you don’t get the exact answer the grader is expecting, there’s a very real chance you’ll get close to 0 points for that problem. So even a single question that is not completely correct can absolutely destroy your grade in the class. I’ve literally lost hair from the stress this class has induced, but more from the logistics relating to the exams rather than the actual material itself (which actually isn’t too bad and is pretty fun even).

This is a cruel and unforgiving class. The material itself is challenging, just like many other classes. But whether you pass or fail this class is basically decided by 6 short answer exam questions, each worth 8% of your grade.

There are 3 exams worth a total of 75% of your grade. Each exam has 10 multiple choice questions and 2 short answer problems. The short answer problems are similar to programming interview questions: wholly original problems that you need to solve on the spot, which all require a few “a-ha!” moments during the exam. However, the questions are typically vague. And they’re each worth 8% of your grade. If you can’t figure one of them out completely, you’re sunk. There have been threads post-exam trying to interpret what the problem was actually asking. When it’s not all that hard for the exam writer to add a few more clarifying sentences to the problem. The rest of the class involves 6 open-book quizzes, 7 homework assignments, and 3 coding projects. Together, these deliverables only total up to 25% of your grade. You’ll want to score 100% on these, since they function basically as a “self-curve” on the exams.

If you have a strong background in mathematical theory and have taken an undergraduate algorithms class recently, you can power through this class. But for everyone else, this class will basically ruin your life for 3 months.

Little code writing for this course. Grading is subjective and grading rubrics are never provided. Refrain from using any prior knowledge in any other algorithm classes. Pay extra attention to Jove’s notes if provided.

A class that stuffed with rich contents. The only and biggest complaint from me would be, exams are taking way too much weight in the final grade (75% for 3 exams).

Thank to the extra final exam, I was able to rescue my letter grade from B to A. I was 2 or 3 scores off from the cutoff.

But truly, the time I spent on homework and projects are equal or even more than that in exams. Not to say the short-form questions are somewhat “you know then you know” fashion, it requires a bit “aha” moment when you’re taking the exam.

How difficult this class strongly depends on 1)whether you’ve taken an algorithms course before and 2) your general comfort with math and proofs. There’s also a decent amount of misinformation surrounding the class. You should not, for example, spend all day leetcoding dynamic programming problems in order to prepare for the first exam. Pay attention to the TAs, Joves’ notes (if available), and office hours and you should get a good sense of what to expect on the exams and how your answers should be structured.

Here are some practical tips for success.

Background: Undergrad STEM BS, CS minor, 4.0 student in OMSCS. This was my 10th and last class. I’d never taken algorithms and was worried I’d be at a disadvantage compared to my BS CS peers, but I ended up doing above average for all tests. Ended up with ~90% skipping the final to get an A in this class.

Effort: Watching lectures and doing actual deliverables was maybe 6 hrs/week. The rest comes from doing and redoing the practice problems. Highly suggest doing this to prepare for exams.

Exams: About 4 of 6 exam problems were exactly the same as a hw problem but maybe with a small tweak. The other 2 were still based on a hw problem but needed a bit of a bigger leap. I felt prepared, stayed calm, and did not freak out about “bombing” a single question to destroy my grade. I was able to come up with a working solution for all problems, even if it was not the most optimal solution. There was a lot of partial credit.

Things I did not do:

• extra DPV problems that weren’t assigned as practice
• read the DPV textbook
• spend time rewatching and fully understanding proofs (you won’t be tested on proofs themselves – only the concepts/applications)
• take my own notes. Thanks Joves lol. actually this is a bit of a lie. I did jot down ~5 sentences of high level concepts for each lesson
• attend office hours. this can be useful to students who need to spend extra time going over problems if they don’t get it the first time during lectures.

Things I did:

• joined a study group of ~6 people and had weekly meetings to discuss hw solutions. (I called them answer sessions). Also studied together by redoing problems together or quizzing each other via text
• aligned my expectations with grader expectations. e.g. knew what was and wasn’t important while watching lectures, synced my exam/hw response format to what they were looking for
• watched all lectures
• did all practice problems at least 2-3x times until i could do them from scratch. i didn’t spend too much time trying to figure it out on my own first. i often just jumped to looking at the answer. but then spent time making sure i understood the answer, memorized, and could conjure it from scratch next time
• had all lecture and practice DP problems straight up memorized but this turned out to be overkill for exam

Overall I enjoyed the class. Class was well-run, instructors and TAs were great, and the material was worthwhile and I learned a lot about algorithms.

Took it while taking job interviews and found it very helpful especially the DP part. I don’t find better resources available that has a better explanation and practice problem that you can be a DP expert. This actually helped me, among other factors, got my current job.

The workload is manageable if you have background in algorithms, follow the video, read textbook as instructed and do practice problems.

The downside is it has 3 exams, each of them has 2-3 questions but took 25% of your final grade. So if you bombed on 1 question, you know how much you lose in your final grade. The worse part is some of the exam question does requires some ‘aha’ moment to come up with a viable solution, especially for DP and NP problems. Btw, NP is not useful at all for real job in the industry but could be a intellectual enjoyment/challenge.

Pro tip. I know this is a required course so you’ll have to take it sooner or later and it’s hard to get into before the last semester. But if you have the choice, pair with your job interview can be helpful.

Enjoyed this class overall and definitely learned a lot, but like many have said very stressful at times.

Background: my 6th course in the program, have taken IIS, ML4T, DVA, AI4R, and Comp Photo.

Class Experience: I found the homework and quizzes to be of good difficulty that test the topics covered. Being open to collaboration and notes respectively, definitely take the time to ensure you get every little point you can as it could be down to the wire in your final grade where one quiz point could be pass or fail for the whole class. I averaged ~90% on these, its a great opportunity to learn how things are formatted/graded, and when the TA’s say the test questions are like the homework and quizzes, they mean it.

For tests, I bombed the first one hard… Like 12 points out of 60. This caused a very stressful semester for me as I did not want to drop and was willing to take a C to gain experience for the whole class to make a second run even better all around. I followed up with the second and third tests being much better, on average 43/60 points per test. The format for the types of questions and scoring in the second and third test is easier than test 1 but its still easy to lose all points on silly mistakes.

Prior to the final they release tentative grades and possibly a curve as it doesn’t happen every semester. this semester, the class was curved by 3% from the starting percentages, so a B was 67% and an A was 82%. I did well enough to earn a ~63.5%, i was 8 test points away from a B so every point matters. The final exam was cumulative and optional to replace the lowest score of your first three tests. Having a 12/60 this test was replaced for a higher score. On the final I scored and equivalent of 51/60 and my final grade was just over 80% for that sweet sweet B.

Test content is derived from the techniques taught in the lectures which are direct reflections of the class book DPV. Ensure you critically understand that content and the assigned practice questions and you will do fine.

Overall, take your time to learn what they are trying to teach you, they are very intentional with the things they post and say on piazza. If you stumble, you can recover. Keep your head up and stick with your goals.

Good, difficult course on algorithms. This class is very well run from an instructor perspective and does a great job of scaling the teaching of a topic that I think is particularly hard to scale.

While not ridiculously hard or time-consuming, this is a very stressful course given the nature of the grading (heavily exam based), this is my 2nd class and frankly I was getting kinda burned out by the end. The final came in super clutch, so if that is an option for your semester don’t feel bad if you don’t have the grade you want after E3.

The problem with this class isn’t that it’s hard. It is hard, especially if you haven’t been exposed to this material before. That’s ok though, it’s all definitely learnable and I’d even say interesting. The problem with this course isn’t even the emphasis put on exams (75%). The problem is the subjective grading by the TAs on those exams. Unless you frame your answer EXACTLY as whoever is grading your exam wants it, you’ll lose points - sometimes a lot of them. Example without being too specific: if you write let y = x, but the grader is looking for x = y, you could lose 10 out of 20 points on an exam. Those 10 points are basically 4pts off your final grade. Be prepared to fight for points on every exam through re-grades.

The key to passing this (which I did, barely) is to not try to answer the question, it’s to answer it how the grader wants it to be. Sometimes that’s subjective and is the one major downfall of this class.

This was my last class in the program, and I’ll walk away with my degree - but it left me with a very sour taste in my mouth for the program and Georgia Tech in general. It’s sad because I should be elated to finally graduate, but instead I’m angry at nit-picky grading that doesn’t even matter in the long run.

One thing I will say is DO NOT GIVE UP! As frustrating as this class is, there is still a good chance you can pull it off. I did absolutely horrible on all 3 exams and had a hail-mary of a chance on the final to pass. Despite thinking I had no chance of making up the points I lost, the curve was lowered by 3 points. With the curve and doing well on the final, it was just enough for me to make a B.

Another one thing, Joves and Rocko are fantastic TAs - Go to or listen to every one of Rocko’s office hours and I guarantee you’ll learn more than sitting through the lectures.

This was my final OMSCS course and overall, l enjoyed it. There are definitely things that I think would improve the course (more info below) but it was worthwhile and I think ultimately fair. I have a BS in CS and took an algorithms course in undergrad, so I think my workload hours (15 hours/week) is less than what a lot of people end up spending.

General Breakdown Exams 1, 2, and 3: 75% total, 25% for each exam In the Fall/Spring semesters, a final exam can replace your lowest exam score 8 HW Assignments: 10% 3 Coding Projects: 9% 8 Quizzes (the exact number depends on the semester): 6%

Criticisms of GA My main gripe with GA is that we had a free response problem as one of our “multiple choice” questions for Exam 3. This is mostly on me for not preparing properly since we had a fill-in-the-blank question for the multiple choice section of Exam 2 as well. I lost 6/9 points for the free response problem on Exam 3 since I hadn’t been expecting that I would have to provide my own answers hah. Yikes!

I agree with other recent reviews that the fact that exams at 75% makes the class really stressful. I got acid reflux and really bad anxiety before each exam so they were unfun to me. I managed to do alright on them and think the anxiety was worse than the actual exam. I think a “Here are 3 problems, answer two of them” would be a better test format and I included that suggestion in my CIOS survey. The fact that the final can replace your lowest score is a really nice safeguard to have. It does mean that you have to do relatively well on the final, but I think this is how they try to address the high exam weight and the resulting stress. I also felt like some of the multiple choice exam questions were unnecessarily tricky or the “big problem” questions were worded in a confusing way sometimes. That being said, I do think the exams were fair. The big problem questions were similar to the ones on the homework/practice problems but usually with a twist. If you understood the hw/practice problem, then you should be able to pivot accordingly. Studying the HW problems and the practice problems will help you prepare for the exams and do well on them.

Overall, slack and Piazza are full of amazing people who are very helpful. But every once in a while, things are weird. One case was that people kept sharing their grades after the exams. I never got the allure of that? I think it was worse when people were boasting about their 60/60 on exams while others were genuinely worried about just passing the class (grade-wise, I was between these two groups). This wasn’t a huge deal but something that I just didn’t understand.

Positive Aspects of GA This class is REALLY well run. I never felt like we had any bumps in the road. Rocko was amazing at posting weekly updates with all relevant information. I also appreciated that the TAs didn’t entertain unnecessary or repetitive questions. Instead, they said “this question was addressed in this post” or would give the link to the Piazza post that answered the question instead of answering it again. This was a breath of fresh air as a lot of other OMSCS classes have students that don’t search for questions before asking them and it’s not discouraged and results in Piazza being super bloated. We did have hiccups (Texas winter storm, Canvas being down for part of the exam window) for the exams that resulted in the deadline being extended. Despite the strict “we will not accept late exams,” I think the teaching staff was pretty understanding when these cropped up and adjusted to them well.

Joves Joves Joves. His notes definitely got me through the semester. I appreciated that he didn’t give you his notes on the lectures but instead gave you notes on the critical information. You had to watch the lectures to understand his notes but they were extremely condensed and included solutions to practice problems/hw problems (after the due date, of course). If you’re given his notes, I would highly recommend taking advantage of them. I used them as a reference and created a private Quizlet flashcard set to study for the exams. Not having to re-read my 200 pages of lectures notes that I took definitely made preparing for the exams a lot easier.

Special shout-out to the other TAs too. Rocko was no non-sense, which I appreciated, and his OH recordings were also really helpful to me. He just seemed like he wanted to help us succeed, which is great to see in a Head TA. Christian was really great at responding to Piazza posts and teaching alternative ways to do things so if you didn’t get it the first way, you had another to try. I didn’t interact much with the TAs but I was really pleased with how quickly they turned out grades for HW and Exams, which definitely helped with the stress of this course.

I had taken an algorithms class as an undergrad and this was a really good refresher while also teaching me concepts better. I learned a TON and feel like I’m a better computer scientist due to this class.

The cohort I took this course with were really collaborative. People shared their testing files for the coding projects and helped others along the way with the homework. The collaborative nature of this class is awesome. I think I learned so much more than I did in my undergrad course because we were ALLOWED to look at solutions/collaborate with others which helped me learn a lot more thoroughly.

Advice for those taking this course First, if you’re doing the II specialization, I would highly recommend taking this class. At times, it was pretty stressful and I cursed myself for choosing this when I could’ve just taken SDP. But I’m glad I ended up taking GA to fulfill that requirement and would highly recommend it to others who have the option of taking it.

Use Joves’ notes. Watch the lectures but use these as a way to really understand the material and the format that the TAs are expecting.

Figure out the format that the TAs are looking for and use it when practicing problems. They go over these in OH and in the solutions to the practice problems. They’re pretty explicit about it/the requirements they’re looking for. Set yourself up for success by making sure you follow the format and hit all the requirements.

Do practice problems without looking at solutions and then verify using the solution. Repeat until you get it down. I had heard the class gets easier after DP and that was simply not true in my case. I loved that with DP problems, you can easily verify whether your solution is correct. You can’t do that as much with other problems. The NP section was easier for me but Graphs were killer.

Spend enough time prepping for both the big questions and the multiple-choice. For Exam 1, I spent all my time doing practice DP problems which was great and I did well on the big questions but I did horribly on the multiple-choice (like 5/20 bad). For Exam 2, I spent a lot of time studying lecture material for the multiple-choice. I did well on the multiple-choice but horrible on the big questions lol (like 20/40 bad). For Exam 3, I allocated equal time and ended up doing a lot better on the multiple-choice while also doing well on the free response questions. Moral of the story: prep for both!

Participate in slack/Piazza. Help your classmates out if they ask for feedback in order to submit a regrade request. You can and will learn a lot from your classmates. Be sure to take advantage of them. That being said, the TAs were overall pretty fair and reasonable on grades and I only had to submit one regrade request.

Final Thoughts Honestly, this class was tough but fair. I felt like the exams were hard and anxiety inducing but they were also fair and relied heavily on modifying problems we have already seen. I think Dr. Brito took pity on us and made the final manageable. I found it to be the easiest of the four exams (maybe because we had 4 free response and no multiple choice). All of this is to say that you can do well even if you get severe test anxiety. Try your best on the three exams but if you end up blanking on one of them, you can always use the final to make up for it. It’s nice not to take the final but it’s also a good fall-back in case you have to. Put in time and learn the material but don’t stress yourself out too too much

TLDR: If you plan to take this class without any background algorithm experience, you better be prepared to put your nose to the grind. This is not a class for the faint of heart. There are people on their 3rd and 4th attempts trying to pass this class.

My Background:

• Embedded programming. Program 95% all day every day at my job. I hardly use the types of algorithms that were covered in this class due to space/time and the hardware the code is implemented on. With that being said, I have come across some of the algorithms that this class covered in my day job. (BFS, DFS, Dijkstra’s). Let me be clear: Being good at programming DOES NOT mean you will succeed in this class.
• I have a BS in Computer Science. My undergrad did not have the strongest algorithms class that I took. However, I would say it was probably an 7/10 in terms of learning the tough algorithms.

The Brutal Part:

Disclaimer: This is solely the opinion I have come to myself. ALSO TO NOTE: None of this applies to the top 1% who barely missed a point on anything the entire semester. There are those people out there. They are extremely helpful on slack/piazza. Just ignore their grades and do your best. Don’t compare yourself.

These exams are administered through Honorlock. You are allowed 5 scratch pieces of paper. Ensure you do the room scan correctly or you will be penalized and receive a 0.

• There were two long answer questions. These were both fair questions, however beware, the deductions for errors on these long questions are extremely severe. You will learn this as you do the homework(s).
• After that there were some Multiple Choice, True/False, and Multiple Select. These were extremely tricky. I will admit that I am not the greatest with the material, but even still, these questions felt like they were to trick you, not simply test your knowledge of the subject.
• Overall Review: I would say this exam was pretty fair. If I had more idea what the exams would have been like, I would have done FAR more studying.
• Total study time for exam 1 was 30 hours.
• There were two long answer questions. The second one was very fair and I should have personally done better to answer it exactly how they wanted. (There was a very similar homework problem). However, problem 1 for Exam 2 caused problems for the majority of the class. It was never fully stated by the professor or TAs, but the overall loss of points on Exam 2 Problem 1 was probably the reason for the final grade adjustment. This question ruined most everyone.
• After that came the Multiple Choice, True/False, and Multiple Select. These were pretty fair. I studied extra hard for these this time around so most of my exam points came from these questions. Again, understand that these are not simple/straightforward questions. You WILL have to think hard and potentially decipher some tricky verbiage.
• Overall Review: I would say this exam was slightly unfair. I studied a metric ton for this exam but was extremely disheartened when I read problem 1.
• Total study time for exam 2 was 23 hours.
• There were two long answer questions. They were both fair questions and mirrored homework questions almost exactly.
• Next came the Linear Programming handwritten section. This section was quite tough. They threw in some simple algebra which really hurt a lot of people (myself included). However, they graded this fairly as they only deducted points of the wrong solution once. If you continued down the path of ‘wrong’, they continued to give credit. Clarity: You still had to do it correctly, but you could do max/min for the standard form part.
• After that came Multiple Choice, True/False, and Multiple Select. These were semi-fair. Most of them were easily attained if you just studied the material. There was 1 or 2 questions that only the super brilliant got (or you just guessed correctly).
• Overall Review: I would say this exam was the most fair of the 3. Studied hard and did very well.
• Total study time for exam 3 was 25 hours.
• This consisted of 8 HW assignments. They give you a week to do them and you are allowed to collaborate with your classmates. It is actually encouraged. Just ensure you cite that at the top of your homework. These are quite fair. They also go over the solutions to the homework in the next weeks office hours.
• Pretty straightforward. There was 8 quizzes this semester. Sometimes less, depends on the semester apparently. It is a single question in which you get two chances. These are EXACTLY like the questions you will see on the exams so make sure you pay attention to these.
• There are three of these. These are dirt simple. Took maybe 5 hours total for all three. They are not meant to be difficult. Pseudocode is given in the book for some and others you have implemented via homework. Don’t stress about these. These will be the easiest part of the class.
• I would have to that hands down the biggest Pro of this course is the new TA Joves. His notes that he releases throughout the semester are godsend. Without these I would be positive in saying that about a large amount of people who passed this semester would have failed if it were not for these. He is very active on slack, and always willing to help. However, you should not DM him on slack. Ask all your questions in main slack and he’ll do his best to guide you to the thought process so you can answer them correctly yourself. Oh.. and his name is pronounced “Jov-es”. ( Don’t mess that up! )
• Rocko holds office hours like clock work each week. He will answer your questions if you ask them in piazza prior. This class is tough, so giving him the chance to prepare to answer your question is very helpful. He then will ensure you understand it before moving on. Great office hours in my opinion.
• The class material is actually really interesting. Take time to understand what is happening and how stuff works and you’ll feel a sense of fulfillment once you complete it.
• The final is a make up (if you need it). If you did poorly on an exam and do not have a B, you can take the final to bring up your overall grade. This semester the final was optional. I cannot speak to previous or future semesters.
• The exams being worth so darn much. Makes it hard when you screw up on one thing on the exam.
• The exams weren’t really testing your knowledge of understanding the algorithms. In my opinion these exams were more written to see if you could understand the convolution given to you by the exam creator. (More on this above under the exam bullets).

Overall: This is a great damn class and I am glad they require it. Only the most determined will pass and it makes this degree worth something. I learned a lot and am proud of myself for getting through. Make sure you have some great group mates or classmates to study with.

Good luck to all future students.

Remember this is just a review written by someone who took the class. This is not the final word on how it all works and everyone sees things different.

Let me start by saying that this class is unnecessarily stressful and difficult. I think there is probably a better way to teach and more importantly assess knowledge on this material.

That said, now that I’ve finished, I completely understand why the course itself is necessary, and these are concepts that any good computer scientist or software engineer should have mastered.

My advice for students

Start early. If you’ve never studied linear algebra or discrete mathematics, take a crash course. You also need to be good with algebra in general, and big O notation. Make sure you also understand basic algorithms like Dijkstra, merge sort, and binary search. This is especially crucial if you weren’t a CS major in undergrad.

Plan your life in a way that you can dedicate the time needed to be successful in this course. For some it may only be 10 hours per week or less. For most, it will be much more. You HAVE to put in the time.

Form a study group early. Try to find people who are in your time zone and aren’t going to flake out. They don’t have to be 160 IQ geniuses, you just have to be willing to work together. This will be most helpful for completing the homework assignments.

Do something for this class every day. Do not wait until the week of the exam to start studying. Put in a smaller number of hours EVERY day.

Do LOTS and LOTS of practice problems, especially Dynamic Programming and NP-Complete Proofs. Make sure you know how to solve ALL of the assigned homework and practice problems from the DPV book, and can do so without looking at the solution. Make sure you actually understand them. The exam questions will be VERY similar.

If you make a poor grade on Exam 1, do not drop the class, and don’t panic. Stick it out. The final can be used to make up for a low exam grade, but most students don’t even need to take it.

Statistically, only about 5-10% who complete this course fail to make an A or a B. If you put in the work and are conscientious, you probably won’t be one of them. If you get lazy, you probably will.

You MUST attend the office hours for this course. They are an extension of the lectures, and often critical info is given during them. During Rocko’s mid week office hours, he does a good job of recapping and explaining the material which is often clearer than in the lectures, and during Dr. Brito’s Sunday office hours, he often gives away hints as to what will be on the exams.

Don’t wait until your final semester to take this course. If you are like many, whether or not you will get the needed B to pass will be in question the entire time, and you don’t want that kind of anxiety when you are trying to finish and graduate. I recommend getting it out of the way sooner.

Advice for faculty/staff

Please consider allowing a one page cheat sheet on exams. Having to memorize black box algorithms and formulas is unnecessary, and only adds to the stress. It would be better to spend that time practicing.

Something really needs to be done about the consistency in grading. I realize that’s difficult in such a large class, but I got a minus 20 on an exam problem for a simple typo on an otherwise correct solution, whereas another student only got minus 5 for a solution that wasn’t even remotely correct. Aside from the re-grade request, which was denied, I had no recourse and felt this was patently unfair.

Please re-consider the format and the weight of the exams. With 2 algorithm design questions times 3 exams, that’s 6 questions which account for over 50% of the entire final course grade. There really needs to be either more questions, or the other components such as the homework and coding assignments need to count for more.

The class felt disorganized at times. There was often conflicting information (such as due dates), and you had to go digging through Piazza comments to find the right answer. It would be nice to have a web page setup that serves as a centralized, official source of info with all the assignments, due dates, etc. Other OMSCS courses, particularly those taught by Dr. Joyner, are really good about this.

My Experience

I did very poorly on the first exam for the above mentioned reason. Thankfully, due to hard work, I was able to make a comeback and got my B without having to take the final…barely. This was only due to the lowered grade threshold (call it a “curve” if you must). I’m glad I decided to stay in the class, but that entire situation just created stress and anxiety I didn’t need in my life.

That said, the quality of the material and the content of the course was excellent. The head TA Rocko did an excellent job and it’s very apparent that he cares about students in the class and wants them to succeed. Another TA named Joves shared his notes from when he was a student, and I have to be honest, I don’t know if I would have passed this class without them. They were crucial. Perhaps something similar should be officially published as a part of the course material.

At the end of the day, my takeaway was that nearly all problems that have to be solved in computer science can in some way be reduced down to these algorithms, and I have no doubt that I will be able to take this new knowledge and skill into my everyday work, which to me made this course invaluable, and I see why it’s a part of the required curriculum.

This was definitely the most difficult course I’ve ever taken, but I’m both proud and happy to be done.

This is my last course in the program, and I feel this is the type of courses OMSCS should provide (shame on 7641 machine learning). It’s solid and useful, and I have to put in some time to get it passed. On the other hand, it’s not that difficult as many mentioned here. I just watched all videos, did homework and practice problems, and prepared for exams by reading the textbook and notes, to get a decent A.

I think my only two complaints are that, this course is so hard to enroll in at the early stage of the OMSCS program, and it should have provided more guidance on coding projects (I think this is essential in job interviews). Happy graduation!

Overall, the worst part about this class is how over-hyped the difficulty is! It makes it impossible to go in objectively. Even the study groups on slack are full of doomsayers and people claiming they know they’ll fail from day one. Cut it out! Jeez guys, it’s just algorithms.

And frankly, although the grading is heavily geared towards the 3 exams, the curve makes it pretty straightforward to pass with a B. This semester, a B was [67% - 82%].

The exams are 75% of your grade but the other 25% is HW (were you’re allowed to look up the answers), Quizzes (8 total, with homeworks, these are also pretty straightforward) and Coding Projects (3, very easy. Often just typing out the psuedocode from the book).

So you get 20% of the 25% of those assignments, pretty easily. Then you just need to get ~62% average on the tests to pass the course. And if you can do better on the homeworks/projects/quizzes (I know you can!) then you really only need about a 60% on the tests to pass. Given the structure, this isn’t guaranteed but it’s doable.

So chin up! Do the homework practice problems. Don’t despair, this course is doable and even enjoyable if you don’t let the constant doomsday prophesying get to you.

I thought it was awesome, stimulating, and incredibly stressful - although the last one was totally unnecessary with the right mindset.

This is my second semester. Before this course, I have some backgrounds in DP, Divide and Conquer, and Graph, but no idea of Maxflow, min-cut, RSA, NP, etc. This course is in fact same as undergraduate algorithm course for on-campus students, so do not be afraid of it. I end up with 99% and below are some of my advices.

• lecture video.

Watch the lecture videos, and focus on the idea of an algorithm, instead of the proof process. Some of the proof can take a long time to understand, but it is not important for exams, so you could just skip them. Take a snapshot of lecture videos, copy them into word, make notes there. convert word to PDF. When review it, review PDF on iPad if you have one, and highlight or make note (using apple pencil) whatever is important. Before exam, you should be able to go through the PDF and only focus on your notes/highlights in a couple of minutes. Very fast.

• note provided by previous TA

Really good note! Try convert to PDF and read on iPad, and make notes there. Review at least 3 times and make sure you can come up with the solution in you mind in a few seconds. Do not worry about details at the beginning. Come up with a solution fast and go to next problem. When you can have a solution easily in your mind, layout solution details.

• Book and practice problems.

For book, read DP/Graph/Path related chapters should be enough. I did not read much about RSA, Maxflow, LP, NP, etc.

For NP, RSA, Maxflow related problems, the problems in the note are enough. But I do recommend doing more problems on DP/Divide and Conquer/Graph in the DPV book.

I came into this course with almost no algorithm experience! Listening to the horror stories about GA I spent the time between semesters to watch the lectures and get as much prep as I could before the semester started. I ended up putting lots of hours for this course but learned a ton and ended up with 96.35/100 which was way more than enough to get an A. My two cents are:

Advantages:

• Great teaching staff delivered a very well organized course that help us navigate through the challenging material.
• Office hours were a great complement to the lectures and teaching staff were very responsive on piazza and slack.
• Grading was fair.
• Course material is very well organized with a great set of lectures and practice/homework problems. Reading the textbook helped solidify our knowledge of the topics.
• Course material is top notch and necessary to become a good software engineer but also prepare for interviews.

Disadvantages:

• I felt sometimes there was ambiguity on what we needed to study to succeed in the exams. In Exam 3 professor selected a set of problems from the book that helped us concentrate on specific problems for the exam. This was extremely helpful.
• The way the course is graded (75% of the grade comes from the 3 exams which are closed book) it relies heavily on exams which creates a lot of stress.
• I wish there would be more coding assignments.

General comments:

• Prepare prior to starting the course as much as you can (at minimum watch the lectures for the first exam). This was golden for me as it is a really fast paced course and you jump from one topic to another in a single week.
• Practice, practice, practice the problems and focus on those given by the professor.

Here are my main takeaways:

• Do all the practice problems assigned. This is the most valuable thing for preparing for the exams. You’ll notice patterns in many of the problems. Dr. Brito even says he gets his inspiration for the exam problems from the book.
• Do not ignore the format of how the TA’s expect you to answer the long free-form questions.
• Don’t give up after Exam 1. I did poorly (mainly because I ignored my own advice in bullet 2) and it was stressful having a poor exam grade hang over my head the entire semester, but in the end did well enough where I could skip the final.
• Do not gloss over the quizzes and homeworks. This is especially important if you do poorly on an exam. My Exam average (before exam 3) was a C, but my average for quizzes/coding projects/homeworks was ~97% so I still had a B overall going into the third exam.

I rated this as “Medium” because I think the material is very straightforward but there is a lot of it and it requires practice to know how to implement the algorithms on the spot in an exam setting. I think this is one of those classes where you see a direct relationship between how much you spend on the material and your overall grade. I loved this class almost as much as I love being done with the degree.

I took this class in Spring 2021 as my fourth class, along with SDP. My background is a BS in Physics and 5 years of experience in tech. Finished with a high A and won’t have to take the final cumulative exam. I had studied the topics in the past.

This class has a lot of pros and cons, and I would like to leave a few tips for future students as I found previous reviews misleading, specifically regarding how to study for the exams.

• Algorithms is an interesting subject, and the class is not proof-based focused on computability. Therefore, since most of tech companies interview based on algorithmic questions, a small subset of this class also helps you prepare for interviews (DP, Graph algorithms, and Divide and Conquer)
• The staff behind this course is very professional. Grading is very fast, despite the difficulty in grading the free-form homework and exam questions, and I believe it’s fair. I never had to dispute a deduction.
• Homework is very good to understand the content.
• If you don’t have any background in CS, this class is a must take. Even if you’re doing the II specialization, try to get into this class somehow.
• Exams are high-stakes but grading is generous. There is more leniency in exams 2 and 3 compared to exam 1 in the form of lower deductions for mistakes.
• Two office hours per week: one by the head TA and another by the professor. I didn’t watch so I can’t comment on the quality.
• The course has to cover a lot of ground (entire DPV book), but it chooses to specialize in a few cases in from each chapter. This is a design decision, perhaps to prioritize the most crucial content, but in my opinion a lot of interesting stuff was left out. For example, in the second part of the course, when discussing strongly connected components, there are many applications that combines dynamic programming techniques with SCCs/DAGs. However, none of it was explored neither in HWs or Exams. Another example: In the final third of the course, classic problems like the Traveling Salesman Problem or 3D-matching were forgotten. The extremely relevant Simplex algorithm was glossed over.
• The HWs and exams share the same themes, which is why I pointed out the above. I believe the content that is covered and graded in the HWs shouldn’t appear again in the same form in the exam. However, that’s exactly what happened, and therefore there wasn’t space to cover other interesting applications of the algorithms in the book. I believe is part of the teaching philosophy of the Professor that the content in the homework is what the student is expected to study, and therefore it’s what should be in the exam. However, that only rewards students who repeatedly solve the same questions over and over again, and not those who seek knowledge and applications outside of the given problem set, even if in the textbook. For the first exam, I had solved a lot of interesting questions in preparation for the exam, but was disappointed because the questions were rehashed ones from the HWs. The same happened in exam 2. I can provide an example of what I think would be more interesting: In the max-flow type of problems, there are interesting applications like edge/vertex-disjoint paths that a well-prepared student should be able to solve even if this problem wasn’t in the HWs nor lectures. However, the professor chooses to rehash questions from the HWs and rewards memorization instead of ability to generalize. It’s his class and his call to apply his teaching philosophy, but I respectfully disagree and I don’t think it’s the best way to test understanding of the material.
• There was a 3-point curve this semester (before the final exam) that I don’t think was necessary.

If you’re taking GA and want to do well, read my paragraphs above. Unfortunately, to maximize your chances to get a good grade you only have to exhaustively repeat the HW questions because the exams will have questions with the exact same theme (same concept applied the exact same way). I saw previous reviews suggesting to solve a bunch of DPV questions, but they’re not useful for the reasons I mentioned before. Each DPV chapter has dozens of problems, and only a handful (those already in the HWs) will be the ones covered in the exams.

Overall, this class was good and I’m glad I had the opportunity to take it earlier.

Also, don’t feed the trolls here. Each time they edit their posts, their grades comically improve by a letter. Remember that if they were so smart they wouldn’t be belittling students in a review board, but solving Millennium Prize Problems or doing something worthwhile instead.

Its very hard to summarize this course. The content was very interesting and extremely useful for anyone who wants to succeed in Computer Science.

However, the grading format may as well be designed to cause as much stress as possible with each exam (only about 10 questions long each) being worth 25%. Make sure you do well on the homeworks and coding projects (find your own solution, then verify it), because you’ll need that extra boost if you flub an exam.

My advice to succeed in this class is to go to every office hour, because Rocko teaches the concepts way better than the videos. Also do every single practice problem, not once, but until you truly understand the concept, because alot of the exam questions are based on them.

Good luck to all students who take this in the future, and remember that you can recover from a poor Exam 1 grade (I did)

Just took Exam 3 and I’m fairly confident I’ll get an A. Edit: did get a comfortable A.

This is a medium class for me, because I was already familiar with over half of the materials. I’m rating it as Hard for someone who may not have as much prior experience.

I had a lot of trouble staying awake for the lectures, not because of the material, but because the way Vigoda speaks just puts you to sleep. Besides lectures, I spend a few hours per week working on the HW and Quiz. Exam week is where I have to play catch-up, needing about 15-20h for reviewing materials, doing the practice tests I neglected. In terms of difficulty I rate Exam 3 < Exam 1 < Exam 2.

If you come from a non-CS background, this class will help you think like a programmer. I liked it but I’d never take it again. Shout out to Joves, whose notes have been indispensable for the exams.

Definitely a course that would be great to take at the beginning of the program, but hey, what can you do? All in all, timeless content that anyone who’s more than a “copy from SO” programmer should know. Success in each third of the class boils down to figuring out a few ‘tricks’ to solve the problems and knowing to use which when. Not hard at all if you pay attention to lectures and do a few extra practice problems each week.

This is my last class in the program. I come from a non-CS background and learned about algorithm here and there on the internet. I find the homework problems challenging. However, you could always find solution to a similar problem on the internet and it is allowed as long as you answer the question in your own words and cite the website. The goal of the homework problems is to learn the material. Bottom line is that the homework does not worth much in the total grade, so even if you mess up here and there, it does not really matter all that much. Go to office hours to see the solution and really understand the questions is important. Quiz are easy and open book. There is no time limit on the quiz and you get two tries. Coding assignments are very easy. I spent a lot of time on exam weeks to review the lectures, practice additional problems from the text book and got good grades. But I’ll admit that if I hadn’t had the time to study for it, I could easily fail. I spent less than 10 hours on a regular week and 25+ hours on exam week. Overall I feel that I learned a lot from this class. Update: Just finished the 3rd exam. I am pretty confident of getting an A. Again, review lecture videos and do practice problems from DPV. You’ll be fine for the exams.

To the reviewer below, lovely review taking shots at your fellow classmates. Might I recommend having some compassion? What this individual may not understand is that for pretty much everyone in this class, they are in it because it is a requirement. Also, not everyone has taken an algorithms course previously, or has experience with these concepts.

As for me, I haven’t taken an algorithms course previously, and I am a horrible test taker. This is a bad combination for the course as 75% of the grade comes from the tests. If you bomb one, you can make it up by taking the optional final exam, but that final exam is cumulative, so who knows how that’ll go.

The lectures can be difficult to follow at times, but there is an abundance of material that can help (loads of stuff on YouTube, some extra material provided, etc). For those that struggle with the content, try to make time to work through the practice problems provided each week, this will prepare you pretty well for the tests.

While there is quite a bit of pressure to perform well on the tests, and that pressure only increases because you need a B to graduate (for most), the course is structured to help. As mentioned previously, the final exam is optional and it will replace your lowest test score. Also, you just need a 70% to pass (again though, bomb one test and you drop below this easily).

Tip, take your time with the weekly quizzes. I didn’t on one and now realize that is 1% of my grade which would help.

Well where do I begin, I am still in awe of this course even after one year. This course is a difficult one and you might ask what is the point of learning all the advanced algorithms if you are not going to use them in day-to-day work, but that is until you reach to the end of the course where you begin to appreciate the course’s primary goals. The main goal for this course as I understand is not entirely about teaching the most difficult or the most important algorithms, but I guess it is to teach generally the theory of computation. The same could have also been taught using more formal approaches like the earlier course 6505, but we all know what happened after the same.

The course does have its pain points and the main one being the exams and the format of the exams, but once after you have suffered through the pain, the relief one gets is also very high. Hence for me at least the pain was worth the trouble. The whole experience makes you feel better afterwards, even though I am not sure if the pain was necessary or not.

Note: The reviewer above me is not talking about my review but for another review which was later deleted.

Love that the reviewer below took the time to insult the intelligence of other reviewers. Sounds like an instructor trying to defend bad course design or a pretentious student. My experience aligns more with the negative reviews. The class isn’t taught in a practical way as it’s very concept-heavy and not so implementation focused. The average exam grade is between a low B and high C. You can make up the rest through other deliverables, but they’re only worth one exam altogether. It can be particularly annoying for someone on their 10th course trying to graduate or for people who have not taken algorithms previously. Otherwise, some of the topics covered are useful like DP and Graphs. Time-wise the course hasn’t taken more than 10 hours a week and I have a low A.

EDIT - to the reviewer below, did i offend you by calling you out for being pretentious? maybe condescending was the better word. sorry that you have a fragile ego but your words do come across as condescending and now your edit just makes you sound unreasonable. your review doesn’t add any value aside from putting other people down. don’t fire shots at other reviewers if you don’t want to get called out. don’t try to gatekeep and say “oh well then these struggling students must be lazy and should leave the program”. we all come from different backgrounds and we’re in OMSCS for different reasons. that’s the beauty of the program. it makes CS accessible for just about anyone. a lot of students in the program don’t come in with strong math / CS backgrounds. the course design is especially bad for these students. it’s the last class for most students and the stakes are high. sure you end up passing, but the reviewer that called the course “unnecessarily stressful” is spot on. there are simple tweaks that can be made to the course to make it less stressful without sacrificing any rigor. i’m saying all of this with a decent grade in the class. learn some empathy my friend.

EDIT 2 - to the reviewer from 4/6, a 98 ain’t any different from an 85. you and i are going to get the same grade but i probably spent less time :)

If you’ve reviewed this course and include judgement like “the majority of the class are failing each and every exam”, maybe your understanding of math is the problem, and not the class. If your complaint is “there’s no prerequisite course” and it’s required, then maybe you’re in the wrong program. Yes, the class is hard, but it’s doable with work. If you’re not able to do that work, then change your specialty to one that doesn’t require it, or try another program.

edit: Love that the reviewer above thinks it’s ok to insult someone himself but is not ok with others doing that. BTW - I didn’t insult their intelligence, but their understanding of math, and willingness to do work. While insulting me for being pretentious, you have defended my point - the majority of people pass the class. If the design of the class is so bad, why did around 85% of students have an A or B last semester, literally 0% failed, and 10% withdrew?

edit 2: I am absolutely pretentious and condescending. I wasn’t hurt by you calling it out. I was calling you out for being a hypocrite for doing exactly what you’re critical of. Which you continued to do in your edit. And then you sound really pretentious yourself saying “i got an A and did less work” than some other reviewer. Good for you, simultaneously being the lone defender of the weak and failing 2% of the class while telling everyone how great you are for getting an A in just a few hours of work.

This course is going to be easy, if you had some exposure to hard math or CS problems solving in the past (example: A => B is the same as !B => !A). Otherwise, it could be very tricky and you will have to spend much time gaining the necessary background.

Pros. 1) You will learn to justify your opinion and will start seeing flaws in arguments of others. 2) You will learn to trace algorithms in your head, which a useful skill for anyone dealing with code. 3) You will learn standard techniques for many classical problems you will definitely see again later in your career.

Cons. 1) Few coding assignments. Not really hands on. 2) TAs miss alternative solutions quite often. Get feedback from other students and get ready to prove your point. 3) Sometimes it’s not clear how optimal your solution is. It seems alright, but there could always be a faster one and you never know when to stop digging. But such is nature of Algorithms in general, not just for this course. 4) Presentation of Graph Algorithms is not very clear about which graph representation is used. It could become a hurdle in HW and Exam problems, as sometimes you want to use an Adjacency List (actually default) and sometimes an Adjacency Matrix.

Tips. 1) If you lack the background mentioned above, do as much as you can of the following in no particular order: take MOOCS on Algorithms, preferably ones that require you to write and justify solutions; read Algo books, e.g. DPV. Solve Algo problems from leetcode and such. 2) Read the book properly. Videos are only the beginning. Clarify every single doubt for yourself. Find a reason why they have presented solution in this particular quirky way. 3) Unit test your Coding Assignments a lot. E.g. you can lose 6/10 marks for missing out “=” in “>=” sign (I did). Test cases from Piazza help a lot.

Actually, I think my original review was a bit heated, so I removed it to try to be fairer. Plus, I see two new reviews here. Also a disclaimer, I withdrew from this course and will take it again in the summer for what it’s worth, so I only made it past exam 1. But that doesn’t nullify what I experienced before withdraw.

First, I am a state certified public high school teacher for over 10 years. So, I would like to think that I have a little credibility seeing as my degree is in education. My main problems with this course are its design and how the exams are weighted. The other problem is there’s no prerequisite course that leads up to this class which means making it required and unnecessarily hard is not very fair to students looking to graduate.

The video lectures are poor quality. He (the previous professor) will tell you the mechanics of the algorithms, but rarely show you “how” or “when” they are used. There are many convoluted explanations that just don’t make any sense. Without concrete examples, you aren’t really going to “get it” at all. Also, the videos are recycled from the old course and from a different professor. If students are to take this course seriously and work many hours, then why hasn’t the course overall been treated in a serious manner with an update? It’s insane they expect students work even harder to put together a course using a “resource dump” rather than updating the course itself. The course design has major flaws. For example, we don’t need xyz, but they are in the video lectures. We need to know xyz algorithm, but that’s not in the video lectures. But no worries, here are 10 different resources you can find it at.

That said, there are too many resources and the class is way too fast-paced. With the video lectures, office hours, DPV practice problems, quizzes, coding projects, and other “suggested material” due almost weekly, you will never have time to get through everything. By the time you think you understand a concept, you are already on to the next thing leaving you not much time to do the suggested “practice problems” that are supposed to help you with the exam. Then there’s a slack group, piazza group, outside notes, outside suggested books, and on and on. Information is too much, not centralized, and not focused at all. You spend 80% of your time in this course working on something that’s worth 25% of your total grade.

And ok so the exams are worth 25% each? That’s alright I guess. However, they are weighted very poorly. If you mess up on one of the response questions for the exam, then you fail it. And there aren’t many questions on the exams overall. Meaning the ton of material you just studied, well most of it isn’t covered. Coming from a background in education, I would never set my students up for failure like this. I am not complaining because the exams are too hard, but that they are too weighted and designed poorly. This isn’t the kind of exam someone with a background in education would design -ever. What kind of exam do you miss one question and fail? None that I’ve ever seen in my entire career. I will tell you now I only ever got past exam 1, but I read the reviews here and the rest are the same structure and similar means. So take my word for what’s it’s worth. Judging by the numbers, the majority of the class are failing each and every exam. That’s not poor exam design?

The TAs are very responsive and good in general. There are office hours. But you are not going to have a lot of time to spend on them. Overall, they just need give the course an update so that it’s more focused. TAs want students to work hard, the students want a fair shot at passing the course if they are working hard. The course doesn’t have to be made easier, but the exams should be designed to be passable at least by over half the class and cover the material from the video lectures more closely. This was not the case for me when I took this course and I doubt it will get fixed. The TAs work hard, they really do. But that doesn’t fix the underlying structure of the course design.

I have seen teachers that after a course is designed, they never want to let it go even if it is outdated. Because they get into a rhythm with it. But what they don’t know is they are actually creating more work for themselves. Because a course that is poorly designed means students have more issues with grades and grasping the material. Taking time to update a course actually reduces headaches, improves morale and motivates students to learn.

Response to above review:

That doesn’t go without saying that NEARLY ALL students that both passed and did not pass complained about the exam for this course in Slack. According to the reviewer below exam 2 was 41.5/60 = 0.69% average which looks like failing. And exam 1 was 44.6/60 = 0.74% barely passing. Fall exam 1 was 34/60 = 0.56%.

I am guessing at this point that these are TAs responding which means that anyone reading those reviews should take them with a grain of salt. One below this practically is trolling students calling them idiots. It’s a complete joke that people come here to tell others they don’t belong in the program and see no issue with the exams. You are either extremely ignorant about this situation, or you have some vested interest to defend the course. I’m guess it’s the latter.

And many many students in this review site complain about the weight of the exams. Look below at the plethora of comments about the exams, I hope you are not blind. If many students are complaining about the exams semester after semester, then perhaps it’s an issue with the exams -not the students. Many students that have problems with this course have high GPAs at gatech. They absolutely do deserve to be here by admission standards. It’s asinine to say otherwise. It’s wrong to say “maybe you’re in the wrong program” because everyone was accepted to this program fairly. And many take this course as their last course, so obviously they have been successful at gatech.

I’m in the course right now and it could be better. It will involve looking at a lot of outside resources if you have not seen the content before. The course lacks focus and the exams suck as other reviews have mentioned. Class averages for exams 1 and 2 were 44.6/60 and 41.5/60 respectively. Exam 1 was easier this semester than previous semesters. The two problems on exam 1 were easier or on par with the HW problems. Exam 2 felt harder. HW alone is not enough to prepare you for the exams. Doing all the problems in DPV might be worth it. The problem is that these if these exam questions don’t click in an exam setting, you’re SOL.

I’d be entirely lost if I hadn’t already taken an undergrad algos course. The lectures are awful and being part of graduate-level curriculum should not excuse poor lecture quality. Vigoda is a poor speaker and the lectures don’t give meaningful background on the topics covered - they’re mostly him writing out the solutions to a bunch of problems in very dense and unintuitive ways. He often jumps from point A to point Z without explaining the in-between. None of the lectures go through definitions. Basics like what is time complexity, what is the master theorem, what is a recurrence relation, or how does Dijkstra’s work aren’t explained at all, so good luck if you haven’t seen the material before. Pretty lazy if you ask me. Why call it an INTRO course if you’re going to assume we know everything already? These topics aren’t properly explained but the exams and hws require them of course. The reviews that are praising the lectures and textbook must all be math majors. Watching Tushar Roy would be a better use of your time because his videos are way more intelligible. I’d skip the lecture videos (except for the quizzes which you’ll want to study for the exams) and just use hws, office hours and piazza to learn the material. Make sure to watch Rocko’s office hours. Oh yea, It was unclear to me who the professor of the class was - thought it was Rocko until after the 2nd midterm but apparently it’s Brito, who is largely absent from Piazza / Slack. This class is very much run by TAs. Kinda unfair if you think about it from a compensation perspective.

There are topics that aren’t really useful to cover, and it felt like they were thrown in just to make it seem like a graduate level course (i.e. FFT, RSA). Prepare to rip your hair out trying to grasp FFT only to forget it entirely the moment exam 1 ends (here’s a secret - you can probably skip FFT entirely and get by grade-wise on exam 1 because that’s certainly what I did). Biggest waste of time ever because you know you’ll never see that crap again.

The course is structured to make it unnecessarily stressful - 75% from 3 exams, 10% homeworks, 9% coding projects, and 6% from quizzes. The 25% per exam is fine, but these exams are weighted in a way to make you fail. Each exam is 2 problems worth 33% each (66% total) and 33% from multiple choice / select / TF. Blank on 1 question on any exam and there goes literally 8% of your course grade. Pretty common occurrence. They pretend like they’re fair and offer an optional final exam to replace your lowest grade, but rumor is that the final is tough as balls, so I’m guessing anyone who goes into the final with a C or below probably won’t improve their grade anyway.

The coding projects are trivial - not sure why the coding projects are so basic (e.g. code knapsack using this awful template code designed so you can’t just grab a solution from leetcode) - my undergrad algos class had tougher and more meaningful projects. The two I’ve done so far took about 30 minutes each.

The grading on the homeworks is ridiculous - be prepared to lose a huge chunk of your grade on a question because you accidentally labelled something an integer instead of a number in your problem definition.

Also, if you’re thinking you’ll be doing a lot of coding and implementation because this is an algos course, think again. Aside from writing pseudocode for DP problems, every other topic basically asks you to explain solutions in paragraph form.

Overall, it’s feels like a low quality course that’s hard for the sake of being hard, not for the sake of learning. I can’t think of anything positive about it aside from the fact that it forces you to do problems and that a 70 gets you a B. Also the TA team is pretty good (thank god for Joves’ notes). If you’re in Interactive Intelligence, avoid this class. Your time will be better spent on free online algo MOOCs plus leetcode. For every other specialization, suck it up I guess (or switch to II?). Hoping to get out of this disaster of a class with a B.

This was my first formal introduction to algorithms, and I have to say that it has definitely affected the way I approach the problems I encounter in my job. Even though it didn’t feel like it at times, it seems the material really stuck for me. I got a 45% on exam 1, yet in the 6 or so weeks since the class ended I’ve managed to deploy a recursion and a divide and conquer implementation in the projects I work on. So I guess it worked?

I haven’t got anything useful to suggest as a replacement, but I’d hope to see this class place less emphasis on seemingly all-or-nothing exams in the future. The first was difficult for me, but I agree with others here that the second and third exams were a bit easier. I was fortunate enough to not have to take the final and get a B.

This class definitely lived up to the hype, it was challenging, interesting, gave me a stress rash, and I loved every minute of it. The class was well run with great TA’s, a responsive professor, difficult, but fair, assessments and great classmates.

Exams are the key to this course, In my case i came to this class without much preparation and had another class in parallel with some critical office deliverables but some how managed to clear this class. TA’s are very quick in responding and i would mainly thank the fellow students, the notes were very useful. Some of the mistakes i did which you can avoid is :

If possible, Prepare well for this course. Because it is a roller coaster ride and we have lot of topics to cover

Take every exam / problem seriously because it is easy to lose a problem - Exam has the maximum weight

Don’t lose hope, even if we miss one of the exams we still have a final exam but it is cumulative we may need to prepare all the topics, In our case final exam was a little bit tough than the previous exams with more questions

All the best

This was my final course and it was one of the more difficult courses in the OMSCS program. I barely managed an A and there was no curve for Fall 2020.

Exams are heavily weighted at 75% comprised of 3 exams and 1 optional final that replaces the lowest exam score. This semester, the mean/median scores were as follows: exam 1 (34/37 out of 60), exam 2 (47/50 out of 60), exam3 (49/52 out of 60), and final (66.5 mean out of 100). Exams comprise of 2 written questions and a set of MCQs. The only way to do well on the written portion is to do practice problems. There really isn’t a way around it. MCQs can be confusing so make sure to understand the lectures. I felt that homework (10%), polls (5%), and coding quizzes (10%) were all relatively fair.

This was easily one of the top courses I’ve taken in the program, and going into it it’s not even a topic I’m super interested in. I think what really made the course successful is extremely involved TAs and students.

It’s tough to give a difficulty rating. I’ve heard the course is tough so I really worked hard and spent a lot of time practicing the problems. I ended with a 97%, but on the other hand I feel like if I put in medium effort I could’ve been scraping by hoping to at best get a B. Since it’s largely test based with a few problems, if you’re unable to solve a test problem or two it could be a stressful course. But it has the advantage of containing almost exclusively senior students who are great at helping each other out, and once again the TAs are excellent.

This was one of the best courses in the program. It is definitely challenging, and takes a lot of practice and thinking to absorb and understand the material. The homework assignments were very helpful and the TAs and forums are great for getting feedback on the problems and understanding them.

I had spent the previous two summers watching the lectures and going through the problems, so it’s almost like I’m taking the course for the 3rd time in Fall 2020. There is nothing like the deadlines and pressure of exams to help you focus though.

The option to take a final to replace the lowest exam is great. I ended up not having to take it even though I did poorly on the first exam. One thing to remember is to persevere through the course and keep doing the problems and you will get it.

It is a hard class, but not as hard as many said. I put 8 hours or less on average a week, and ended up with an A (90%+ on homework/exams and 100% on coding quizzes/polls). I am not trying to sound smart. I was very struggling for AI and ML. I took 15+ hours a week for each of them, and ended up with solid Bs.

All I want to say is that don’t be scared about GA. There were other classes harder and more time consuming than GA. Study hard, and you will be just fine.

I usually spent 1 - 2 hours on each week’s lecture videos (I played them at 1.5x to 2x), and another hour on reading the textbook. Some homework assignments were really hard, usually I spent like 1-3 hours for each depending on how hard it was. There were 3 coding quizzes, which were fairly easy. I just followed the textbook or lecture to implement the algorithms. I spent no more than 1 hour for each. Polls were easy as well. It took only a few minutes. If you understand the material well, you can get to the right answers quickly. Studying for exams were stressful. I put 3-5 hours during exam weeks. During exam week, there was no assignment. There were 3 exams, and I skipped the optional final, which is used to replace your lowest exam grade.

I took this without any previous preparation and I found this extremely hard. If this is your first introduction to algorithms, do not go in like me.

Fall 2020: Exams - 75% Poll - 5% HW - 10% Coding Quiz - 10%

The exam model makes it even harder. You have 2 long answers worth 40p in total and 20p worth of MCQ. Mess up one of the questions in the first part and you are down a grade. MCQs aren’t a walk in the park either. There is an optional final but for that you’ll be studying the entire syllabus again with more questions and more MCQ. If it comes to a point where you can pass GA on either Exam 3 or final, put all your effort in Exam 3. don’t be lazy.

Whoever said “it gets easier after Exam 1” needs to clarify what they meant by that because it only got harder after Exam 1 in Fall.

For DP -> You can do a certain set of problems and get one of them easily. There’s at least a boundary to this category until you hit repetition of patterns.

For Graphs -> Good luck with the million combination of questions. To add fuel to fire, we had some number theory lessons with this one. #TeamFKGraphs

NP/P & Linear Programming -> Lots of possibilities for tricky MCQs. Do NP-C reductions for everything covered in lectures at least. Do all the book problems. This exam is not in any way easy. If you are given a completely unknown problem you haven’t seen before, it’ll be insanely hard to reduce in an exam setting.

General tips for people who have not seen algorithms before except when someone compared them to a cooking recipe:

1) Do DPV chapter-6 problems and get a head start for Exam 1. 2) Do the entire DPV problem set and get a head start for the entire course. (if you hate yourself) 3) If you want a assured B, do all the practice problems, homework problems and wikidot problems without looking at the answers first. 4) Some luck. 5) Don’t give up after Exam 1. 6) Join a study group and teach the problems. 7) Watch the OH and respect the TAs. TA’s are human too. They make mistakes. Don’t jump the messenger like a.. 8) Don’t boast about how you registered for GA in your first semester and quit the entire OMSCS program after Exam 1. Yes, this happened to one person. 9) There will be less handholding in this class. So, it won’t be like ML4T. 10) If you had an option to choose between having maximum homework or less homework - pick maximum homework. Exams will have variations of homework, book or lecture problems.

The other realm:

If you have been leetcoding, you’ll find E1 and E2 - somewhat easy. Make sure you stick to the exam format and rules. We know you like top-down dp approach and like to code but guess what? Dr. Vigoda can’t pronounce memoization. The only area you would put some effort is to study for Exam 3.

If you took a UG-Algo class recently or years ago, don’t worry about GA.

• Great TAs - very hard working. Basically the team completed grading for E2 before drop deadline for 550+ people in less than a week for the sake of students.
• Rocko (Gold) & Chris (Gold) & Cailin Pitt’s motivational message on Slack - Without these three I would have quit half-way.
• Joves’ study guides - You might get negative marks if you pronounce his name wrong next semester, so watch out.
• I like the guy who writes the announcements too. Forgot his name.
• Very well-structured class.
• Free Dr. Vigoda ASMR lectures.
• Coding quiz and polls are good grade boosters
• Can compose a book from Nishant’s piazza posts and sell on Amazon.
• Rocko’s motivational videos at the start of exams.

Not so positives:

• Not a fan of exam format. One small tumble and you are down a grade.
• The know-it-alls who don’t own up to their mistakes, I-want-CCA-ers and hey-I-got-100-on-this give-me-attention crowd. There was this one annoying guy who took this course along with Deep Learning who wouldn’t keep his mouth shut. They would do all the assignments so close to the deadline and shit on the TA’s or the program whenever he got the chance. If you see a guy who says GA is a cakewalk or this course is too easy - that’s the smart ass I’m talking about
• This course would have been a great on-campus course. You’ll understand why at the end of GA.
• Dr. Vigoda saying something is a toy problem.
• You’ll hear everything in Vigoda’s voice & talk like him after exams. Replied to my mom, “let me prove why this claim is true” and she was confused as f, because all she said was that we needed more rice next month.
• Someone questioned why a past student made notes. lol?
• Mistaking someone with a similar name to Ada from GIOS.
• I think GA is a well run course with awesome TAs and I’m glad I was part of this particular group.6515 team should be proud of their work.
• Make it a rule to not let students post OH bluejeans in public (slack) next semester or make it so it’s authenticated to our GA student group only for obvious reasons.
• Please make sure not to show anonymous posts with TA view by accident.
• Share some meditation videos and how you deal with anger management by TA-ing this class.

so uhm yeah. good luck and “ “just have fun with it” - Rocko “ - Michael Scott.

Note: This fall 2020 batch was an incredibly smart batch. The mean was over 80% and there was no curve this semester at all . So do not depend on the curve blindly.

I have just passed this course - as I will not be sitting the final (optional) exam. This is my 9th course in the program.

Overall I was quite anxious about taking this - as it had been many years since my undergrad course. The first module on DP certainly didn’t help - but once I got back into the swing of things, it became easier to see the light at the end of the tunnel.

The material for this course is top notch, the videos are excellent and the TA’s, office hours and support on Piazza is probably the best I’ve seen so far.

This course has a significant workload, both in staying on top of the lectures, and in the weekly homework (I’ll leave a breakdown below of how it ran for Fall2020). A couple of times I wasn’t able to stick to my schedule and needed to work through the weekend to get things done.

The course does have a lot of work, however all of the coding, polls, and homework only account for 25% of the grade - then three exams account for the remaining 75% (there is the option of taking a 4th exam that will replace your lowest score). Exams 1-3 are only for the modules leading up to it, exam 4 covers all of the semester. Exam 4 is only open to those that have strictly less than an A, though you need to do the math as it’s easy to make your grade worse by taking it.

Office hours and the unofficial guides online [1, 2] are excellent to help prep for the exams and to reinforce each of the modules.

In terms of difficulty:

• Homework was average difficulty, and focused on the module for that week.
• Coding quizzes were trivial (e.g. implement this algorithm in python, using this skeleton provided). These did a smoke test with gradescope, but you could not see the full test suite.
• Polls… these were mostly ok, but seemed to be designed to trick - you get two attempts at them, but you can open them and leave them open for as long as you like (there is no time limit).
• Exams: All of exams 1-3 were of the format: two long form written questions, worth 20 points each, and 8 MC questions worth 20 points - so total out of 60. For exam 1 and 3 we were told what each question would focus on, we didn’t get this for exam 2. I found exam 2 to be the easiest (only 1 MC incorrect), and exam 3 to be the hardest (all MC correct but groking NP reductions….).

Here’s how things broke down in terms of deliverables:

• Week 1: Homework 1
• Week 2: Homework 2, Poll 1, Coding 1
• Week 3: Homework 3, Poll 2
• Week 4: Homework 4, Poll 3
• Week 5: Exam 1 (covering DP, Divide + Conquer)
• Week 6: Homework 5, Poll 4, Coding 2
• Week 7: Homework 6, Poll 5
• Week 8: Poll 6, Coding 3
• Week 9: Exam 2 (covering Graphs, Max Flow)
• Week 10: Homework 7, Poll 7
• Week 11: Nothing! There was some election or something in the US.
• Week 12: Homework 8, Poll 8
• Week 13: Exam 3 (covering NP completeness and Linear Programming)
• Week 14: Optional recap.

Overall my grade was 82.36%, which is a B (unless the cutoffs get shifted).

[1] https://teapowered.dev/assets/ga-notes.pdf

[2] https://gt-algorithms.com/

TL;DR Great course, not as scary as the stories go,definitely possible to score at least B on 1st try.

I was really nervous starting GA, and this was my last course in OMSCS. Took it alone for this semester. I would suggest doing so. I took summer off and started prep for GA then.

Coming from a non-CS background and hearing horror stories about GA and finding out that the breakdown this semester was reverted to 75% exams made me nervous.

I spent the summer starting from basics of time complexity analysis etc, I saw all videos on YouTube by Abdul Bari and then watched all videos from Standford’s Tim Roughgarden. Then watched Udacity CS6515 videos as well. Wanted to read/solve DPV, but did not find time to do that in summer.

There were 8 hws, 8 polls(basically 1 MCQ per poll) and 3 coding quizzes (pretty easy). Hw were 10%, polls 5%, coding quizzes 10% and exams (3) 75 %. An option final to replace worst score can be taken if needed.

The homework and practice problems were similar to what we saw in the exams. The exams were 60 points with 2 long questions for 20 points each and MCQ/short answer questions being 20 points broken into 8 parts.

The lectures are great, the textbook is slim and concise. Doing the exercises at the back of assigned chapters and homework is all you need to get B or better and the mantra is “Practice, practice, practice”. The OH are great, very well managed and great source for understanding stuff anything you missed.

Try solving DPV problems on your own, but do not hesitate to look up answers online if you are struggling/stuck and remember to look up similar problems online for practice, especially for NP complete section of the course. Also put in effort to understand the ‘trick’ behind the solution. Study smart not hard!

The exams and grading was fair. Exam 1 MCQs a bit tricky. At least 1 questions out of the 2 long ones was very similar to hw problem.

We moved to Honorlock this semester, and that was a problem on its own as well for exams. But then from exam 2 we moved to Canvas for exam delivery and it went smoothly after that. Also the strict requirement for external Webcam no longer holds because of that.

For exam 1 the nerves of test taking took a toll on my score, but exam 2 and 3 got me back in the game. I went from thinking about dropping at one point and managing a B to now after exam 3 getting an A(the score aren’t out yet, but from Piazza discussion I know what score to expect, and my exam went very well).

A big thanks to my colleagues this semester for creating and sharing study docs and engaging in Piazza discussions. This was I think my first course were discussing any question from Book or homework, exam or otherwise was not frowned upon rather encouraged (on Piazza) Thanks to the TA team as well was being so great!

So here I am ending by OMSCS journey on a high note concuring the GA beast with an A the first try!!

I got OUT!!!

This class was tough. I enjoyed learning the material, and the exams mostly reflected the homework and material. There was a lot of good discussions, and crowdsourcing going on.

This class is non-stop full of work. I took this class by itself, and will say that it is just as hard as taking one hard class + one easy class in a semester. There is homework due every week (mostly), and the second third of the class is tough because you might end up being a week being from studying for the first exam.

Make sure you are mentally prepared for this class.

If you are planning to switch job this course would be ideal to align the skills needed for interviewing. I did this course in my Undergrad and this was a good refresher. Lectures are super helpful in getting crisp understanding of the concepts. But every week you will have lot of deliverables which makes difficult to plan outings or family time during weekends. I think this course should not be taken along with other course.

This is my last course in the program, possibly my favorite. Very well run. Difficult material, but they set you up for success.

The material is fascinating if you’re a Computer Science nerd like me… I went down so many rabbit holes, but had fun doing it.

Excellent instruction team. Textbook is great, slim and to the point. Lectures are the same. Weekly Office Hours to help you with key points and walk through solutions to problems.

If you have taken undergraduate algorithm course. This course isn’t that different. Since I was already familiar with the material, I found the course to be okay.

I was really nervous for this class because of everything I had heard and because I don’t have a CS background, but I enjoyed it and didn’t find it all that challenging. I’m genuinely confused about the complaints regarding unfair grading. The professor basically gives a template for how to answer each type of problem and a lot of the exam questions seemed to be a modified version of a provided practice problem. My advice to students is do all the practice homework problems, watch the office hours, and invest in an external webcam. (Shelling out $50 for a webcam is annoying, but it does make the exam proctoring less stressful)

I spent the 7 prior semesters hearing horror stories about GA and I don’t have an undergraduate CS degree (and thus have never taken an algorithms course), so I went in expecting a very painful semester. I was pleasantly surprised to find the material challenging yet approachable, and the workload very manageable. The lectures are well-done and explain things very clearly, yet aren’t overly long and bloated. I rarely found myself having to do outside research to understand the lectures despite my limited algorithms background. Overall, you’ll learn a lot of useful and interesting material if you’re willing to put in a reasonable amount of time/effort.

Another great thing about this course is that the instructors seem genuinely invested in the success of every student. Grades came back in a very timely manner, Piazza questions were answered quickly and thoughtfully, and regrades were reasonable and amicable. The thought and care the TAs put into their work made this class one of my favorite so far in the program. I believe the head TA for this semester was different than usual, but he did an excellent job.

My main issue with the course is the exam format. This semester, exams counted for 60% of the final grade, which I understand is less than the 75% they used to count for in previous semesters. However, like other semesters, each exam was heavily proctored and had only 2 main questions so if you blank on one, you’re in some hot water grade-wise. I don’t feel that this small sample size is a good measure of student ability and knowledge (especially for those with test anxiety); for example, I froze up and got an extremely low grade on the first exam (<50%) even though I truly feel that I understood the material completely, and I spent a ton of time practicing for it. That being said, I still ended the semester with a very comfortable B, so don’t panic if you have a rough first exam. I just wish there were a better way to test student knowledge that didn’t come down to a high-stakes all-or-nothing test scenario where one bad question can throw away weeks of studying.

Most of this has been said by others before, but here is my advice for success:

• Watch for patterns, especially with DP and NP-Complete problems. With enough practice, you will notice patterns that make it very easy to identify what needs to be done for any particular problem. Which brings me to my next point…
• Do ALL the optional practice problems give on the homeworks, plus extra out of the book. This is absolutely the best way to prepare for the exams and if you get lucky, the exact problem you practiced will be on the test (happened to me in the final).
• Take the homework and coding quizzes seriously and make sure you’re confident about both the correctness and completeness of your answers. I ended up with a 99 average on the homeworks which saved me from my disastrous first test score. You can check your answers on the internet so take advantage of that safety net.
• Don’t panic. This class is not the smoldering hellscape that other students would have you believe, and you’ll get through it just fine!

This class is difficult not in subject matter but the grading structure of the class overall. Homework (25%), Tests (60%), Polls (3%), Coding Quizzes (10%). There are several issues here: 1. There is no leeway if you completely bomb a question on an exam. There are typically only three problems total. If you bomb one, you are essentially done. In addition, the tests in my opinion are not fair. Many times it feels like russian roulette as to the difficulty or subject matter of problems presented on the test. The hw problems are not indicative of the difficulty of the problems you will encounter on the test and you can be sure that the professor will throw in some “trick” to trip you up. 2. Homework is 25% of your grade. You only get six to eight total. This would seem as though it’s to your advantage. However, homework grading is extremely subjective at times with TAs pressed to meet tight deadlines and grading several assignments at a time. In addition, instead of being able to learn by doing the hw, you are now stressed and fighting for points as doing well on the hw is critical to success in the class due to difficulty of the exams. There is no room to learn here. Make a mistake and bomb a hw and that’s essentiall 3 points off your total grade. 3. The proctoring requirements for exams make a stressful exam even more stressful as one has to ensure they perform each step or else be deducted points. 4. When submitting coding quizzes, there are base cases that are automatically graded on the spot and give feedback as to whether your algorithm passed. That’s great, until you are deducted points for not accounting for some arbitrary case not listed in the requirements. 5. The lectures are as dull as they come. Brutally dull and superficial at times. Professor goes over simple examples in the lecture which does nothing to help with the actual difficulty of exam questions as stated previously.

This is a great class. The subject closely follows that of the textbook by Dasgupta, which is a phenomenal resource, and essentially covers the entire book, including some interesting unconventional topics like the FFT and NP-Complete reductions. The class lectures by Eric Vigoda are also done very well.

The course handles like a tough undergraduate algorithms course in terms of scope and pace. In terms of assessment, it’s straightforward and fair. The homework and exams are meant to test your fundamental knowledge and aren’t especially hard or tricky.

That said, this is algorithms, and it requires logical thinking and mathematical facility, so don’t expect to learn the material without banging your head against tough problems. And that’s really the key to success: do lots of problems (and spend time on them before peeking at solutions).

The TAs who are active are excellent, and the course is very organized. This is definitely one of the top courses in the program.

I put in like zero effort and got a B with a software engineering background (I excel at math). I didn’t read the textbook at all but I did do the problems in them to prep for exams, which I highly recommend as the exam questions are similar/identical. The material is fantastic, the lectures are fantastic, and the problem sets are fantastic. I loved this class, it’s easily the best I’ve taken so far. You aren’t drowned in homework and, if you struggle, can apply efforts into studying the material your own way.

I have a non-CS background, coming into this class relatively cold with no formal background in Algorithms. Apart from some small mention of Big-O back in my undergrad when I took an introductory course to CS (which was about 8 years ago), this is the first time I’ve encountered these topics. I have a fairly strong math background, though. I took this class in my last semester in OMSCS, along with two other classes, and while working part-time. I ended up with an A in the class.

The strategy to doing well in this class is to study the well-established algorithms and concepts and be able to apply them for new situations. For example, in Dynamic Programming, the Longest Common Subsequence can be applied in some way to the Palindrome or Edit Distance problem. In Divide & Conquer, all problems can be solved using a Binary-Search-like or MergeSort-like approach. In NP-Completeness, a lot of problems are some version of another problem. I think that in order to master the material, your best bet is to do a lot of practice problems in order to “recognize” the problem.

My main critique about the course is regarding the lecture material and textbook. I personally felt the lectures and textbook chapters were way too concise. There were moments where the professor or author is like “Oh, and of course, this is the obvious solution? Isn’t it elegant?” and I’m scratching my head like “What??” Then I proceed to read the chapter a couple more times, and google for online lecture videos of these concepts to get an alternative lesson. Throughout my time at OMSCS, I think I ended up having to search for supplemental study materials more often in this class than any other class I’ve taken. I’m a bit surprised at some of the other reviews that say the course materials are perfect, but I also wonder if this may be due to my non-CS background.

For the most part, I enjoyed taking the class with the instructors as I thought they were very knowledgeable. It was nice to have office hours and hear someone talk about the concepts in real-time (Rocko is awesome!). I think considering how theoretical this class is, it’s difficult for the online format of OMSCS to properly capture the heart of a class like this. This is one of those classes where I almost wish I could be in a classroom to ask questions during a lecture. Of course, this is not a fault on the instructors, but the nature of the game. That being said, I’ve always thought that the instructors were fairly open-minded to discussion on Piazza. There were a handful of times when a student opens a discussion on their different (though correct) algorithm for a problem, and the instructors (and students!) chime in with helpful feedback.

Grading is kind of tough, if I’m being honest. The key to getting points for your answer is making sure you apply the concepts in the most efficient manner. Your Big-O matters! I always try to make sure that I state my assumptions clearly, and construct my answer as concisely and as completely as possible. For the most part, I’ve always been able to get full points back, or at least, partial credit. But then, at times, during these regrade requests, the instructor also decides to take off points for something else, or decides to penalize more for something already penalized, so proceed at your own risk! It’s a bit frustrating, and at times, I do feel a bit discouraged about asking for points back for something that I’m pretty sure is correct. Though they offer a chance for you to redeem a bad exam grade with a cumulative final, so that’s pretty helpful.

Overall, this is not my favorite class because it’s more of a writing class than a programming class, but I do think it is important to take. You have to put a lot of work into it to do well. I can see how if someone is also working full-time while doing this class may have some challenges since this class requires a lot of dedication and time to master the material if this stuff is pretty new. Heck, I barely feel like my own sanity is intact after this semester! Now that I’m done with the program, I intend to try my hand at actually programming the concepts taught in this class during my free time. I think these topics are definitely important to learn in order to be an effective programmer.

I have to admit that I was really bad at algorithms before this class. I didn’t do well at all in undergraduate and even when I took this class previously at graduate level. I had trouble answering a Fibonacci question in an interview 2 years ago. Not only did I not use the dynamic programming solution but I think also got the recursive solution wrong. Yep I was that bad even probably 5 months ago. I mean if you know the answer to Fibonacci right now before opening the book with dynamic programming or if you can just read the Fibonacci question and think of a way to solve it in O(n) if you have had any programming experience or if you also know what O(n) means then I think you will be just fine in this class given you study regularly and follow how to properly use the format in the class to answer questions. Remember to follow the format while answering.

For those that are worried or have limited background or are just bad at it (like I was - hopefully ‘was’) there is only one way to get through this class clearly. And that is practice practice and practice like the professor says. First of all the official book is DPV. Get that right now, and if you plan on taking it in summer then start solving DP problems and watching lectures right now. You will need to first make sure you strengthen your basic algorithms. Meaning the book and lectures have certain basic algorithms that you need to know and once you know these problems you can use them as guidelines to solve more complex and twisted worded problems. However the only way to get that is to solve lot of them and maybe even repeatedly solve the ones you cant remember how to solve if you look at them a week or so later.

The proctoring rules makes it a bit harder (sorry guys this is the common format of algorithm exams usually - 3 tests and some projects with home works and exams using pen and paper) but here are few things I followed that you might find useful (could be different when you take the class so DO NOT DEPEND ON THIS)

Invest in a good external webcam that can be mounted. I took all OMSCS exams in the last 2 years with an external webcam so I already had one. Macbooks mostly have decent webcams so maybe they are exempt from this but the proctoring setup will get tricky without an external webcam.

The basic idea is that while you write the test on a desk, your screen should be visible, your workspace should be visible, and when you upload the scans everything about you and your scanning hardware must be visible. Problem is that you will need to push your laptop away from you if you used the in-built webcam so that the entire workspace is visible so you either need a large desk or some way to achieve this possibly by mounting it higher at an angle or something but be very careful and confirm everything including your head can be seen. I bought a 10$ amazon basics tripod. Mounted the camera and set it at a distance. This way pretty much all the area was visible and it was a very simple and cheap solution that worked. TRY YOUR SETUP BEFORE YOU TAKE THE ACTUAL TEST.

Why proctoring setup is important? You need to stop feeling stressed of inadequate proctoring requirements and focus on the test itself. If you worry about proctoring, you will miss the fact that the test itself is the part that gets you the grade not proctoring. So get it out of your way first.

A phone can be used end of the test to scan and upload or a scanner connected to the PC. No you can’t scan and send from the phone directly, you can email it to yourself or use a data cable but the upload must happen from your proctored device. So make sure you have backup device in case your primary scanning device doesn’t work. I had a scanner but I used a phone with a scanner app for all three tests where I emailed myself the scans then opened the email in the proctored PC and uploaded via Gradescope. The phone method is way faster than a scanner.

Finally practice the setup with the onboarding. I also asked a friend to setup a practice exam for me (he sent me some random problems from leetcode in mail and then I didnt look at the mail until I took the practice exam) before exam 1. So I practiced with the onboarding which is unlimited attempts and open throughout the semester. I think that helped.

I ended up with an A. Study regularly for this class (recollecting something you practiced 2 weeks ago can be tricky). And remember to keep your calm during the test. You might not get it initially but if you wait for a few minutes and think about the problem from different ways you might get it eventually. Also whatever format for the semester they give you, you still need to put in same effort but the class is very well managed so that can help you put the effort in right places. This might all sound a bit stressful and lot of work, but honestly as a Computer Science Graduate Student, its really fun to do algorithms once you start getting a hang of them which I can only say now after being terrible at it for so many years.

One of the best classes I have taken. A must do for anyone who has not already taken an algorithms course. The course covers a range of interesting algorithms and their time complexity, going through most of the DPV book. The lectures are excellent as well as the TA and Professor involvement in Piazza.

The course is hard but very fair. Most exam questions were similar to questions in the textbook so if you studied you should do well. The nature of the exams did add pressure. In one exam I got less than half points, mostly due to misreading one of the questions. Despite this I was still a hair under an A grade going into the final, and the final is optional and can only improve your grade by replacing the weakest exam score.

One of the best courses in OMSCS and hats off to Prof Brito and the TA team.

Videos are the best and provide in-depth understanding of the topic

Textbook selected for the course covers the topics in details. But Prof’s videos and TA classes make it possible to understand all the material.

Not an easy course but definitely one with the most learning.

Can’t express enough gratitude for Prof Brito and TAs for their understanding of the entire pandemic situation and adapting the course load to help the students as best as they can.

All in all, one of the best courses I have ever attended anywhere

One of my favorite courses in OMSCS! The lectures are very clear and the textbook is very concise. The homeworks were very good preparation for the exams so there were no surprises. For Spring 2020, the first exam (DP, D&C) was easy, so they made exam 2 (graph algorithms) quite difficult, and ended with a moderate exam 3 (NP completeness, LP).

My biggest tip for those who take the course is to do as many of the DPV problems as possible and really study them. Sometimes exam questions are taken straight from it. I did this and ended up with ~98% in the course.

Lectures are very in depth and well organized. Get started on them early because they can be very long. To succeed in the class, do as many practice problems as you can get your hands on. I spent the time every week to do 5-10 problems from the textbook and I believe it paid off greatly. This class was a lot of work on top of the coronavirus pandemic. Expect an assignment or exam every week. Do not underestimate the time you’ll need to devote to the class. As with many others, this was my last class in the program and I found it very enjoyable. I learned a lot and I only wish I was able to take the class earlier in the program.

Overall very good class. Leave your computer alone, spend much of your time on your scratch paper and understanding the concepts from the video and the book and all will be good. Algebra is must. Try to do as much exercises as possible in the text book after each chapter.

Overall, this class was reasonable this semester. I worked my butt off and got an A. This was also my last class in the program.

Similar to previous semesters, if the coursework is not familiar to you, you will need to study and practice a lot. The secret is to do as many practice problems as you can.

The tests were difficult and the proctoring was ridiculous but it is worth it in the end. If you do well enough, you can finish the semester pretty much in April.

Homeworks were worth 30%, Tests worth 20% each, quizzes worth 10%. Homeworks were important and you really need to make sure you get every detail right, and follow the instructions.

I have an EE bachelors so Algorithms was not my strong suit. But I’d like to think it is one of them now.

Background: This is my last class in the program and I’ve taken it once before. I previously dropped after Exam 2.

This term the class seemed really reasonable.

-Homework had significant weight. It could really help your grade if you put effort into it. DO NOT BLOW IT OFF. YOU’RE JUST PISSING FREE POINTS AWAY.

-A “final exam” was offered optionally so that you could replace a low exam grade. (I did not take it so can’t comment on how bad it was).

-Exams were hard but they were reasonable when grading them; especially exam 3.

-Rocko’s office hours were awesome. It really helped.

Outside of that:

-Participate in the Slack channel. (#cs6515)

-Do the additional “not-required” homework problems. Besides outright practice (DP), some of the questions are really close to exam problems.

-Completely tanking an exam problem can still drop you 8% of your final grade.

-Their proctoring requirements are still pretty ridiculous.

Overall, the class has a reputation that proceeds it. They’ve made changes. If you put forth your best effort, getting a B should be reasonable. Getting an A is a bit more of a challenge.

I ended up with an A.

A very easy class. I like the lectures, which are crystal clear.

my background: No CS undergrad (linguistics). I have taken tim roughgardens algorithm course 3-4 years ago (which I recommend), that helped prepare me significantly for this course.

Course format was very fair. This semester the setup was

• HW’s (we had 7) = 30% grade
• Exams (3) = 60 % grade
• Quizzes (ours was corona canceled) = 10% of grade

There is an optional final (which I am not taking) which you can take to replace your worst exam score if you want. I earned a solid B in this course (~77%). Historically 70-85 is a B, and 85-100 is A.

It’s very possible to get an A in this class if you

• a) Do all the homework and work to understand them.
• b) do all of the book problems as much as possible because this helps you practice and learn all the different patterns. Additionally, sometimes a book problem appears on an exam.

Doing well is a combination of two things

• a) understanding the material in-depth and intuitively.
• b) understanding the notational intricacies and requirements for setting up the problems. I lost 9 points on my last exam for not quite setting up the problem correctly, I missed small details. However, my overall understanding of the material allowed me to be set up the problem mostly correctly and the T.A’s only dinged me somewhat.

Granted the grading may have been more lenient in my semester (COVID-19) but overall it seemed quite fair throughout the semester.

The material itself - Graduate Algorithms - is awesome and totally fun. Especially if you like math, but really for anyone who loves computing.

Prof Brito does a great job in video lectures and the T.A’s did a wonderful job on piazza and with office hours. Everyone was very helpful and supportive. I only went outside class material a few times to brush up on skills (big o notation, binary search, dijkstras shortest path) that are probably taught in undergrad.

Finally, a huge shoutout to Prof Brito and all the T.A.s for handling the current world situation (COVID-19) so gracefully. At a time of high uncertainty, fear, and anxiety we see people’s natures in crisis and Prof Brito and crew showed theirs to be 100% upstanding.

Prof. Brito personally answered every single question regarding class changes and any difficulties faces because of COVID-19, and in my case, he answered within minutes on piazza. He was extremely active, thoughtful, and fair. He demonstrated that he was actively self-reflecting on his own choice of words and decisions. I believe this fostered a community where students felt comfortable to express their concerns and doubts without any fears. We felt like we could just ask the questions we had without any fear of “pushing the envelope” and asking for too much.

Overall an outstanding course with excellent teaching and leadership.

This is was one of my favorite and last classes that I took over my 4-year journey from 2015 to 2019.

I can’t stress enough to work through the recommended exercises from the text. The process I followed was to watch the videos, read the chapters for depth, and work through the exercises. Sometimes I felt the videos lacked the details, which was supplemented by external resources.

I do wish that the less breadth and more depth was introduced as this is supposed to be a graduate-level algorithms class. I felt that a lot of the material was a re-hash of what one would learn in an undergraduate level curriculum.

None the less, even if this course was not required, I would have enrolled anyway.

As a side plug, I am applying what I learned in this class, as well as the GT MSCS education to build this web app https://www.korabo.io.  Allows collaborators to split proceeds.

The app will allow you to generate a shield to a checkout like so which you can stick on your github repo.

I don’t normally write reviews, but I feel like there are a lot of mixed reviews and ambiguous anecdotes for this class and not a lot of concrete information about it going in, so I wanted to try and provide some details.

I come from a non-CS background. I studied IT in undergrad, and have never taken an algorithms class in my life and have only taken math classes through pre-calc and statistics. That being the case, I was extremely worried about my ability to succeed in this class and what the content might entail. There were 3 exams, and all 3 exams were weighted the same and accounted for 75% of the final grade. A project was worth 10%, fairly straightforward take home coding quizzes totaled to 5%, and the HWs were another 10%. The class was broken down into 3 exams and corresponding class units:

Exam 1: Dynamic Programming / Divide & Conquer

Exam 2: Graphing Algorithms / Max Flow

Exam 3: NP Completeness / Linear Programming

During the exam 2 period, one week of material was on hashing/bloom filters that correlated to the project, but it was not on the exam.

As far as Exam 1 information goes, Dynamic programming is the most difficult content I’ve ever been exposed to in my life. I must have studied 30 hours a week, thought about it constantly, tried to take tutor sessions, and by the time the exam came, I still could not do it. I was convinced that I was a failure and that I wasn’t smart enough to do it. I got a 66 on the exam, which was slightly higher than the class average. I lost so much sleep, pulled out so much hair, and couldn’t believe that I came away with a failing grade after that amount of effort.

But here’s the thing about this material that people don’t realize going into it. As far as extremely difficult content goes, I personally felt that it stopped there. D&C along with the other exams’ content was perhaps challenging, but I never felt like I couldn’t do it. The DP content spooked me so much about what I was in for, but it really wasn’t representative of the course difficulty as a whole. I put in close to the same amount of time for exam 2 and realized that I was really over-studying and nearly got an A. This missed points were just silly mistakes I made due to a Proctor Track fiasco, and not really because I didn’t know the material. I believe the reason the class is front loaded with the most difficult material first is so that people can have an opportunity to drop it before the withdraw deadline. Instead of getting to the end of the class and potentially failing on the most difficult material, they just get it out of the way, which helps you know how well you can do moving forward. By the time of the final exam, I was completely burned out and missed an A in the class by .53 points. It was totally within my grasp, but I took the exam early because I wanted it to be over with and I paid for those few days of freedom with a letter grade. An A was totally within reach for me, but I’m fine with the B. There was also a 3 point curve for the C/B range only, which didn’t affect me, but surely helped some other students pass. I would like to note that while many semesters have a curve, not all of them do, and it is never guaranteed, so don’t count on it.

The point I’m trying to make is that this class isn’t as big, bad, and scary as people make it out to be. Difficult? Certainly. Impossible? Certainly not! Coming from the background I did, I was able to teach myself the prerequisite content that is built upon and succeed in the class. Don’t let yourself get bogged down by the Dynamic Programming. Stick with it, do your best, and let Exam 2 be a more realistic indicator of performance. Many times in the class I thought about not only dropping out of the class, but quitting the entire program because I was so overwhelmed. But if you ever feel this way, just remember that both Piazza and the course Slack channel are filled with extremely helpful students and TAs alike that are going through the same exact experience as you and are there to help each other succeed. Don’t be afraid of this class. It’s extremely interesting and fulfilling to learn the material, and I walked away with an extreme sense of satisfaction, but also my first gray hairs.

The subject matter covered in this course was very interesting and useful to me. As an engineer however, I was disappointed with how both the book and lectures often describe what a problem is, e.g., dynamic programming, but even after reading all the material, we learned little to no consistent methodology to solve some of the types of problems like DP or NP-Complete. I often had to find other lectures which describe concepts more completely.

Since the grade is based 75% on 3 tests, and 80% of the test are two problems, passing this class is based upon a very small subset of problems you study. As some other reviewers noted, the problems can seem easy in hindsight, but they are often dependent on having a “eureka” moment. I have all A’s in 7 prior courses which goes to show how hard this course is compared to others in terms of grading. Graders are strict and do not give credit for taking reasonable, correct approaches to solve the problem, only credit for correct proofs.

I honestly don’t know what the hell they did with this course. What was once the most daunting and difficult course in OMSCS has gotten nerfed tremendously. The amount of lectures covered per week is super manageable, and the weekly homework assignments consist of only 2 questions. The exams were manageable as well, though I must admit that the TAs grade very strictly, and though they claim to grade off a rubric, the way they take off points indicate otherwise. Also please note that the TAs do make mistakes when grading (I recovered letter grades worth of points from 2 exams), so make sure to review your grades and submit regrade requests if you think your answer makes sense. However, though the workload is manageable, the material covered by an algorithms class is going to be challenging no matter where you take it. Many topics were covered better by Youtube than the class lectures.

To pass this course, you need two things: You need to be able to answer the questions, and you need to know how to document your answer in a way that gets full credit. You will want to study the lectures closely on how the instructor structures their proofs and/or analyses to make sure you follow that pattern.

What makes this hard is that it’s not a class you can code your way out of, so if you have a strong programming background it’s helpful, but not as helpful as you’d like it to be. Many of the problems involve staring at a question until the answer comes to you; there’s a few rules of thumb to help you, but basically you just have to have a flash of inspiration. Thus, much of the studying consists of building up your intuition and getting better at lucky guesses. You’ll see a lot of recommendations to do a ton of dynamic programming examples as a means of doing that. The same goes for NP-Complete reductions. The result is a sort of pass/fail kind of results to the class: either you get it, and you do great, or you don’t, and you flail. You can basically flub one of the 3 exams and still do OK (get a B), but more than that and it’s a lost cause. For me, I found Dynamic Programming challenging, but the rest of it was easier and so I did OK.

This is one of two hardest courses I’ve taken so far with the other being Intro to Operating System taken as my first class. If you have never taken an algorithms class before, then you’ll probably be spending the average workload per week. You’ll be learning a lot of different famous algorithms.

The homeworks are tough but they do reflect on what you’ll expect on the exams. Do not give up if you don’t do so well on one exam!

This is one of my first two OMSCS courses. I took it with Bayesian statistics and end up with an A. There are three midterms exams, I got 52% for the first one and 96% for the other 2, so I was still able to reach an overall 85.7%. The final cutoff for A is 85% and for B is 67%. When the first exam result came out I really thought I might have to retake this class though. Surprisingly the Dynamic Programming question wasn’t tough at all but the Divide and Conquer question was. Exam 2 and 3 are realtively easier and the grading is more lenient in my opinion. So I would suggest don’t lose hope/drop the class if you got crashed for the first exam, and just spend time and do more practice problems for the latter sections and you will get rewarded.

Background: I’m working full time (remote so no commut time, and not much overtime working), and 3 months pregnant when the semester starts. My undergrad and graduate majors are not STEM, but I took calculus and one algorithm course in undergrad which is more than 10 years ago.

Before the semester starts, I bought the book and watched 2/3 of the lectures, trying to get prepared for the class. However, what really helps are doing the homeworks and exercises in the book, when the semester starts. Lectures are relatively easy and straight forward, but only thourgh doing the homeworks you can really understand the concept and pattern of the solving the problems. Do all of the practice problems, and try to do as many problems as possible in the book in addition to the homeworks. Solutions of many problems can be found online by searching DPV 1.2 solution or something like that. Or you can post in the forum for help.

I feel like it is a good idea to took the class as first one if you can afford the time and effort. It is a mandatory for most of the tracks so you’ll need to take it anyway. And it really helps to set up the right mind-set for this program. It might be hard to get in the course though. I got it on ‘Black Friday’ after several hours of refreshing my webpages.

Difficult course only because of the way the course is structured. We had 3 exams each with very little no. of questions and they essentially decide your grade. <- negative. But, seeing the recent trend of GA reviews and comments from students, the overall course load has been reduced. The exam difficulty has (probably) been reduced. We did not have a cumulative final. <- positive.

The content of the course is not too hard if you have a background in CS or if you are a recent UG graduate. I got a pretty high overall (95%). My prep was like this:

Exam1: (DP + D&C) - do problems from DPV, homework, geeksforgeeks. For geeksforgeeks, I would recommend skimming through at least 50% of the DP problems on the website. You can skip the “difficult” ones as they are unlikely to come on the exam. You can kinda guess what’s difficult and what’s not based on the homework and extra problems that you get in your semester. More than DPV and homework, geeksforgeeks helped me prep for DP. Also, note that this exam will probably decide your final grade - if you absolutely crap out here, getting a B will be hard even if the cutoff is low. So, put max effort into this exam.

Exam2: (Graph) - this was like a breather after the exam1. Problems were relatively easy, but the content is a bit more difficult than that we studied for exam1. DPV + homework problems are more than enough. Just be sure to understand all the graph “tricks” to make problems easier to solve. Don’t overcomplicate solutions. If you are doing that, then what you’re doing is probably wrong.

Exam3: (LP and NP) - conceptually the most difficult of the 3 exams. DPV + homework again is more than enough. Make sure to clearly understand the solution to DPV problems - don’t just skim any of them and assume you will do well on the exam! details matter since these are all proofs! For the LP problems, lectures are the best source. There is a lot of online material for this, but it’s kinda different from what’s taught in the lectures. So, it’s best to just stick with the lectures and lecture examples for LP part - that will mostly be enough.

Exam problems have largely been variations of homework and practice problems, but that does not mean only those will be enough practice (unless you are really good at algos that is). You just need to keep revisiting DPV problems - atleast 2 or 3 times. Doing them all at the last minute isn’t going to help you. This is the best advice anyone is going to give you - “Do DPV problems” and it’s no joke. Even if you just practice DPV problems alone repeatedly, you will mostly get a good grade! I’d suggest spending 1-1.5hrs everyday just to refresh the content+problems and keep practicing problems.

Treat this course like a marathon, keep practicing and you’ll get that A! :D (+ it’s free interview prep! :))

My reason for dislike: I did not feel like I learned anything new as I’m a recent UG graduate. So, I only took this course because of the spec. requirement. For a situation like this, I did not expect to put this much effort and take on a lot of unnecessary stress to learn very little. The course is very stressful because 1 mistake in 1 exam can drastically affect your final grade. I’m NOT overexaggerating here. I’d much rather have few more projects (as I actually learned cool and useful stuff from the bloom filter project) and maybe more applications of algorithms instead of placing a LOT of weight on exams which are very unforgiving.

I loved this class. There were 7 homework assignments that together only contributed 5% to the grade, but they’re strongly recommended as the best way to prepare for the tests. There are three tests. The questions require a bit of precision and you have to think on your feet, but if you’ve really understood the homework then the tests will be fine. The textbook is short and an easy read. Get it. The lectures are solid too. The material feels like very core CS. I enjoyed all of it. The course is known to be difficult, but I found it easier than others I’ve taken like CV, ML, RL, or AOS. I think it’s reputation comes from selection bias. So many students have to take it and can’t avoid it. While the students who take AOS are self-selecting into it and hold a higher bar for what counts as difficult.

I’m writing this review in my Airbnb in Atlanta on the night before I graduate, and I’ll try to keep this brief and straight to the point.

This class was awesome. It was challenging, the material was interesting, and I really feel like I “earned” my degree after taking this course. When I took this course in Fall 2019, it had 3 exams, 2 quizzes, 1 project, and 8 homeworks. This topics this course covers are: Dynamic Programming and Divide & Conquer Algorithms, Graph Theory, NP-Complete Algorithms and Linear Programming.

To be honest, the material isn’t what makes this class difficult. The grading scheme is the hardest part, because exams are worth 75% of the grade. The first exam (Dynamic Programming and Linear Algebra) is the toughest. Dynamic Programming can be a pretty tough topic, and the class overall usually does the worst on it. Exam 2 (Graph Theory) was the easiest in my opinion, and Exam 3 (NP-Complete Algorithms and Linear Programming). One thing I noticed is that as the course went on, the graders seemed to be less strict on exams. Mistakes that cost me many points on Exam 1 didn’t seem to matter as much on Exams 2 and 3.

I ended up with an 86% (A) in the class, and the B cutoff ended up being lowered to 67%.

Grade Stats:

• Exam 1 : I scored a 29/50. The class mean was 30.89/50 and the median was 31/50
• Exam 2 : I scored a 44/50. The class mean was 39.34/50 and the median was 42/50
• Exam 3 : I scored a 50/50. The class mean was 40.50/50 and I’m not sure what the median was

The biggest advice I can give is:

• Start studying before the class begins by reading chapter 6 of the textbook, watching the Dynamic Programming lectures on Udacity, and doing some of the practice problems. It sucks to hear this as someone who is preparing to take this class, but doing this really helped me during the first few weeks of the course. Dynamic Programming was a topic completely new to me (and it can be tricky for everyone), so spending an hour a day before the course began learning DP really helped me feel less stressed than I would have when the course started as someone who hadn’t prepared.
• Do the practice problems as part of your exam prep . I can’t stress this enough. Each exam had questions that either came directly from a practice problem, or were similar to existing practice problems. Completing the practice problems can really help you do well on the exams.
• Do not freak out if your Exam 1 grade isn’t what you hoped it would be. Exam 1 is always the lowest exam grade for the class because Dynamic Programming can be tough for a lot of people. Don’t despair, and stick with the class. When I found out I had scored a 29/50 on Exam 1, I freaked out and considered dropping. I’m so glad I didn’t. Tons of people do terrible on Exam 1, only to do extremely well on the last two exams and get an A in the course!
• Utilize Slack : One of my favorite things about this course was how active and helpful all of my classmates were on Slack and Piazza. Don’t isolate yourself. Talk to people who are in the class with you, share some memes, discuss solutions with each other!
• Do as best as you can on the quizzes & project . The quizzes and project really just exist to help bump everyone’s grades up, especially the project. Take these assignments seriously instead of putting them off. Start them and get them done early so you can worry about the homeworks and exams.
• Do your best & have fun . Seriously. At the end of the day, all you can really do is your best. Study hard and try to do well. But also have a life, get outdoors, see some friends, and don’t let school consume all of your free time.

Good luck! You can do this, and I believe in you. <3

Pretty fair - would be extremely difficult without high-level undergrad algorithms course. Still tough due to grading structure. Lectures are decent, but it’s more important to be able to do the homework and practice problems well.

Let’s face it - you’re taking GA because you have to. But that’s a shame, because it is one of the most interesting and rewarding courses in OMSCS. There’s a lot of content crammed into it, from Dynamic Programming to network algorithms to LP to Undecidability. Recorded lectures are pretty excellent, the projects are interesting.

Okay, it’s 75% high-stakes 3-4 question exams, and that’s the part that freaks people out. That’s pretty typical for most graduate schools, and these aren’t “trick” questions that rely on anything other than the materials. It’s neither fair nor unfair – it’s just how a lot of courses work.

Know your Big-O notation, know core algorithms, buckle up and prepare to study. In the end you’ll feel like you understand this CS stuff.

GA is a course that breaks a lot of people. The exams are high risk and high stress. 60% of your grade is detemined by 6 problems (in prior semesters this was even higher). If you mess up 3 of those, or some partial combination, you fail the class. You can only miss 1 in total to get an A. Anything between is a B. If you are good at taking exams than that experience will pay off here.

Once you get past the first exam, and figure out the testing approach, I think this class gets much easier. I’d say the run up to the first exam was probably the hardest class experience I’ve had so far in OMSCS, as some of the topics are quite difficult. After that it got much easier, and the final NP complete section was a complete walk in the park with several weeks of downtime.

This class gives you everything you need to do well in it. Make sure to do all the homeworks/additional practice problems, and study extra problems in DPV and you will do well. The class is very well run I think and the TAs were excellent in turning around grades quick.

This course is not actually that hard. Your grade is almost 100% from exams. My recommendation to prepare is to do a bunch of dynamic programming problems on Leetcode or Geeksforgeeks. Even though you don’t have to do them in real code for the class, I think it’s helpful to do them in code on something like Leetcode first.

If you’ve taken a Data Structures course beforehand, you should be fine here. If you haven’t, you might be in for a rough time. When you don’t understand an algorithm in lecture, just go to Youtube and find someone else’s explanation. Everything in the class is covered in many other places.

One thing I don’t like about the course is that the grading does indeed seem to not be all that reliable. I think this is unavoidable, but it does mean you have to read the answers and check that you were graded properly. If the grading was off on an assignment, I would let it go, but if you get marked off for a question on an exam that you actually got right, follow the process exactly and appeal. This is an annoyance, but I think it’s unavoidable. The TAs are doing as good a job as they can, and that’s that.

That said, this course is one of the most useful ones you can take. If you want a job at many of the “real” tech companies, you need to know all these algorithms cold better than you learn them here and be able to code them too. Everyone should consider this course a requirement, even if you are doing the Interactive Intelligence spec.

8 written homework (10%) + 2 coding homework (5%) + 1 project (10%) + 3 exams (75%)

Part 1. Dynamic Programming + Divide & Conquer Part 2. Graph Algorithms + Max-flow Part 3. NP-Completeness & Complexity + Linear Programming

• Excellent Lecture Video.
• Not quite possible to take this before being in the 6th or 7th course of the program due to shortage in available seats
• Difficulties largely depends on previous background and/or preparation
• Most important (I will say it should be a compulsory one) for a CS degree
• Wonder how much more difficult it was in the era of CS 6505

This course destroyed me. I am going to end up with a B or C. I just took the final exam. I spent hours upon hours studying for these exams to continually get wrecked. Do yourself a favor: become a master at dynamic programming, NP-complete problems, and any of the other topics in this course. This is my 10th course in the program and this one absolutely wrecked me.

Prepare for divorce. Your friends will wonder if you even exist anymore.

I think this course by far has the worst testing format of the entire OMSCS program. There are 3 exams that form 75% of your grades. Each one has 2 problems that form the bulk of the points. One mistake can cost a lot, and in the limited time and format of the exam, it is quite possible to make a mistake that is going to steer you in completely wrong direction. Some of these are of the nature that after the exam you realize wow that was such an obvious thing, but during the exam its not that obvious. Of course hind-sight is 20/20, but it seems like the whole testing format of this course is based on that principle. The catch is that you don’t get to use that hind-sight within the course, because the next exam is going to be on different topics.

Course topics are interesting. Lectures are very detailed, however some are intuitive while others are absolutely not. Which I feel is unfortunate because the recorded lectures seem to have taken quite some work. In the lectures, you don’t see the forest, just the trees. You have to basically work out those examples and problems explained in the lectures or in the assigned book chapters that are not intuitive on your own, via forums, other materials on the internet, until it is clear to you. Maybe that’s the intent. But I have seen better video lectures that are very good at build intuition. I think it’s a whole different teaching style and philosophy compared to some other courses that I have taken in OMSCS.

Exams are luck-based; you get penalized heavily if you happened to answer the question differently from the intended “correct answer.” A boring, textbook regurgitation based course that is unfortunately, the only algorithms course in OMSCS.

This is exactly the easiest course I have ever taken.

Lecture video: not much, and very easy to understand if you have a little background.

Homework: spend several minutes to come up with a solution, then spend less than 1 hour to finish writing.

exam: only the first exam is a little hard for some students because one problem(20/50 points) is a HARD problem from Leetcode.

Summer 2019

• There were 3 Tests for 90% of the total grade. 35% for the best, 30% for the second-best, and 25% for the lowest score.
• There were 6 homework worth 5%
• Polls were 5%. Everyone got full points; you only need to participate even if the answers were wrong. Poll closed in 1 day and some folks missed them. Professor still gave everybody the full 5% as it was probably difficult to keep track of the students on Piazza.
• There was no curve for A. You needed to score 85% or better.
• B was curved by 4%. So, 66% was a B.

Oh, by the way, there was no rounding! 84.99% would be a B and 65.99% would still be a C. So, be super careful not to lose points due to silly mistakes in tests, homework or project (if there is one). Some folks lost 5/20 points on tests for algorithm questions for not providing correctness/time analysis.

Discuss the problem on Piazza and request a regrade. There have been multiple occasions of successful regrade. Also, don’t wait until the last minute to discuss the problem on Piazza.

Some Insights

In the first 2 exams, there were 3 questions and the 2nd question had 2 parts; one easy and one medium/hard. You have to describe the algorithm, time-analysis, and correctness for each part. So, it is actually 4 questions. Only, the last exam truly contained 3 questions; 2 algorithms and 1 multiple choice (with 4 parts) questions.

Questions were similar to homework/practice and lectures. However, the exam questions were not 100% identical to any problem in the book/homework.

Questions were well thought out. They were simple and challenging at the same time and can be solved in one-page. I hope I don’t confuse anyone.

They are not anything like some complex/lengthy problems in the book or some homework. They resemble medium/easier ones with little change.

Though, some students find NP-complete rather hard, it is probably the easiest concept to grasp. Professor loves NP-completeness and I’m sure he’ll spoil you. :)

Final Thought

The course is easier for those with Computer Science background or people who are retaking. If your overall score remains around 60% or below before drop date, drop it if you cannot afford or do not want a C.

First, the lectures were good but not very comprehensive like most classes in this program. I used MIT OpenCourseWare lectures as a secondary source and read most of the sections that are stated in the schedule. As a summer course, it had 3 exams and they were not cumulative. I remember 6 main subjects and exams were divided into 2 subjects for each.

First exam subjects: Dynamic Programming and Divide & Conquer Algorithms.

• Both subjects require a lot of practices. I used the textbook’s questions as well as CLRS Algorithm book’s questions.

Second exam subjects: SCCs, Max-Flow

• Max-Flow is my favorite subject. It is easy to learn but a bit difficult to master because you can’t see the solution to a problem using max-flow in the beginning. Again, practice makes it easier. SCC doesn’t have that kind of variety, at least I haven’t met. I think this part can be the easiest one, even though I lost most points in this exam because of a misunderstanding of a question.

Third Exam subjects: NP-Completeness, Linear Programming

• NP-Completeness is difficult to comprehend but it is super core to Algorithms so spare your time to understand fully. This class touches LP only a bit, so learning the rules and duality will be enough. I don’t believe they’ll ask you to solve a problem using Simplex or something. But, it is important to be able to set up a problem as an LP.

It is really easy to lose a lot of points because the exams consist of two problems and one multi multiple-choice question. If you can’t solve one of the problems, then you are at 30/50 (60/100). But, they alleviate this by using an unusual grade calculation. You get 35% of your best exam, 30% of the middle exam, and 25% of the worst one. 85 is cut-off for an A, but it can get lower. It didn’t get lower for Summer 2019.

I found this class much easier than what the reviews would suggest. Topics covered include dynamic programming, graph and max-flow algorithms, NP-completeness and LP programming. Evaluation is done through 3 exams (on the summer version), plus 6 homeworks and a participation pool. The difficulty of the questions asked in the exams ranges from easy to medium: if you have some experience with interviewing at software engineering companies, you’ll be mostly fine.

Material was interesting and recorded lectures by Dr. Vigoda were well done. I learned a ton. He is no longer involved with the class, though. Some takeaways:

• Very stressful course, especially since it is often the last one standing between you and graduation. In the Summer semester there were just three exams that accounted for 90% of your grade. Each exam had two long-format questions worth 20 points each and a handful of multiple choice worth 10 points together – a total of 50 points per exam. If you mess up just one question you can say goodbye to as much as 10% of your final grade.
• Very little feedback was given by the teaching staff and homework was not graded as stringently as the exams so you often didn’t know if you were doing it right until it was too late. This combined with the high stakes nature of the tests makes the course way more stressful than it needs to be.

The raw workload for the course is frankly pretty light. If you do well on the early exams and already have a background with the material you could get away with less. I put in 5-10 hours a week in the beginning and towards the end of the semester I was putting in 30 hour weeks to save my grade and pass. It’s just a highly variable workload – more so than any other class I’ve taken.

Only advice is to supplement the Udacity lectures with additional ones you can find online and do every problem in the textbook for the assigned chapters.

The lectures are great, very well taught. The textbook is also very good and helpful.

Previous reviews already say almost everything about the course, but there is something I would like to advice you that I didn’t see anyone saying. I have taken this course in my last semester, but I would suggest you to NOT do that. Most of the content is very useful in a lot of other classes (especially if you are on the ML track). The big O notation, runtime analysis, Graphs, Linear Programming, Dynamic Programming, NP-Completeness… All this stuff is useful in ML, RL, AI4R, DVA, AI and so on. So, take it early, but don’t try it on your first semester, it’s too hard. On your 2nd or 3rd will be perfect.

Although the lectures, the book and the course content are great. The instructors this Summer were not very helpful. They do not help with office hours and they barely answer any question on Piazza. Most of the discussions are solely driven by students and TAs don’t even confirm if we are on the right track.

The course is hard, be sure to invest enough time to master the material. Also, try to prepare well for the exams, they are very stressful and a single question may ruin your grade (there are only 3 questions per exam, 2 of them accounting for 80% of the score)

This is I think the first time that GA is offered in Summer. I heard that regular semester of this class is front load, but for Summer I feel the workload is evenly distributed across the whole semester which is good.

Due to the short semester, we drop some contents like RSA and bloom filter, but still it covers most topics. Also a project is dropped. So we have a weekly poll (5%), homework (5%) and 3 exams (90%).

Exams are fair in terms of difficulty but considering the percentage it has for the whole grade, some mistakes may severely decrease your scores. I completely misunderstood a problem in the 2nd exam but explained what was my mistake on Piazza private post, then I still got partial credit so I can say grading is lenient though. My final score exceeds 85 so I would get A. So you may make up to one big mistake in 3 exams if you want A. I recommend review all homework problems and relevant problems in a textbook (you can get a list of problems). Grading is reasonably fast.

About the contents, I think it is good. Firstly I felt it’s boring because I work as a software engineer and DP and Divide & Conquer are pretty familiar in an interview question which I practice on daily basis. But it gradually changes its gear and goes deeper topics as you proceed. An explanation of NP-complete is interesting and a step of proof is also exited to see.
Overall I think it is decent graduate level “Intro” to algorithm. If you are already in tech industry I think you don’t have much trouble in this class. I feel the workload is rather very light. If you are not familiar with any kind of concepts in algorithm, however, you should be well-prepared.

Last but not least, the requirement for ProctorTrack is way more strict than other classes. It requires you to capture not only you but including your surrounding while taking an exam, to capture 360° view before taking an exam, and to show all your papers before and after an exam, which made me end up in rushing to BestBuy and buying a webcam just before an exam. (It was difficult to satisfy the requirements with my room layout plus laptop built-in webcam)

It’s true, this is easily the hardest (and also the best) course in OMSCS. I wasn’t sure how this course would work in a summer semester, but I think the professor got the workload about right.

• Homeworks (5%). These were given almost every week, and consist of a few problems that are usually right out of the textbook. These don’t have a big impact on your grade, but are critical because the same style of problems appear in the exams.
• Polls (5%). Again, almost every week a poll appeared on piazza with multiple choice style answers. Only participation counted, so it didn’t matter if you got it wrong. These polls resembled some questions on the exams.
• Exams (90%). We had three exams over the course of the semester. Your best exam was weighted 35%, your next best at 30%, and your worst at 25%. Each exam consisted of two algorithm design questions (40% each) followed by a small number of multiple choice questions (10%). The first exam was about dynamic programming and divide and conquer, the second was about graph/tree algorithms, and the third was about NP-complete reductions and linear programming.
• You will learn more than you have in any other OMSCS course.
• The lectures are actually good. Given how stressful the exams can be, the dulcet voice of Eric Vigoda calmly explaining complex topics in a digestible way was great. You may need to re-watch the lectures several times to get everything, but they really do contain everything you need to know.
• This summer semester didn’t have a final exam!
• The exam format is very stressful. The majority of each exam is determined by 2 questions. If you blank on one of these questions in any exam, you probably won’t get an A. If you blank on two of them, then getting a B is very hard. If you blank on three of them, then you’ll have to retake the course. Additionally, there are very strict requirements on your table setup for the exam and scanning your paper with your phone at the end. Many students (including me) bought external web cams in order to comply with these requirements.
• There were no office hours. This just seems odd and detracts from the otherwise good experience.
• Some students complained of inconsistent grading. I didn’t experience this.

Tips for success:

• Just don’t drop the course. The first exam (dynamic programming and divide and conquer) is the hardest and is easy to bomb. If you get lucky on the other exams you can easily wind up with close to 100% on them. There might be a curve at the end as well. Worst case scenario is that you get a C, and retake it, but as you’ve seen everything before you’ll do much better.
• Do lots of practice problems. The TAs advice was simply to ‘search the internet for problems’. This is annoying advice, but it is valid.

This is easily the most stressful class in OMSCS. Even though I ended up with a fairly comfortable A, I still feel like I just passed by the skin of my teeth. You just have to hope that inspiration strikes at the right time during the exams - if it doesn’t, that A can turn into a failing grade.

I would recommend taking this course over the summer, purely because I don’t think I could handle another 4 weeks of this pace and then a final exam that covers everything. If you can, try not to take this course as your last one - If you fail it twice, then you may have to switch specializations and take an extra 2 or 3 courses to graduate with Interactive Intelligence.

Good luck everybody.

This is my 8th class in the program. I have been scared to take this class because of the reviews. It says 20+ hour per week workload. I took it this summer and found that it NOT true at all.

• In summer course, there are 3 exams which are every 3 to 4 weeks. Each exam focuses on specific topic.
• The course is really well structured. The professor is THE BEST ONE I have seen so far. The other best professor in a different way is from COMPUTER VISION.
• It is not as difficult as people reviewed in the program. That’s why I HAVE TO write this review. I never wrote one for this website before. The workload is no where to compare to other similarly rated classes like Machine Learning, Computer Vision, etc. It only took me 5-6 hours per week, including preparing the exams, which basically mirror what you learned in the class.
• I really loved this course and the professor. THE BEST ONE in the program for sure! Do not be misled by other reviews. I regret that I took it until now.

Some pointers from my experience.

• The summer course had 3 exams, once every 3-4 weeks, weekly assignments and poll questions. There was no project. The assignments and poll questions only account for < 10% of your grade.
• The first 2 thirds of the class are faster and tougher than the last third.
• There are only 3 questions in each the exam 20+20+10. Even Small mistakes in the exam can be quite costly.
• The course content is quite interesting and it is worthwhile to read both the recommended texts and also check out the various algorithms lectures available on youtube. With the condensed summer schedule you may miss out on a great class and content if you are always chasing assignment deadlines and exams.
• Make sure you attempt all the suggested practice questions and then some. A big factor in the exam is time management. Having lots of practice solving and analyzing the algorithms gives you an upper edge. In the exam you are expected to have an arsenal of algorithms you know off-head and understand quite comprehensively that you are able to use as blackboxes to construct more complex solutions; or modify to achieve desired results.
• Practice! Practice! Practice!
• Topics covered in the course, Dynamic Programming, Divide and Conquer algorithms, Graph Algorithms, NP completeness and Linear Programming.

Overall it was a great course. I heard and read horror stories about this class with a high drop out rate, difficult exams, and low number of A grades, so I started the class expecting a bruising battle - a daily study plan, some days off booked at work to coincide with exam weeks, pre-watched the udacity videos and other video series on algorithms, and read the course text book before the class. In the end, the efforts paid off, even though I feel I could have still been OK with a bit less effort.

It’s true that the course is difficult, however I feel that it was the best OMSCS course I’ve taken in terms of execution, material, and lessons learned. Eric Vigoda is an incredible teacher who can clearly explain complex concepts with ease - kudos to you sir.

If you want to succeed in this course:

• Do every practice problem, especially the optional problems. If you don’t understand something, post on Piazza or search other forums until you do.
• Read the textbook (DPV).
• Follow the ProctorTrack instructions set by the TAs, especially those regarding visibility of your workspace. I personally bought an inexpensive USB webcam so that I could position it as required.

CS6515 - Spring 2019 This is by far the hardest class of them all. The material is good and the video lectures are in-depth. The problem is the current prof (not the prof that recorded the videos). He was completely absent most of the semester. If you are looking for help, there will be almost none, you are almost on your own. TAs get confrontational, and can punish you if you submit a “invalid regrade request”. Make sure you fight for every point you can. The days of almost everyone passing the class are over. Previous semesters had about 5% of the class needing a retake, this year it was about 25%.

structure: 3 midterms - 2 hours each, mostly free-response, some multiple choice. 1 final - 3 hours, cumulative.

The class cutoffs are A - 80%, B - 70%. The final cutoffs were lowered to 67% for B, so if you got 66.9%, you are retaking the class.

Prepare for 4 months of hell and constant wondering if you are going to pass.

In spring 2019 this class is actually CS 6515, but that option isn’t available on this mediocre website yet. (Pro-tip: for those of you who don’t have the current semester listed as an option when writing reviews, I’ve heard it’s “some kind of caching issue.” Have I mentioned this website is mediocre?)

We had 8 homework assignments that all together were worth a whopping 5% of our grade. Make sure you keep up with them and absolutely do the optional problems since they very much help with the exams. On the other hand, the low weight of the homework means if life gets in the way you can miss one without feeling too bad about it (but I still don’t recommend that). Three midterms, each worth 20% and the final was worth 25%. There was a pagerank project worth 10%. Project was fun and the TA for the project was great.

For the class itself, the lecture videos are very instructive and the textbook is mostly great. This class marks the third or fourth time I’ve tried to study dynamic programming, but it’s the first time that it actually makes sense to me, and I can’t believe how easy I find it now.

But the grading can be very harsh. This class consists of really interesting topics marred by a crappy, almost “all-or-nothing” grading scheme. “Oh, you made one small mistake in the beginning of the problem and it cascaded but you otherwise did everything correctly and clearly understand the overall concept? Enjoy your 5 points out of 20, asshole.” “Oh, you clearly understand the concept but you didn’t do this exactly how we did? Fuck you, here’s a 0.” (To be fair, these aren’t direct quotes, just how it felt. And regrades are possible, kind of.)

What I describe in the previous paragraph is a big deal since each midterm was 3 questions, 20 points each, meaning 1 question was worth 20/60 * 20% = 6.67% of our overall grade, which is more than all the homework combined. So, the exams were very high pressure, considering the strict grading. There is a pretty generous curve from the start, where >= 85 is an A and >= 70 is a B. I think they adjusted that very slightly in the end (so the cutoffs were lower, in the students’ favor) but I’m not sure since I pulled a B before adjustment.

The final is cumulative but wasn’t that difficult. Actually, none of this class was very difficult, but I’m calling it hard because the terrible grading makes it harder and more stressful than it needs to be. It’s a shame because these are really interesting topics and this class completely ruins the joy. I’m so glad to be able to put this behind me. Good luck to the repeaters.

I loved this class. The lectures were great, the subject matter was fascinating and the TAs were helpful.

Difficulty is highly dependent on preparation and mathematical aptitude. In particular, it relates to how ready you are to come up with solutions to book problems. I personally found GIOS’s subject matter harder and workload higher (though that class was just as great). This class has a much higher potential for stress though. As an example, after the first exam I got a 45% while the project and homework en route to exam 2 were underway. I was concerned a C might be difficult to obtain and considered dropping. Luckily, I ended up with an A at the end.

My advice beyond what the other reviews have mentioned:

1) Success in this class depends highly on the ability to do book problems in an exam setting. Keep doing them until you’re comfortable solving new problems without using external resources while simulating proctoring

2) Persistence pays off – see paragraph above

3) If you learn algorithms by implementing them (besides the project), do so BEFORE the start of the class. For every successful implementation, who knows how many book problems you could have solved instead. If you do want to implement, personally recommend the UCSD courses on Coursera, as many of them use the same book

4) The main concepts to understand are smaller versions of the same problem (Dynamic Programming, Divide and Conquer), graphs (Connected Components, Shortest Paths, MST, Max Flow) and reductions to a different algorithm (NP and LP). RSA was also covered

5) I found it less stressful as a second class than I would have as my last class before graduation. The ideal timeframe (though possibly not realistic) is probably as a third to fifth class, when the foundational requirements have been satisfied but it’s still possible to switch specializations without having to take extra classes just in case

6) Despite the lower workload, the stress factor will make this class difficult for anyone with a full-time job to pair with another

7) Grading is usually lenient but can be inconsistent. The best bet is to be so prepared that your answers do not raise confusion or doubt about correctness in anyone’s mind

Tortures before a great sense of achievement

This is a review of CS6515.

The course design is the most brutal, so to speak, I’ve seen in OMSCS: 4 closed-book ProctorTracked exams account for about 85% of the total grades. If you mess up 1 exam, you can still hope for an A; if you mess up 2 exams, you’d better just aim at getting a B; if you mess up 3 exams, better get prepared to retake the course in the next semester. With that said, I still managed to get an A :). You might experience lots of pain in the beginning and start to realize that you really need to work diligently to survive the course. This isn’t a course which you can simply put together fancy words in a report and get a thumbs-up. All the following is necessary: practices besides homework, reading the corresponding chapters in the textbook (DPV) every week, and watching course videos over and over again till you understand what Prof talks about. With that said, I enjoyed the slightly painful journey and luckily got an A eventually.

I personally don’t find the mathematical reasoning and proofs too difficult, because I come from a mathematics background in college. To me, Dynamic Programming is nothing fancy but Mathematical Induction; D&C and LP are free perks to boost your exam score; Graph Algorithms are simply a downgraded version of Discrete Mathematics; RSA is Chapter 1 (okay.. maybe Chapter 3) of a Number Theory textbook.

I spent 3~5 hours per week to take very detailed+readable notes while watching the Udacity lectures (oh man I enjoyed the professor’s comforting voice). Then I spent another 8 hours or so every time when an exam approaches on practicing on exercise problems in the required textbook (DPV). Once you find yourself comfortable with most exercises, the exam problems shouldn’t look too distant from your daily exercises.

Besides algo design and NP-Completeness proof, the following topics are also important: How to draw a reverse/residual directed graph and label the edges with relevant numerics; How to do FFT and reverse-FFT; How to perform polynomial multiplication with D&C; How to use Master’s Theorem to calculate Big-O notation; How to calculate optimum with LP and Dual-LP; How to properly use the theorems in RSA module, etc. One needs to be very knowledgable about details of the concepts/algo iterations/equations/theorems/corollaries.

Big Shout out to Prof. Vigoda for his thorough elaboration on the algorithms. He did a great job of explaining everything about all major algos in proper English wording. One can tell dude knows what he’s doing LOL…

CS-6515 for Spring 2019 review

I’m about to start job-hunting and this course has helped me prepare for the white-boarding aspect. I earned an 83% in the course which was painfully close to the A cutoff. I worked my butt off. I performed best on exams where I took written notes and and knew how to answer every homework question. I only completed about 40% of the homeworks, and might otherwise have earned that shiny A! I did, however, work through every single suggested and assigned problem prior to the exams and highly recommend that you do the same.

The lectures are straightforward and the topics are explained thoroughly. Whenever I couldn’t nail down a topic, I referred to the required text or one of the other recommended texts. I would say I only completed about 10% of the recommended reading for the course.

The PageRank project was fun to work on and was not overly challenging. It did a good job of conveying nuances of the topic, and I felt supported by the TAs while working through it.

The tests are not easy. The problems resemble some of the questions you may have seen but going rote won’t get you through every aspect. I suffered a lot of anxiety leading up to the exams because each has such a high impact on your grade, but this is a math class, and it’s online so I think this is the best way to assess our progress.

My only complaint about this class was the amount of noise on Piazza. There was so much whining and complaining and griping about grades that it was hard to find useful conversations about specific homework problems. Yes, online proctoring is a pain but there are some things you can do ahead of time to make your set-up more conducive to focusing on the exam. I can’t tell you how many students took to Piazza to complain about being proctored without offering any reasonable suggestions for alternatives! Piazza for this class just made me anxious and I worked through the course without it. With a large number of students, I don’t know know the TAs could have managed that better without making some already edgy students extra cranky.

I probably could have devoted about 60% as much time as I did to this class and still landed in that curved B threshold. oh well!

Challenging course though it’s a little overstated at times. The key to this course is practice problems. Unfortunately, you have to do a lot of googling to find practice problems with solutions as the textbook does not have solutions. Great book and great lectures. I recommend working over the practice problems and homework multiple times before the tests (you will be given the solutions). If you do that and understand the solutions you should do fine on the tests. I also recommend watching other lectures on the subjects as it helped me to see the topics presented by different people. Plenty of lectures available on YouTube. I wouldn’t take this course with another course unless you are already solid on algorithms, specifically Dynamic Programming, Graph Theory and NP-Completeness as those make up the bulk of the course. This class hits hard and fast and peaks around the time the project is due. After that it’s a little less daunting. Good luck!

This course has an unfair reputation. Yss, it’s hard, but it’s extremely fair. Grading policies are transparent, the TAs do a tremendous job turning scores around, and the exams cover exactly what you expect – and are often based upon sample questions at the end of the chapters. Why do so many people complain? Some thoughts:

For many, the material is new – theoretical computer science is not something you just teach yourself as you’re trying to become the company’s Visual Basic “developer” by watching a few you tube videos.

You can not get an A in this class just by putting in the right number of hours. You have to practice, absorb the concepts, and learn to see the patterns and relationships necessary to do well on timed exams.

Piazza is full of angst – for many this is their last class, they’ve dreaded taking it and have put it off, and now they need a B to graduate. The pressure this generates during the exams is insurmountable for some.

The worst part of it, for me, was the endless pleading for the grading rubric to change, for extra credit, for adjustments to the curve. I call it the curse of the Millennial Snowflakes, who expect to “earn” an A just by doing the required things rather then demonstrating proficiency in the actual content.

This is Georgia Tech, not Kaplan. If you want a Master’s from a top-10 program you need to earn it. This class ensures that you do.

Writing this review for CS6515 in Spring 2019.

This class is very difficult. I’d been dreading this class since I started this program 3 years ago, especially since algorithms has always been something that I’ve struggled with. However, the reason I’m writing this review, my first and last review of any class in the program, is to tell people that you can be successful and pass this class.

There were 8 homework assignments, pretty much every week except for spring break and exam weeks. All of the homeworks had a few suggested practice problems listed, and then 2 graded problems, usually from the textbook. The homeworks weren’t overly difficult, but they were important for solidifying your knowledge of the material. Homeworks were worth a total of 5% of your overall grade, so they were really there just to make sure you were keeping up with the material. There was one project on the PageRank algorithm, which didn’t take a whole lot of time, and was worth 10% of your overall grade. The vast majority of people got a 100% on the project. Generally, I spent about 4-8 hours on a non-exam week between watching the lectures and completing the assignments.

Finally, the exams. There were 3 exams worth 20% each, and a final worth 25%. I understand that in previous semesters there were 3 exams instead of 4. Personally, I think I prefer 4 exams because it allowed you to really hone in on less material, even if it meant that you had to go more in-depth on certain topics. The first exam was on Dynamic Programming and Divide and Conquer, second exam on Graph Algorithms (DFS, BFS, Dijkstra’s, Strongly Connected Components, Max-Flow, etc.), third exam on Linear Programming and NP reductions, and the final exam was cumulative.

My strategy for exam was studying was as follows. For the first 3 exams, I started studying about a week before the exam, and for the final about 2 weeks before. I would rewatch every relevant lecture at 2x speed, while redoing the quizzes in the lectures also. Once I finished that, I would read through the textbook chapters again just for more review. Finally, I would do every possible practice problem in the book that was relevant to the material. I can’t emphasize enough how important this is. Practice, practice, practice. If you can complete pretty much every relevant practice problem in the book, and really understand the solution, then you will do fine in this class. That would honestly be my biggest piece of advice: do as many practice problems as you can. I studied as much as I possibly could during exam weeks, so 3-6 hours every night.

This is a well-taught class, and pretty organized. TAs were quick to respond, there was a great Slack channel and active Piazza presence. Grading turnaround was generally pretty quick – about a week or less for most of the exams. Unlike some of the other reviews on here, I personally did not find the grading to be overly harsh. I felt that if you showed a good understanding of the question and your solution was solid, then you would get full credit. Sure I got dinged here and there for minor mistakes, but for the most part the grading and exams were very fair in my opinion.

This class is a marathon. There are very few breaks, and you have to stay focused and motivated the entire time. It’s not easy, but it is absolutely doable. Study hard for every test. Make sure you really understand the material. This class is like a “rite of passage” for OMSCS. It’s a tough one, but you can do it. Algorithms has always been something I’ve struggled with, but I worked incredibly hard this semester, and I can say that I finally feel comfortable with the material. This was my last class, and by the far the hardest I have ever taken at OMSCS, but also the most rewarding at the end. You CAN do it. Good luck!

Note: This course is now known as CS6515. Using the old 8803GA as there’s no CS6515 course entry as of today. The content is identical between the two courses.

What a ride! The contents of this course are absolutely amazing and awesome. I have learned an unbelievable amount of material in a relatively short period of time. Not being a good test taker, I struggled mightily in the first half of the course - I ended up with an average of 50% on the first 2 exams! Then I reevaluated my study habits and managed to pull up my grades to clear a B, which probably shortened my lifespan by 5 years or so because of the stress.

The material is actually not too difficult and quite intuitive from just watching the lecture videos alone, but the exams are tough in that there’s the special element of handwriting and scanning, and the added surveillance requirements added in the middle of the semester to combat cheating. It’s hard not to stare at the countdown clock and also to the camera to make sure you’re still within view of ProctorTrack (point penalties were levied on many individuals for not following the very strict and detailed monitoring requirements done in no other course in OMSCS).

The exams were graded quite harshly in my opinion (whereas the homeworks were graded very leniently which provided a false sense of accomplishment and understanding of the material). Given the low number of questions on the exam and the tendency not to award partial credit commensurate with progress made on a problem, a mistake could very well cost you a significant portion of your grade. Miss a major item or blank out on a DP problem? Boom - now your grade maxes out at 66%. The grading appears to have become more lenient starting with exam #3 (either that, or my improvements in studying were paying off more than I realize).

This semester’s cutoff for a B was just published at 67%, which was higher than the one established for the previous semester. This means 40-50 students who stayed through the entire semester may have to retake the class, which is pretty daunting compared to other classes.

Algorithms is hard. What you get out depends on what you put in, but it could be run a bit better and students would get more out of it. The professor this term was Gerandy Brito, and he commented probably every week, though mainly on class policies.

The class is reasonably well run, and grades are returned very fast. TA quality varies from excellent to huh? Unfortunately, most TAs are not prepared for their office hours. You will find out quickly who to pay attention to.

There were 8 homeworks that all together were 5% of the grade, but you better know that stuff cold. The one project was doable, fun, and required a very specific paper. The TA in charge of the project was bloody phenomenal. I did all the HW fine except #5 which was due the same day as the project. That’s silly. One more day would have allowed me to do that HW, and no one was grading it that day. I did the missing HW before the test, BUT… I didn’t have all the parts my grader wanted, and maybe, just maybe, that migh have come out on the HW grade. But probably not, since the HW scores were highly optimistic, while the test grading was harsh.

The tests are the gist of this class. The tests are LONG, about 3 hours each to do roughly 3 problems and a page of MCs (about 5 each time). I worked hard the whole time in each one, and solved every problem, but never had time to look back, and that didn’t help my grade! Some things I would have caught, but uh well. I did fine on the first one, on DP. Do a ton of practice problems until you can do all the ordinary ones in a half hour or less, and this test will be OK. The second one, I repeatedly did problems correctly, but not knowing that a particular statement was required cost me at least 15 points. That hurt. I was taking another time consuming class (coding-wise, ML4T), and did not get started studying for the final in GA until a week before it. I put in about 25 hours, but that was nothing complared to people who only had one class and used 3 full weeks to study. By the time the final came around, I knew that only a miracle would get me an A, and it didn’t happen. I never looked back at my test.

I think we had the same graders all the time, I was not impressed with mine. Good luck all ye who enter here.

The class is terrific, knowledge-wise, but its hard to get ahold of some of the topics. The text is good, I had a cheap paperback and wrote all over it. By term end it all made sense. Watching a lot of MIT videos on same material helped, and a lot of DP problems done by Tushar Roy, and also I bought a used Corbin book, and that had a lot more specific info that really helped. Google problems for a variety of approaches. I really learned this stuff, but lack of prep time for the final brought me to a B.

This class is infamously rated as being a huge time sink and very hard. It is very hard, but compared to project oriented courses it is not that time consuming and there is zero busy work to do (i.e. you don’t have to write a reflection each week like KBAI). I would characterize this course as a mastery course, whereas most of the rest of the courses in OMSCS survey such a wide swath of topics that you end the class knowing some material but also knowing how much you still don’t know (ML and RL tests are notoriously difficult and if you get half the questions right you are likely to get an A). When you are done with this class you have internalized and fully demonstrated your understanding of several important and widely applicable algorithms and concepts.

I really enjoyed this course because

The material is useful and ubiquitous, and if you have never seen some of the material before it is elegant and fascinating

The lectures are concise, sometimes a little dry, but ultimately very well done. For example, the lectures on Linear Programming concisely explained all the rules to get problems into standard form in about five minutes and during my course on optimization in an Engineering program the same material filled two weeks of class time. Also the course textbook is insanely concise and fairly easy to read so you actually can and should read it all, maybe multiple times over.

You leave the course feeling a sense of mastery of the topics presented

That said, the tests are hard (but fair), the grading wasn’t always the most consistent, and the days leading up to each of three tests were more stressful than any other course I’ve taken in the program.

The most disappointing part of the course was a grading snafu where incorrect final grades were released and then corrected (lowered) after the regrade request period for the final had expired. I was one of the students that was shown an A that then got reduced to a B. In grand scheme of things, it doesn’t matter at all and I got the grade I earned, but it did sting a little bit to wake up to the Piazza note that “your A is actually a B because we messed up the weighting scheme for the final grade calculations”. This has been my only B in the program so far, so I was disappointed, but I enjoyed the course and respect the TA’s and the instructor immensely. I would strongly recommend to future grading teams, to just not release the final grades at all until they are triple checked and finalized.

While I love the OMSCS program - it’s hard to defend it and say it’s on par with the on-campus program when students struggle with a class that is basically a very easy class to pass (get a B or better).

What I mean by that is that I seriously don’t know how you can fail this class. You look at all these reviews and you think that Dynamic Programming is rocket surgery or something. It is…for loops…. with arrays to store information. That’s it.

For Dynamic programming, each exam is divided into 4 parts of equal value. You are given a problem that requires a for loop to solve. You solve it this way.

A) State the problem in words, (e.g. T[i,j] equals the maximum….”). That’s it. You get free points.

B) State the recursion. This is the “hard part”. You place the stuff in for loop in here. That’s it. Don’t forget the base case (e.g. the first loop iteration). Here’s where it gets tricky. If you need a loop in the loop, you use “for all”. If you need to compare with a previous value in the loop, you use max/min. And the trickiest part, sometimes, you have to include the current value (e.g. longest common subsequence problem(. That’s all there is to it. These are explained in the lecture. Just cross your t’s and dot your i’s, and you should be fine.

C) Write your algorithm in psuedocode. You know how to write two for loops and initialize a two-dimensional array, right?

D) Count the loops within loops and that is is your O(n) value. For example, if you loop over n, and within that loop, you loop over n, your big O notation is O(n^2). Free points.

I’m not sure why people are doing tons of Dynamic Programming problems when, for the purpose of this class, it’s just freakin’ for loops. And you do all of this in the homeworks already, so you know exactly what you have to put on the exam.

Looking at the DP problem above, you are guaranteed 10/20 points. And if you put something down, you’ll get decent partial credit. For example, there was one dynamic programming question that I did not know. I got 12 out of 20 even though I forgot the base case and messed up the return in the psuedocode. Now, let’s put this in perspective - you needed a 60% to pass. The homeworks and projects are free points (15% of your grade), so you really need like 53% to pass. In the exams, I plain did not know 3 questions, and my grades were 11/20, 12/20, and 14/20 for those question because I just threw up something that resembled the homework. You could literally pass this class and not get any real questions right in the exam.

Which makes me wonder how are people failing? Are they writing Walking Dead fan fiction instead of answering the question?

Other parts are easy - for the sake of brevity, I won’t go into details like DP. Divide and conquer is no more complex than something simple like quick sort. Linear Programming is basically follow the same simple steps you did in the homework, and on and on. FYI, make sure to memorize any formulas or major points in the slides for the multiple choice and true/false (yep, even though you need only 53% to pass, there’s still true and false questions).

I took my last algorithms class 20 years ago, so I should have put in more work than the average Joe. But anyone who has taken any sort of halfway decent algorithm course should have seen 80%-90% of this and have worked less. All the topics are pretty standard undergard fare. And sorry, If you have never heard of NP-complete, then you really have no business in a Master’s program.

In terms of time, homeworks should take you no more than a couple of hours (just look up the problem or a similar problem on stackexchange and put it as a reference). No need to bang your head on something to gain some “deep-seated knowledge” when you just need to learn the steps once so you can repeat the same steps on the exam. There’s only 8 homeworks BTW. The two midterms should take 5-10 hours each to study for, with the final exam taking 10. The project is actually really cool and I wish the whole class was like that instead of exam based. That took about 7-8 hours to do. In other words, I have no idea how anyone could possibly spend the 20-30 hours a week on this class.

One quick note. The first exam is the hardest, and there was no indication of a curve, (it was stated that you need a 65% to pass/get a B) so if someone got below the median, which was something like 65, it gave the impression that that person was failing, which caused a lot of people to drop unnecessarily.

All in all though, this class is dirt easy. I had no desire to really put in any effort into the class since it’s a requirement I cared so little about. I literally was too lazy and didn’t bother studying certain items that were not well presented (e.g. roots of unity, Linear Programming Duality), because I knew it was impossible to fail this class. Even with that, because of the generous curve at the end, I barely got an A.

It’s sad that this class is presented as some sort of Boogie man when it should be viewed as the lightest course around (it was my lightest course). No real programming, no complex math, simple tests that resemble the homeworks you were given. It’s about as straightforward as you can get.

This course covers some topics: dynamic programming, divide and conquer, graph algorithms, linear programming and NP complete. You may get ideas about exams and homeworks from other reviews, so I just want to share my experience. I did not have a CS undergraduate and was a bit hesitate to take the class this fall 2018. I would say I learned a lot in this class and ended up with A (higher end) before the curve. To understand the material, I read DPV book and practiced the problems in the end of each chapter in addition to assigned homeworks. I feel like there are some typical dynamic programming problems you may be asked in the exams. Tried to understand all dynamic programming problems in lectures and the exam questions are just sort of the variants. They can restate the questions in different context or words but the approach to the problem sounds more similar. Material about graph algorithms is straightforward but I found the graph algorithm problems/questions are bit tricky. For exams, if you can not come up with good/optimal solutions, just write what you think and you may get some partial scores. You should try to get full points from homeworks and the project. The project is easy however you should follow instructions very carefully: what results they expect you to show in the report. I had to change the result figures several times following the piazza comments and got 100%. The final exam covers all materials ~3hours. I reviewed all lecture notes and practiced DP more in leetcode and had to watch additional videos to understand linear programming and NP-complete. These topics are kind of confusing for me. Some classmates found the NP/NP complete lectures from MIT courseware useful and you can try to watch them. If you have time to prepare , you can start with data structures and algorithms on coursera or MIT courseware. If not, just try to practice as much as possible throughout the class, tackle topic by topic and do not screw up any exams. You should not expect the curve because the instructor can change the grade policy each semester.

This was a very hard class, but hard based on the way the class is run / the grading scheme.

Pros: The concepts aren’t particularly difficult, and they are interesting. It’s also nice to have a class where you are thinking a lot and sitting down working through problems on pen and paper. Most other classes in the program end up requiring hours in front of a computer coding (it is CS afterall!). Also, the TAs were very helpful for the most part, and tried to aid in the understanding of the material. And based on the way the class is run, you do learn the material in intimate detail. What I mean by that is…

Cons: The exams are worth 85% of the grade. For Fall 2018, there were two mid-terms and a cumulative final. The exams are graded strictly, and often with a bit over zestfully (word?) by the TAs. There was then vague guidance regarding requesting regrades that amounted to threats to take poitns away if the regrade wasn’t submitted with the right justification. The final was then worth 35% of the grade. Because of this, it was a make-or-break type of exam. I was in the same boat with a lot of people in that a B was required to pass and then graduate. The last few weeks leading up to the final were spent studying every waking minute… which led to a detailed understanding of the material. I ended up with a B (64, 77, and 79 on the respective tests), and there was a fairly generous curve in the end which helped a lot of people on the edge of a B/C.

Overall: You do learn a lot. Just expect to be stressed until the end in order to get the B needed in most OMSCS specialties to graduate. But to end on a high note, if you start off in the class and don’t do well on the first test or two, don’t give up! Keep studying hard and stick it out until the end. It is still likely you will get a B if you keep trying and show improvement over the semester. There is a light at the end of the tunnel and you CAN graduate (if it’s your last class)!

This course is difficult for non-CS background students. But if you’ve taken some algorithm classes in college, or you’re already good at LeetCode coding competitions, then this course is not difficult at all. Since math proofs has been removed, this course is basically the same as undergrad-level algorithm design and analysis, which is usually the 2nd algorithm course after the 1st one where students learn data structures / tree traversal / graph, etc.

The video lectures are great, the textbook is good, some interesting algorithms are covered, and the TAs get test grades back very quickly. At the end there was a 5% curve up to A and a 10% curve up to B if you need that sort of help. I had an A before the curve, but it was nice to see the instructors be generous at the end of a hard semester (where many people reported they were just below the original B cutoff).

This class is taught under a cloud of fear (since most students can’t graduate without it), so it’s hard to enjoy. It’s a theory course more applicable for students targeting a career in academia than the professional world. It’s the least practical course I’ve taken in OMSCS. It’s probably good for “interview questions”, but that hasn’t been a significant portion of my (long) career.

The exams are too heavily weighted (85%) relative to homework (5%). We had 15 problems total on 3 tests, so each test problem was worth 85/15th = 5.66% of our overall grade. So a single test problem (taken under closed book conditions) was worth more than the entire semester’s worth of homework (which took dozens of hours).

The course schedule was too front loaded. There was no homework the last 4 weeks, and no lessons the last 3 weeks. This semester was paced almost like a summer class, which makes me wonder why GA isn’t offered in the summer.

The instructors seemed very reluctant to ever endorse student answers on Piazza. According to the Piazza report, of the 313 student answers, only 41 (13%) were instructor endorsed. The other 87% of student answers were not all wrong; most were just ignored by the TAs.

Other thoughts:

• There were way too many threats about regrade request penalties after tests.
• Dynamic programming is way over-emphasized in this course relative to its real-world applicability.
• Having to scan hand-written documents and upload them during exams is kind of nerve-racking (but better than typing LaTeX).
• This was Dr. Brito’s first semester, and he’s the fourth algorithms instructor in 5 years (after Charlie Brubaker, Chris Pryby, and Eric Vigoda). So there’s not much stability in this course.

For those that want to take GA before your last class, this Reddit comment sums up my opinion: Let OMSCS take you out to dinner first before it f**ks you.

GA is not a undergraduate data structure and algorithms course. It already assumes basic familiarity with elementary graph algorithms like BFS/DFS, graph representations, etc. This is an algorithms course that will teach you algorithm design skills and will develop your thinking as a computer scientist. You will understand the broad algorithmic landscape, and how one island connects to another: E.g. linear programming <–> graphs. This sort of thinking is extremely valuable if your work involves algorithm design (mine does). Your investment in this course will return multifold. If you give it your best, you’ll transcend from merely following the latest algorithm-fashion-trends (e.g. deep learning) to actually being able to map business problems to CS concepts.

I did not enjoy this course, but I did learn a lot.

Major subjects of study: Dynamic Programming, Divide and Conquer, Modular Arithmetic, RSA, FFT, MST, SCCs, Max Flow, Linear Programming, NP-Complete Reductions.

Pros: <ul><li>The lectures were straightforward and solid; I would say they are some of the best lectures in the program.</li> <li>The general workload is very minimal; most of the homework can be completed pretty quickly and you can often wait until the last minute if you want to. </li><li>There is a pretty easy and straightforward project that is a nice buffer on your grade.</li> <li> You will probably learn the material pretty well (especially dynamic programming) if you study for the tests adequately, and do additional practice problems in the book. </li></ul>

Cons: <ul><li>This class is all about tests. The homework is collectively worth 5% of your grade, and the project is only 10% of your grade. Thus 85% of your grade comes from tests.</li><li>There are only 3 tests in the whole semester so each one carries a lot of weight.</li> <li>There are not that many questions on each test, so you are penalized heavily if you get stuck on or did not read the directions carefully enough for a problem. The tests require some cleverness, and even though the answers are usually pretty straightforward, you can trick yourself into overthinking it. Once you start thinking the wrong way about a problem it’s hard to get out of that way of thinking without getting up to take a walk, which you obviously can’t do during a test. Seeing the timer tick down, and having the responsibility to stop in time so you can scan your answers does not help. </li> <li> Directions on the homework and tests were at times insufficient, and they will penalize you for not following directions that were not explicitly stated.</li><li>There is no curve (at least that I know of)</li><li>Before the final (which is cumulative), they give you 3 weeks of studying without much of a peep or any work, so it can be stressful trying to manage your time effectively.</li><li> It’s hard to escape the feeling of dark cloud of impending doom looming over you the entire semester. </li><li>I was borderline between an A and a B pretty much the entire semester, but after some mistakes on the final, I will not get an A in the class. This was my 8th class, and the first class I was not able to receive an A. </li></ul>

Update: They curved the grade at the end, and I was able to score an A just barely after all! Still quite a stressful class, but I think it is definitely worth taking.

This class provided a broad overview of different algorithms and a deep dive into several interesting topics. The lectures were well done and the TA’s we helpful. The project was a little weird and didn’t seem to fit in with the rest of the course, but the exams were very fair. I spent about a week preparing for each exam and I felt like it effectively tested my understanding of the concepts. The only complaint was that it was very front-loaded. I spent the last month of the class feeling disengaged and not very involved. On the other hand, I spend the first few weeks of the class trying to keep up with the amount of concepts I had to learn. A more even distribution of the workload would have made this class much more manageable and enjoyable.

This was my first course in OMSCS program. I enrolled for this course, knowing it’d be difficult and that I needed to spend ample time on it, in order to grasp the material. I never had a formal intro to under-grad level algorithms prior to enrolling in this course.

The course covers in depth algorithms, ranging from Dynamic Programming, Divide and Conquer, Graph algorithms, Linear programming, NP complete algorithms, various reductions to prove NP complete algorithms. This is a great course to develop algorithmic thinking, which may help you in technical interviews. And you only need to write pseudo-code, use algorithms as a black-box to solve specific problems and perform analysis of algorithms. So no coding except on the project. You only need to write less than 100 lines of code (take this with a grain of salt, I gave the number just as an idea) in total for the course

I spent a lot of time playing catch up. For example, I didn’t know how graphs are represented, basic algorithms for graph traversal/exploration, finding shortest path using Dijkstra’s, Bellman-Ford algorithm etc. So, if you’re in the same boat as me and are really interested in taking the course, I’d suggest taking only this course, and maybe even starting ahead with dynamic programming and revising graphs.

There was one project which consisted 10% of the grade. I roughly spent about 13-15 hours on this. If you spend enough time on it, you should be able to ace it an get the entire 10% of the grade. We had roughly 1 homework assignment per week. They account for an insignificant portion of the grade (5%), but are strongly recommended to do as practice problems for the exams. The problems you’ll see in the exams are very similar to HW problems. The only change I’d like to see in the course is to have one more mid term (total 3 mid terms and one final). Due to weight-age of the exams, if one screws up a mid term, then they may be looking at a lower grade.

Finally, a special shout out to the TA’s for this course in Fall 2018. They were very helpful answering all the questions in Piazza and slack. Very diligent in grading the assignments and mid-terms. The course had close to 450 (prior to withdrawal date) students. The turn around time for grading the projects and the mid terms (both mid terms were prior to withdrawal date) was just one week.

All in all, a fantastic course, great learning, helpful students and TA’s. I really developed a new way to approaching problems, in general. Grade doesn’t matter, learning does! So I’m satisfied and would absolutely recommend this course to anyone. Just prepare yourself for spending ample time and learning :)

This course is hard there is no doubt about it. I would recommend taking this course in the middle or in the end of the program. I took this in the middle of the program for me this was a make it or break it for continuing in the degree. I pulled an A through the skin of my teeth.

Find a study group make new friends. I had a few friends I would study with just for this course and I highly recommend it. Do the practise problems, if you like more theoretical work this is a really great course.

I personally like this course a lot and am considering going into a PHD program just to work more on this time of topics.

Create a schedule everyweek on how you will study and complete this course. Do NOT take this course with another course it will be exhausting.

The material is pretty good (although hard for some people) and valuable to learn, and most of it is presented fairly well. The problem is that the attitude of the professor towards students who don’t think and work his way ruins parts of the class and ruins the experience in general. Dr. Vigoda forces you to work with pen and paper, including on all four exams, and scan your handwritten work in to submit. He is openly hostile against writing code or using code to understand algorithms. He considers projects to be “bonus points” despite them being a required part of your grade and not bonus at all. What could have been a great class to replace CCA turns into a painful experience of antagonism towards students who are used to using computers and writing code to learn, understand, and solve problems. Almost the entire grade is based on handwritten exams. Despite this being CS in the 21st century you will do everything on paper, even ProctorTrack isn’t used the normal way, it just records you handwriting your exam and scanning it at the end. If you want a good grade you need to do all of the practice problems and read beyond the assigned reading, don’t stop at what was assigned and don’t do just the homework problems, do them all. Also be warned that perfection is expected and the slightest mistake will be heavily penalized. I personally found most of the material to be straightforward and not too difficult but I found the class overall to be obnoxiously obtuse and very hard as a result of the attitude and antiquated teaching methods.

Easy and extremely well taught class and should be taken as one of your first courses in OMSCS because it is the foundation upon which almost all other classes build on within the ML specialization. It goes into a little more depth in advanced algos topics that you would not have covered in undergrad without being overwhelming with the Math. Extremely fair exams and grading. Highly recommend! This is one of the best and fair classes in the program and is essential if you plan to interview for software engineer roles.

My only peeve are the people who come with poor CS background having never taken Data Structures or Algos in OMSCS and then complain about this class on piazza. These people should never have been admitted into the program. Ignore their whining.

One of the more difficult classes in the OMSCS programming. Light on the programming but heavy on the math. Be sure to practice the material a lot before taking this class. The questions are very similar to the book and class material but require a lot of practice. The topics may be somewhat useful to the job but is definitely more oriented towards learning for learning’s sake.

I actually really liked this class. There is a fair amount of work involved but it is manageable. The math was never overwhelming, and our arguments aren’t required to be excessively rigorous as long as they are valid.

I am very excited that I now understand things like linear programing, max flow, the fast Fourier transform and RSA pretty well: all these seemed completely mysterious to me before I took this class but they all turned out to be pretty easy to understand from the lectures.

The format of the exams and assignments is a pretty weird: you are given a template that you need to print, fill out and scan (there are phone apps to do that). Technically for the assignments you can just edit the LaTeX but for the exams you do have to scan your filled out template while being filmed by ProctorTrack… Weird.

Also be aware that there are a lot of exams (3 “midterms” and 1 final) and that the assignments and projects count for very little (5% for the assignments, 15% for the project).

One criticism however: especially at the beginning of the class, I ended up needing to do a lot of regrade requests for my assignments and first exam which I felt were graded incorrectly harshly. Out of 4 regrade requests I did, 3 got accepted, which shows that there was indeed some excessively zealous grading going on. Things got better as the class went on, but if you take this class, do check your feedback carefully and don’t hesitate to request regrades if something seems way wrong.

It is a tough class, but is well worth the effort since you will learn concept that help you in almost every other course that’s math heavy. I highly recommend taking this as your first or second course.

As noted by other reviewers, it takes Practice, Practice, Practice! Do all the homework and practice problems and additionally, the DPV textbook has a ton of practice problems and you can find more from other sources.

So, this class was pretty hard for me. I had next to zero algorithms background, but the topic is everywhere in CS and I wanted to fill in a lot of knowledge gaps by taking a supposedly-more-practical-than-CCA algorithms class, and I got it here. There were 3 exams and a final, 1 project, and homework. Exams were about the same level of difficulty as the homework, so the best advice I could give is to practice doing problems a lot, especially with Dynamic Programming and NP-completeness reductions. If you want an A in this class, you will work for it - exams are regularly 4/5 problems worth 25/20% each, so if you mess one up, there goes your grade.

TAs are really responsive, and the lectures are very well done. I found them exceptionally clear if you pay attention, and more straightforward than textbooks in terms of the explanations on average, but not always (compared to Dasgupta and CLRS). The class was exceptionally well run, and this was probably the biggest factor in my passing at all - homework and exam solutions (though not the final exam) were released the day after the submission window was closed, so you can figure out where the differences were, and learn from your mistakes immediately. There were office hours all the time, though I didn’t attend them regularly.

If you’re wondering whether or not to take this, I’m going to recommend it highly. It’s hard and time consuming, but it’ll enhance your experience in other courses. For example: my section of Reinforcement Learning used Linear Programming and Dynamic Programming throughout the semester, and my (admittedly old) Computer Networks section had a Bellman-Ford project. All of these topics are covered in depth in GA, and will probably be significantly easier with prior exposure to them. It’s hard to get in because all but one degree specializations currently require it, but keep at it and you’ll be glad you did.

Prof Vigoda is definitely a great lecturer. Excellent content covered in this course. This course will prepare you for some of the most important algorithms you need to know in a software engineering interview. Exams are pretty easy. Important note - do all HW problems (don’t slack) and try to solve as many problems at the end of each chapter as possible. To be honest, I was expecting the exams to be more vigorous in a graduate level algorithm course.

I absolutely loved this course. My favorite course ever by miles. The material was fabulous, the structure of the course was excellent, the organization was immaculate. Kudos to Professor Vigoda and the TAs.

I didn’t find it all that difficult although I seemed to be in the minority on that opinion. I wish there were a sequel because it left me wanting more.

There are 4 timed proctored exams and they are 85% of your grade. To prepare, get the “Algorithms” Dasgupta book and do all the exercises at the end of the chapters. The exams are problem solving questions similar to those. All chapters are covered by the course except the last 2. I also found the CLR book useful at times as supplement.

The most important thing to do in advance in terms of preparation for the course is to become skilled at Dynamic Programming. The first exam comes fast, and many students get such a devastatingly low score due to inability to solve the DP problems that they can never recover.

The partial credit on exams is generous – too generous maybe – so whatever happens, make sure to write something.

This course ought to be required for every specialization. It is the #1 must take course in the program. I can’t imagine how anyone could really call themselves an MSCS without it!

GA is definitely the best OMSCS course along with ML / RL, all because of the tremendous efforts from prof. Vigoda and his TA.

Difficulty is just right. Exam questions could have been alot more difficult, but prof. Vigoda gauged it perfectly so that they are very manageable.

By far the best OMSCS class I took. Dr. Vigoda’s lectures were engaging, thorough, and provocative. The material is difficult and the tests are hard, but everything is presented in such a clear way (and the grading is fair with a generous curve) that the class isn’t overly difficult. This class prepared me in ways that I didn’t think were possible and completely changed my mind on the benefits of the OMSCS program.

I believe the difficulty of this class is very much related to your preparedness. I generally enjoy math and also took an algos class on Coursera a couple years ago, and I thought the course was highly enjoyable and not too difficult. If you are in a similar boat, you probably won’t have much trouble with this course. On the other hand, if this is your first exposure to algorithms, I would highly recommend priming yourself for this course by taking a free algos class first, or you may find this course to be a lot of work.

Another key to this class is simply to practice a lot. A lot of the homeworks and exams come down to figuring out ways to apply the algos to a novel problem, sort of like puzzles where the algos are the tools you have to work with. Once you are in this mindset, though, it’s pretty fun thinking of ways to solve the problems.

One last note about this course is that the instructional staff is excellent. Compared to other courses I’ve taken, Dr. Vigoda is much more active on Piazza. Probably the second-most instructor participation of any course after SDP. Dr. Vigoda was very occasionally a bit snippy here and there, but I’d rather have massive presence with occasional errors than a total lack of presence which seems to be the norm (or at least the median) for OMSCS courses. There were also several TAs that were also active and helpful, more than any other class I’ve taken. Grading for all homeworks and exams took less than one week (though the project took over a month) which is critically important from a pedagogical standpoint, yet virtually unheard of in this program, so major kudos to the staff in this regards.

Keys to success follow the review…

Review: The material for this course is pertinent and important. This is a difficult class that is challenging in two ways. First, the material is difficult to learn and takes some time to fully understand. The book and lectures do a terrible job of explaining the material (the book is vague and the lectures focus primarily on mathematically proving the theorems behind the material rather than the testable material itself).

The second part of the challenge in this course is the way the exams and homework are graded. The rubric calls on strict adherence to very specific terminology, formatting, and nitpicks minor details. This can be frustrating because even with a mastery of the material and after solving difficult questions, you may receive a substantial markdown for trivial “omissions” in your solution.

As you go through this course, I would encourage you to stick with it even if you’re receiving poor grades. I did very poorly on the first two exams and still managed to pull through. The very first test is the trickiest… it gets a little bit easier after that. Grades are curved pretty significantly too. Worst case, at least you’ll get to see all of the material before taking the class a second time, so you’ll be better prepared the next round.

Keys to success: -Take this class by itself, it’s really tough -Practice problems from the text book and homework on a whiteboard or on paper over and over again. -If you have time before the course starts, brush up on Dynamic Programming (DP)… it is the most heavily weighted topic that takes the most time to master. -In regards to DP: focus your efforts on variations of LIS, LCS, and Knapsack type problems… there’s no need to get more complicated than that -Pay very close attention to the details of the professor’s solutions (such as HW solutions) and make your solutions follow his particular format and verbiage -Don’t blow off the project: it’s free points… it only takes a couple days to tackle & it’ll be in python most likely. -Youtube videos with graphical depictions of the algorithms in action really help

I wish you the very best of luck!!

An absolute must. Don’t call yourself a computer scientist if you haven’t taken this class. It’s about solving problems, efficiently. And it’s what interviewers ask about.

• Lectures are very clear and indepth. Didn’t need the book. Also any prereqs are covered in the lectures, except for graph theory. If you’re dying to prep before the course starts, maybe Graph Theory and BFS.Dijkstra are a good idea. Other than that I don;t see a reason to start early. Go into this class with a clear mind cause you’re gonna think and study A LOT.
• Exams are fair. Not easy, and not impossible. Just the right balance to test how well you understand the material, and can apply it to new problems.
• AWESOME staff. Professor is very active on Piazza, he is a true educator that cares about his students. Same with TAs who held 3 office hours per weekto answer HW questions, and any otherproblems from the book…etc.
• HWs, althoughof very low weight are extremely important. As well as practicing on your own with extra problems from the book or anywhere else. Practice is key here. You gotta train your brain on these kinds of problems. Don’t be disappointed if you can’t solve any of the Dynamic Programming problems. Just make sure you practice enough, and you’ll be fine.
• There was a coding project. It was very easy and not much of a learning opportunity. There’s room for improvement here.
• 3 midterms and a final. Midterms are not cumulative, so you can dive deep and practice specific topics as much as you want.
• This class is a marathon run. There a re no dull moments. Every week you’ll either be busy working on a HW or prepping for an exam. That’s why try not to burn yourself by prepping too much before the semester starts.

Bottom line. This is the best run class in OMSCS. And one of the most important to take. Can’t believe there’s a specialization (Interactive Intelligence) that doesn’t mandate this course.

This is THE class to take in this program. Perhaps the best one! Course structure is unique and heavily based on exams (85% of grade from exams. Only 5% from homeworks and 10% from project)

Lectures are super useful and clear. However reading the book is a must to fully grasp the subject. I did well overall, however I attribute it to putting in effort to solve bunch of practice problems from text book. I can see someone who just relied on lectures, didn’t do much practice on problems, would have less chance to do well.

TAs are simply the best. There were 3 office hours per week where TAs would patiently answer all questions from students. A big thanks to them :)

Prof. Vigoda is very active and friendly on Piazza. He greatly cares about his subject and students.

This class is very hard, not because the material is difficult, but because to me it seemed very rushed. This was the only course I took this semester and I struggled to keep up with the amount of practice and preparation that was required.

If you are reading this review and hoping to prepare for the class, study DP, NP Reductions and Max-Flow as well as Min-Cut. These are the main topics you will be tested on. There are graph algorithms as well, but you will never be asked to find a shortest path or anything like that, you will need to know how the algorithm works and based on the problem presented you will need to identify whether or not the algorithm can be used to solve the problem.

The lectures in my opinion are only good if you read the book first, then watch them once as you take notes and then watch them again just for content. So in other words they are not as good as other OMSCS courses. If you plan on grasping the material just by looking at the lectures, you probably won’t because the lectures go quite fast and they only explain the basics of how to do the problems. A lot of times I also found myself going on YouTube to try to look at different explanations because I thought the explanations given were either not clear or just not good enough.

I suggest taking this course on its own and if you have a few classes left, perhaps a semester before you graduate so you can re-take it if you do not get a B.

I would also suggest to become a regular on Piazza and do all the homeworks even though they are not worth many points. Basically, if you know how to do the homework, you will have the needed knowledge to pass the test.

This class was very well taught. So, the material wasn’t too hard to grasp from the lectures, however it did require a lot of work in practice problems on top of the homework. Finally the one thing which I felt could be improved is the amount of feedback on exams and homework. The feedback was too brief to be of much use for improvement.

This is a hard class, it takes a lot of time to understand the material it’s very difficult. The entire grade is based upon exams, the exams average 4 questions and are difficult. Most people either love or hate this class and it depends on your background and understanding of the material prior to taking this class. It’s a requirement for graduation and the class it NP-HARD.

Great effort from the TA’s and Professor Vigoda. You’ll do well if you practice doing many problems, from both the textbook and other sources. Keep doing problems. You have to do many problems to truly understand the subject matter. Very rewarding class and the benefits are great for interviews later in life.

You can’t bullshit your way through this course, and that’s a good thing. So don’t try to, or you’ll crash and burn.

I’ve rated this as ‘hard’, but really its just quite different than the other classes in the program, more theoretical vs the project-based I’ve enjoyed in other classes. Thankfully, its not just a class full of proofs.

The instruction is clear, professor and TAs are responsive on Piazza, the exams are fair, and grading on assignments and exams was quick (and lenient). Perhaps this is easier for those who had algorithms as an undergrad, you but don’t need it to be successful in this class.

With the exception of the dynamic programming, homework only took a couple hours to complete. However, doing only the assigned problems was not enough for me to do well on the exams, I did most of the problems in the book and others I could find online as well. For me, workload was light most weeks, but spiked just before exams.

I don’t think theres a need to prepare in advance. I came in without a CS undergrad or advance prep and did well. But if you like to prep, get a head start with the dynamic programming – I found that the topic that took the longest to master.

Preface: I had not taken a formal algorithms course before. This class kicked me in the rear early. I very early considered dropping the course cause I did terribly on the first exam. However, I stuck through it and am expected to get an A now. I hadn’t taken the old CS 6505, but from what I’ve heard it was crazy difficult with its proofs. In this class, there is little to no emphasis on formal proofs. There is a bit of proving NP-completeness at the end of the course, but it’s not very rigorous I’d say. The key to the course: study, study, study. If you study as much as you can for this course, you’ll get a B or A. If you don’t put in the hours, you will likely not do well.

This was a hard class but nowhere near as hard as 6505. This should be manageable if you have time. My biggest issue was that I didn’t like the tests. You would have 4 questions and that was it. If you couldn’t figure out a question (Dynamic Programming, Graphs, NP complete, or Max-Flow) you were screwed. But, you don’t have a choice unless you do II for your specialization.

The TAs and Instructor are great and will help you as much as possible.

This course is one of my favorite courses. It is a nice mental stimulation. It is not easy but it is not too hard also. If you do the practice problems and the homework problems you will get a good grasp of the topics. There are plenty of more problems in the textbook as well. The professor,Eirc Vigoda, is very active and engaged in Piazza. The TAs were great. There are lots and lots of practice problems and office hours to help you prepare for the exam. I did very well on this course by simply studying using the practice problems provided and the textbook. For additional reference, I used the MIT OpenCourseWare lectures. Make sure you join the slack channel also.

This is a tough course. If you do not have ANY background in algorithms, mathematical notation, or informal proofs, you are going to struggle to play catch up.

There is very little programming, most of the algorithm work is done in pseudo-code. You can front load learning about Dynamic Programming, Divide and Conquer algorithms, and graphing algorithms.

This class and Machine Learning are the two best ran classes that I have taken in the program.

This course is very hard but also very deep. It covers algorithm design techniques such as dynamic programming, divide and conquer, linear programming, greedy algorithms, reduction, and np completeness.

The course is almost entirely graded on exams. That makes it extra difficult.

It requires that you spend serious time doing a lot of exercises so you get very good at things like dynamic programming. (I’d suggest you get the book and start doing those exercises now.. and keep practicing DAILY)

I like the course because it gave me a deep appreciation of graph algorithms that I had previously not cared for. If you put in HARD work you should survive. It won’t be easy.

This class was very well organized with great support from TAs and the prof. Even though some of the concepts were hard to undertand, the Udacity video was very well made and it was much better than other videos available in public. There are 3 mid terms and 1 final exam and you need to make sure you understand the concept well and study some extra problems on top of the homework assignments. Exams are not extremely hard but they were designed such that you need to use the concept you learned and apply to the problems that are similar but different from homework problems. i.e. just memorizing the answers will not work. The final was harder than mid terms in my opinion but you have a few weeks to prepare for it.

I really enjoyed this class but found it very easy. I’ve taken ML, AI, RL and all those were far more time consuming for me (more than 20hrs/w for those). If you have taken an undergrad class on dynamic programming, graph algorithms, and NP completeness, there isn’t a ton of new information, just more in depth. If algorithms and theory just make sense to you (I find I do much better in courses on math and theory than practice), then this course isn’t really that difficult. If you found your algorithms class difficult in undergrad, or have never taken one before, expect a rough ride (as you can see based on the other reviews). The homework questions were harder than the exam questions, so just be sure you can do the homework questions and you will do fine. None of the exam questions were out of the blue and were very reasonable given what the lectures and homework covered. All I did to study for the exams was practice the hw problems and I recieved >100% on the final grade. For this class just practice practice practice. No need to study useless trivia from the lectures (aside from complexity of common algorithms).

This was my 10th and final class in the program (I ended up with a B). As far as the difficulty, it was the hardest course I took, though I would say that the concepts themselves werent terribly difficult, more so that you need to stay on top of the schedule and practice practice practice with the exercises in the book and elsewhere. The arrangement of the topics (DP then Graph then P/NP) front loaded the difficulty somewhat so it wasnt too much for me to recover after not doing well on the first exam. For those worried about needing a B, the cutoff was 65% (84% for an A). And much kudos to Dr Vigoda, he is a great professor and made the class enjoyable.

I took this class for the first online offering. I really enjoyed the class and learned a ton. However, it was a huge amount of work. Working a full time job and a new child, all of my free time was spent on the course. During the first two weeks (Dynamic Programming), I was ready to drop the class but my wife convinced me otherwise. I’m glad I didn’t drop it. It took a ton of work in the beginning. Perhaps 30 hours a week doing sample problems and Dynamic Programming finally clicked. After Dynamic Programming and exam 1, we moved on to Graph Algorithms. This was a little easier for me since I have supported networks that run BFS/DFS and I had a working knowledge of some algorithms. Finally, NP-Complete and Linear Programming. This course definitely seems to be front loaded in difficulty. I would suggest you put as much effort as you can to learn dynamic programming. For many it is the toughest topic in the course. Once it clicks, you are set. So, work hard, don’t give up hope and good luck. I ended up with an A in the course but I was about to drop it during the second week. So, don’t be discouraged if DP takes you a long time to become efficient.

This was my 9th course in the program and this course is by far my favorite course of the program. It is my favorite because I find the content very useful and will definitely help you do well on software engineering interviews. Eric is a great professor and he is very active on Piazza. It also becomes addicting, because once you solve a problem it motivates you to solve another. If you want to prepare for the course, I will review Dynamic Programming, Big-O notation/Master Theorem, Basic Graph algorithms like DFS, BFS, Djikstra, etc, and NP. The course is very challenging and I liked that the homeworks are challenging you to prepare for the exam. If you understand the concepts behind the homework, you will do fine on the exam.

This class was both challenging and fun. It was extremely well presented and executed. The material is derived from an excellent textbook.

Unless you’ve recently taken an upper level algorithms course prior or have a recent and strong math background, you will probably have to work hard to do well. Some students could have used additional preparation before enrolling (e.g., their math background was extremely weak and hadn’t even encountered high school level calculus or discrete math). If you fall into that category, take a discrete math course or find some way to fill in those gaps.

My advice: don’t underestimate the importance of the homeworks and practice for the exams. Do all of the homeworks, all of the lectures, and stay current with the recommended course schedule (which can be demanding). If you find yourself having an idle week in this class, you’re likely doing it wrong.

Don’t let students who comment about “no formal proofs” deceive you. Usually, that “formality” is seen at the undergraduate level and you are expected to prove your claims on much of the material (and understand proofs given in the lectures). For example, having an intuitive understanding of induction helps with dynamic programming problems and when you get to NP complete problems, those are proofs. Either way, it’s not something to be afraid of but rather to embrace as part of your journey into the core of computer science.

This class is very hard in terms of lot of things. Firstly, what to expect in the exam, you never know. However much preparation you do for this class is going to be less. In all other courses, we will get to do the projects where we get 1-2 weeks of time where we can figure out what needs to happen. In this course, we need to figure out in 3 hours of exam time. The exams are similar to homework but home works are not easy either, But you will get a week to figure out for homework where as exams can be very tricky. The professor won’t ask any questions that does not make you think. He makes you think a lot during the course. The professor gives a lot of good hints on what to focus on during exam times. They are very very important. Pay close attention to what he says. He is very active on piazza and answers a lot of questions. The professor is very particular about dynamic programming. If you do well in this area, you will get A or B. Otherwise difficult to pass. He asks tough questions of Dynamic programming. It is his favorite part of the course. He initially scared the class saying that if we don’t do well n dynamic programming, we will not pass. That happened to be true. This class required at-least 30-40 hours of work for me. So, my advice is not take this class with any other course

The positive thing about the course is, the curve. The B cut-off was 65% and A cut-off was 84% for Fall 2017. Believe me, 65% is not easy to get.. But the curve really helps at the end of the course. The text book used for the course is DPV- Algorithms (Dasgupta + Papapi……..+Vazirani). Practice ALL problems from the exercise of this book to pass this course. This is a MUST. Good luck.

This was a very difficult class, and it took me a lot of time to really master the materials. Listening to the weekly lectures and taking notes alone took me about 10 to 15 hours per week because I had to rewatch them several times to fully understand the topics. Doing the homework took about 5 hours or more per week. And, I spent about 20 hours or more per week to work on extra problems and reading. And so, on average, this class took me about 35 to 40 hours of studying per week. Can you do with much less amount of time? Absolutely! But it depends on a few factors. First, it depends on your goal: are you okay with a B (I’m not; I want my A)? I know some students who spent 10 to 15 hours a week, but were struggling to get into the B range or were solidly in the B range. Second, it depends on your background: are you familiar with the topics already (I’m not) or are you the brilliant type (I’m not; I have to work hard to get my As)?

The exams were hard but fair. They weren’t tricky, but you absolutely need to be careful lest you’d make silly mistakes. But, from personal experience, and from what I gathered from Piazza, it was almost inevitable that people would make small mistakes, some of which had disproportionately large deductions, and so don’t kick yourself too hard when you do make those types of mistakes.

Take my review with a grain of salt. I’m the type who pushes myself very, very hard to fully master everything about anything, and I strive for the high scores in my classes, which I did in this class.

Ok, without too much lyrics here is what you need to do in order to succeed in this class:

Become good at dynamic programming! This one is the most important and the hardest. Learn how to solve typical most common problems like LIS, LCS etc. Get Dasgupta algorithms book and start solving DP problems (chapter 6). Learn how to write a recurrence and pseudocode for them using pencil and paper! Once you are comfortable - go to leetcode, or hackerrank and practice them as much as you can. Code them if you want, but keep in mind that you’d have to be able to HANDWRITE your solutions!

Learn about roots of unity in the context of Fast Fourier Transform. To be more precise - understand, how to multiply 2 integers using FFT Divide&Conquer approach. This one is also one of the most challenging topics. The lectures are good, but assuming you know the basics, which I didn’t, so I had to dig all over the internet to understand it.

(If you are good with 2 things above - you’ll most likely succeed. Other stuff is also important, but not as much as previous 2. You’d still have to practice all of it, but other topics a bit easier to grasp.)

Brush up on modular arithmetic, RSA cryptosystem and all the theory behind it.

Learn the basics of the graph theory: paths, flows, spanning trees, DFS, BFS, SCC, Djkstra etc.

Don’t worry too much about proving problems to be NP-complete, those are fairly straightforward, although, practicing wouldn’t hurt at all.

Practice linear programming problems, but only after you are good at 1 and 2 (or if 3rd exam is approaching).

Make sure you have enough time for the entire semester, and don’t hope for the last night preparation. It won’t work, unless you are already pro in all the topics above.

Do all the homeworks, and do them EARLY!!! They are hard, although worth almost nothing in terms of grade. Doing them is crucial for quality exam preparation, and if you don’t do them - you’re screwed!

Do not rush dropping the course if you screw up on the first exam. There will be plenty of opportunities to catch up, at last you can drop with W after the 2nd exam (if nothing changes next semesters).

The course is absolutely amazing, and it will develop your brain big time. The lectures are of the highest quality and very helpful. So, work hard, be optimistic, and good luck!

This class was one of the hardest I’ve taken in this program. It’s extremely exam based (85% of grade) and the concepts take a lot of time and practice to master. I spent a ton of time each week watching the lectures and doing practice problems in order to keep up with the course. For each exam I probably did 20-30 practice problems to prepare…and still didn’t perform as well as I would have hoped. The exams and homework are all handwritten. There is one project that was actually really fun. Overall this class was really good…like I learned a ton. But it is very difficult - I wouldn’t recommend pairing this class with another one. Oh, and the grade is curved significantly.

Excellent course and great professor Eric Vigoda. The video lectures are of high quality and clearly explained by the professor. The course is heavily exam based - 85% of score comes from 4 exams (this might change in future semesters), one programming project (10%), and home works (5%). The course also required you to read the text book (DPV mainly) and do the practice problems. Overall, course is not too hard if you have some CS knowledge (data structures, recursion, graphs etc). The focus is heavily on understanding the algorithms and applying them in new problems rather than memorizing algorithms. So it is very important to do as much practice problems as you can. Overall, this is the most rewarding course in this program!

This was my last class in the program and by far the hardest class I have taken. I needed it to finish up the ML specialization and found it to be a very different class from the others I have taken. There is very little actual programming (1 programming assignment this semester that was relatively easy and able to be completed with little code once the concept and problem is understood). The class focusses on theory and math and consists of HW assignments that are worth so little that they are practically optional and 4 tests. This model made it very easy to fall behind if you weren’t diligently studying and doing practice problems to prepare for the tests. Professor Vigoda is awesome. The videos are high quality and straight to the point. I liked that he explained concepts in what I found an easy to understand manner. He clearly tried to use simple language and provide multiple examples to drive points home. This class is a lot of work. I took this class along with DB Systems and I stuck it out but overall would recommend taking this class alone. Very rewarding and the staff was super responsive especially the professor. Class was run spectacularly especially considering it was the first semester. I learned so much the past few months that help to put other computer science topics in perspective.

Excellent professor (Dr. Vigoda) and TA team! The material itself is difficult but the work load for me was fairly light. The exams determine most of your grade but it is very important to do the homework in order to understand the material. Dynamic programming, graph algorithms, and NP Completeness consumed most of the class with a few other things such as FTT and RSA thrown in lightly. Memorization does very little good on the tests as they are all about the application of the concepts (i.e. use the algorithms from class to show how to solve this seemingly unrelated problem that you’ve never seen before). Understanding Big O notation is required. The book is also required for homework purposes and reading it is also important. Surprisingly well run for a first run course and surprisingly fast grading for a written exam based course. Test solutions are hand written and scanned while using Proctortrack.

All I can say is… never give up. There were so many times I wanted to quit because it was so difficult, but I persevered and I am pretty sure I did well enough on the final to pass. The homeworks seem almost impossible at times. However, don’t let that dissuade you. If you can’t do some of the problems just do the best you can (they are only worth 5% of the overall grade) and wait for the solutions to be released and then go back and learn how to do the problems. The exam questions are similar to the homeworks and actually seem a little easier than the homework problems. Professor Vigoda says he wants the HW to challenge you. So, if you can understand how to do them, you should be pretty well prepared for the exams. To prepare for this class, you can go to the course website to see the topics and watch some youtube videos on them. The MIT OCW videos were also helpful at times for a different perspective. Dr. Vigoda places a strong emphasis on Dynamic Programming. He once stated on the forums, if you don’t know DP you won’t pass this class. DP boggled my mind when I first encountered the topic. However, I leave the class relatively confident that I could apply it one day if necessary. The lecture videos are excellent, he repeats the information enough that it sinks in better than some courses where they just state the facts and immediately move on. I can’t believe I’m saying this after how difficult it was… but after it was all over I actually liked it. If it was easy, it wouldn’t have the same meaning or impart the same feeling of accomplishment and that’s why we’re at GaTech, right?

I dropped this class in spite of being very satisfied with the teaching. I dropped because I didn’t put enough time in doing the exercises as the class requires. Its not enough to be able to solve a few problems. One needs to have a lot of practice (as others pointed out). I don’t think this class requires too much time a week. Instead I would recommend daily practice. Caveat: my comments are as a person with a CS background. If you don’t have a CS background there’s probably some significant prep work you need to do in Algorithms and Data Structures to pass this class. It won’t be easy.

Excellent course, very well run especially for a new course. The lectures are great and the professor and TAs do a fantastic job. I recommend watching the lectures and reading the textbook. This is my 10th and final course before graduating, and while it isn’t as interesting content wise as some of the previous courses, it is one of the best run.

So I tried this in the fall and had to drop. It was tough material for me to grasp, and I needed a better game plan than what I’ve done for other classes. After retaking it this spring, I wound up with an A. Here’s how: So this spring when I took the class, I went in knowing that I needed to work on this class every day. So for the first month or so, I did at least 1 dynamic programming problem a day. And not just the ones they recommend - I did all of the ones in the DPV text, all of the ones in the Kleinberg-Tardos text. I also watched Erik Demaine’s lectures on dynamic programming. This is all in addition to the every day requirements of this class (the homework and lectures, etc). For dynamic programming - draw the damn table on your scratch paper. Every time…draw the table! When we got around to the NP Complete problems I did the same thing - at least one problem a day. The other topics were tough as well, but these 2 topics are the most crucial to passing this course. Anything he says in the lecture is a ‘key idea’ or ‘key concept’ is going to show up on a test. Even if you think, how could they possibly test that? Trust me, it’ll be on the exam. Also, watch the office hours. There’s a project (they choose a different project each semester), but it is not difficult and only worth 10% of the grade. The tests are the bulk of the grade (85%).

This course is very challenging. By far the most challenging class of the program for me (and this is my 9th course)

The content presentation is excellent. The homework, tests and project are all well constructed, fairly graded, and directly inline with the content covered in the course materials. However, it is not a simple regurgitation of the materials. It is an application of the materials and so you really have to understand and practice the use of the materials (the algorithms mostly) in solving problems because you will have to be able to apply them to other situations on the tests.

The grading is heavily weighted towards tests with 85% of the grade coming from tests (10% from project and 5% from homework).

Homework, while it has little impact on the grade is a must-do. In fact, to succeed in the class I would say that you have to go out and find other homework from other courses and do those problems as well.

The project was a coding assignment which was interesting but not too challenging once you wrapped your head around it. They have indicated that they may add an additional coding project in a future iteration of the course, but don’t plan on reducing the grading focus on exams.

This class has probably had the greatest participation in Piazza of both the instructor and the TA staff of any of the courses I have been in and that has been very helpful in understanding some of the nuances around the algorithms and their application.

Overall a great class.

• 8th class for me (Prev: ML, RL, CV, HPC, IOS, DVA, AI)
• Well Organized
• Awesome Content
• To the point exams, appropriate in length
• If you are planning to interview with a tech company, take this course
• Prof Vigoda and his team of TAs are very responsive and helpful
• Not esoteric theoretical
• Multiple (three) midterms, allows for smaller syllabus per exam, helps to dig deeper
• Do all of the text execises, not just the ones identified by the instructor, would help to reinforce concepts

This class is difficult, but not impossible. You definitely have to put in a lot of work, or you will fall behind! While the 10 homeworks are worth a total of 5% of your grade, don’t slack on them. They prepare you for the 3 midterms and 1 final which are the bulk of your grade. There is also a project for 10% of your grade, which is the only coding you will officially do in this class, though future iterations may include another project.

The homeworks are generally problems in the text (DPV), or very similar to them. While the previous class required a lot of proofs, this class requires informal proofs and pseudo-code. The book is definitely required, and I recommend also getting CLRS for the graphing section. The most math I encountered was during the FFT section where we had to work with complex numbers and roots of unity.

Prepare for this class by watching the lectures, reading DPV and doing the problems. There’s no real substitute for doing the problems. https://8803ga. wordpress. com

This class is really well done. The lectures are clear and interesting, and Dr Vigoda actively participates on Piazza! It’s hard, it’s theoretical (your brain gets tired), but it’s super-doable (even for someone with little to no formal background, like me).

I personally never manage to prepare for classes ahead of time; and I frankly think with this class, the best preparation you could do would be to come in with a clear head, excited and ready to learn. Once you’re in the midst of it, I recommend lots of practice problems and active participation on Piazza (trying to explain concepts to others or formulate clear questions is a great exercise in and of itself).

It’s an exam-based class, and the tests are challenging in that you likely haven’t seen the exact problems previously, but they’re very fair, and you can figure them out with a solid understanding of the material (as long as you don’t get too stressed about seeing something unfamiliar).

So, take it. You’ll be glad you did.

I am in the Fall 2017 class which is the first offering.

This class is the class that replaced CCA; do not be fooled, its not far easier than CCA. While there are mostly no formal proofs involved (although you will have to give informal proofs), there is still a ton of material and concepts. The math isn’t terrible, and everything you forgot is re-hashed by Dr. Vigoda so you can get back up to speed (although for graphs you will want to do a refresher on your own; otherwise this isnt needed).

To prep: I suggest going to the course website https://8803ga. wordpress. com/ and watching at least the first 2/3 of the lectures (the professor links to the videos on this page). I’d particularly suggest, at a minimum, getting re-acquainted with asymptotic notation and the basics of graphs (Depth-First Search, Breadth-First Search, Dijkstra’s algorithm, Prim’s algorithm, and basic graph terms are either lightly covered or not covered, depending, but you will need to know them),

The class is do-able, but be willing to prep OR be willing to spend 40 hour weeks on the course. If you are already comfortable with asymptotic notation and graph theory, Dynamic Programming (DP) and NP-Complete (NP) will take you the most amount of time, so if you have a good handle on those going in it will make life far easier. I would suggest being able to at least hold a light conversation in all of these topics; with no exposure to these, 80-100 hours spent on them before the class will surely pay off.

The fact that I hated this course isn’t a reflection on the professor (Dr. Vigoda) or TAs. They did an amazing job and were very active, I just hate theoretical math. This is a very hard class. If you are like me and 1) were not good in math theory and 2) have not done this sort of thing since college, then this will probably be really hard. I would recommend doing all the homework problems, and all the problems related to the material in the text book. When you are done with those, find another text book and do all the problems there. Practice is the only way you are going to pass, unless you are just really good at this sort of thing.

There is a project but it isn’t worth too much, though it took me a long time to complete. The homework problems are more or less meaningless for your grade, but very important if you want to learn the material. The exams are all closed book. You get partial credit, but that means you made smaller mistake, and you still lose a very large portion, so you really need to know the material. To be fair to Dr. Vigoda, he tells you what he expects you to know to pass, and he holds you to that. Grading is very quick on exams for the amount of students and the content in them. Office hours are very good too, and I had to watch almost all of them to get at least some grasp of the materials.

I would recommend taking this class early, but not before you get some study habits down. It took me 15 PTO days, and studying almost every night to get down most of this material. If I took this when I first started OMSCS (I have 24 credits as it stands) then I would have not been able to adjust to the workload and the amount of effort needed to pass. Also, it is probably going to suck. Many students did not do well on one or more exams (myself included), and though you will see the stereotypical “look at how smart I am!” tech students in piazza, remember that others are struggling as much as you are. Don’t drop too early, so that you at least get some of the material down, and plow through it.

This class was fun! I had a LOT of fun learning things, doing the problems, and reading through the materials. I learnt quite a bit, too. It’s a shame that this class is discontinued.

Fun class. Exams can be a bit tricky. Teaching staff was very involved and helpful. I learned a lot.

This was my first attempt at 6505. I actually signed up for the new Graduate Algorithm course which did not start. I have passed with a B and feel proud of myself for having made it through. It was by far the toughest course among the 6 courses in my last 4 semesters. I would not say it was Maths heavy but it does require brushing up some basics and keeping them handy for proofs/calculations throughout the course. Prof. Pryby’s youtube video lectures helped a lot during the initial part of the course. Video lectures on Udacity were dreadful. As the course progressed, I got a hang of things. Like others have stated, working on problem sets helped prepare for the exams. No matter how hard I prepared for all the 5 exams, I never felt confident before, after and during the exam, infact I always felt like I was going to fail. I somehow maintained 9s and 10s out of 15 throughout, which got me a B towards the end. It took me 4 tests to finally get a 5/5 on a question. I have to say that there were several moments where I felt like giving up, but I held on. I remember looking at the sample problem sets and exam questions before the course started; absolutely nothing made any sense. Just like everyone else, I too have learned a lot but at the same time I feel like there is so much I still don’t know :)

You will be on fire and in hell unless you have studied it before. But at the end, it is the most rewarding course of this program, for me.

Grades statistics for spring 2017: A: 25% B: 60% C: 11% D: 1% F: 3%

Don’t know how many dropped before midterm, but might be a lot as before.

A rich course. The instructor Chris Prypy cares about the students, which makes all the differences. The best way to prepare the exams is to study the problem sets.

This class was one of the most challenging, yet rewarding classes I’ve ever taken. I took an automata & complexity class in undergrad, but taking this class gave me a much greater appreciation for algorithms and the theory of computing. Despite its storied history and monstrous reputation, this class seems to have improved to the point of being one of the best classes in the program (I’ve taken 9 so far), so it’s a shame that it’s being replaced – hopefully Graduate Algorithms will be just as successful as this has been the past couple of semesters. This class was divided into three sections: algorithms (9 weeks, 3 exams), computability (3 weeks, 1 exam), complexity (3 weeks, 1 exam)

Some of the bad things were still there: the Udacity videos were largely useless; I dreaded having to watch these, and was thankful for the weeks that the instructor posted new videos on YouTube that aligned more with GA. I was also able to understand material much better by just reading Sipser and CLRS and watching MIT’s OpenCourseware and UC Davis’ equivalents of the material. Having problem sets assigned solely as preparation for the five exams (each worth 20%) was great. We could propose solutions on Piazza and have TA’s or the instructor Chris Pryby (who were fantastic, btw) respond and give us hints and feedback. Tests were difficult, but fair, and there were opportunities to make up for some lost points on previous exams. No doubt the material is hard and might take some students a few semesters to get an A or B (particularly ones that have never seen the material before), but this is one class that I would recommend to anyone seeking a Master’s degree in this program.

This is CS, not programming, which means it’s taught like a math course. If you’ve ever taken a math class at the undergraduate level (something above calculus/any rigorous, proof-based course past middle-school geometry), you’ll be fine. Get familiar with asymptotic notation and pseudocode syntax, and you’ll be just fine.

I have no formal CS background. I took one programming class in college, didn’t like it, and majored in math. Later, I learned VBA for consulting, picked up some Java, and got myself a Dev position. And this is my first OMSCS class. But because I’ve taken math courses before, I’ve averaged 14/15 on the first four exams.

For those unfamiliar with how math classes are taught in universities, here’s how they go: Claim: If [conditions], then [result] Proof: Suppose [blah]. Then [… ]. Therefore, the claim is true. Moving on, New Claim: [Stuff] Proof: [Other stuff] etc. You’ll get few examples per big concept, which means one or two per lecture. Expect to do most of the puzzling through the implications on your own, though the (ungraded) homeworks help put you in the right mindset and give you practice.

If you’ve never taken a math class at the university level, you’re going to start out at a loss. Prep. Learn the difference between an intuitive argument (It works for these three examples, so I’m pretty sure it should always work. Besides, it just makes sense, you know?) and a rigorous one (For all objects in this category, equipped with these attributes and arrows, the following holds: [Stuff]. Therefore, in all cases, [other stuff]). Learn induction, contradiction, infinite summation, and whatever else strikes your fancy.

Yes, the administrative decisions are capricious and inscrutable, the lectures have flaws, and the Piazza will be devoted to commiseration and scarce on productive advice. There are problems here. But with a little preparation, you’ll be just fine.

Theoretical class that gives a good overview of the most important algorithms. However it sometimes goes too far and we end up learning very unusefull things… It was not hard for me as I have a mathematical background

I prepared for this course in Summer 2016 and took the course in Fall 2016. I was caught off-guard as the topics were rearranged, and the first lessons were not what I had prepared for. I am also not very good at exams (hate time pressure!), and the term I took it the grade depended solely on exams. So this class really tested my limits. I got intimidated and lost confidence early on.

I planned to drop this class, and dropping deadline period then coincides with Exam 3. I thought I’d just give it one more push, study well and take Exam 3, then drop the course. Unfortunately (or fortunately?), I got too busy studying I did not notice the drop deadline has passed. :’( My grades for Exams 1 to 3 are really depressing, I thought I’d get a D.

My results for Exams 4 and 5 though are really good, almost looks like a different person took it. :p It was mainly because Exams 4 and 5 are within the scope I had prepared for during Summer, and that I did not attempt to answer the recovery questions giving me more time for the actual exam questions. That being said, yeah, preparations make a (huge!) difference.

I am a slow problem solver and it really takes me sometime for some concepts to make sense, so if you are like me, prepare before you actually enroll. And while taking the class, solve as many problems as you can so you can gain speed for the exams. 30 minutes per question is really not enough for me.

To give you a little bit of hope, I ended with a B (yey!).

This class was very challenging, and also my first class in the OMSCS program. In the end, I found it to be very rewarding and I learned a lot that I am currently finding useful in my class this semester.

It took me some time to find the best strategy to learn and do well in this class, and here are some methods I found to be the most useful:

• Following Piazza discussions about the problem sets
• Using VisuAlgo to help me understand graph theory: https://visualgo. net
• Reading outside resources (online) to get another perspective when I didn’t understand something
• Directly applying similar concepts/routines from the practice problems on the exams, rather than trying to solve the exam questions from scratch

Don’t kid yourself or think that you’re better than those who have gone before…. the average horror about this class is true, so don’t take it unless you are well prepared (recently) and have sufficient time to work on it. For me, it was basically every waking/free moment I could carve out… staying engaged with fellow students on the topics to help test and further reinforce my understanding was key. Don’t think that simply reading the text and watching the lecture will do it for you… treat everything like a project and don’t stop until you’ve mastered everything inside and out.

The new structure introduced in Fall ‘16 did help:

• The professor gave some good and pertinent lectures toward the beginning of the course
• The professor and TAs offered some helpful office hours to help with understanding the problems (ask ?’s so you don’t merely get a regurgitation of the text or the essence of the problem).
• The professor allowed/encouraged communication with fellow students on the topics (working problem sets was key)
• Outside resources were allowed for reference and to help build intuition when the lectures & text failed.
• “Re-take” questions were often offered on exams to try to improve on previous scores.

This is a tough, but rewarding class in that you get to graduate if you are among the hard-working group that get’s to pass it. I did on this second time through (prev’ spring ‘16). There are skills that I have definitely used since taking the course and this should also help in coding interviews for future job searches!

Don’t underestimate any topic until AFTER the exam! Just think: bootcamp that never seems to end!

I took this course on Fall 2016 where the passing rate was much higher. The class was definitely time consuming but you will be able to get an A or B if you invest sufficient time. Here are some tips:

• Get a good pencil and practice writing. We had 5 times exams. The exams were to be hand written, scanned and uploaded. There are some suggestions on the slack group.
• Start working on the problem sets as early as you can. The problem sets were much harder than what showed up on the actual tests.
• Make sure you are able to solve all the problem sets. Many times, the exam questions tended to be very similar to some of the problem set questions.
• Don’t feel bad if you are not able to solve the pre-requisite questions. I spent a lot of time preparing for the course, but was not able to solve most of the pre-requisite questions. However, I ended up doing quite well in the course.
• 5 tests actually made it easier as each week, we just had to master 3 different topics. There was no cumulative final.
• Join the slack group. You don’t need to be active, but do keep an eye out on the discussions. You will learn a lot here.
• Listen to all the office hours (good or bad).
• There are lot of external resources which are much better than the Udacity videos. Check the slack group for links (e. g. Harry Porter’s videos, MIT algo course, Stamford’s Roughgarden’s etc). You can go through the topics as they come up each week.

This is a really tough course, specially if you don’t have a strong background in algorithms and discrete math but if you like that kind of thing, this is for you. I had to put more hours in this course than any other I’ve taken but I was pretty motivated because I love that kind of stuff. In short if you are not into discrete math and set theory, maybe skip this if you can. Please notice I took it in Spring ‘15 so maybe things have changed by now.

One of the very hard and very useful courses in OMSCS. For those with limited background in Maths or theoretical computer science, this subject might be more than a handful. But at the end you end up learning a lot. The course structure and the grading was bit vague, but heard that this was rectified in further semesters. Sad to see this course go, as a I learnt a whole lot here, though suffered as much for it as well.

Background: I majored in CS and Math as an undergrad. My undergrad work was heavily theory based. I can’t imagine taking this course without that sort of background. I would heavily suggest self teaching some of the material beforehand.

There was a homework assigned each week, but not collected. Try your best on each problem and then look up the student answer on Piazza. This is probably the best approach to learning how to do these kind of problems.

There was an exam every 3 weeks (5 exams total) and these exams only covered the past three weeks of material plus we got a “retry” question from the previous exam. So each exam had one question for each week of material plus one optional retry question which covered a topic students did poorly on for the previous exam. I never did the retry question so that I could have more time to work on the required 3 problems for the exam. You have 2 hours for the exam, you also were allowed a one page handwritten note sheet for the exams.

You will need the famous CLRS textbook as well as the Intro to the Theory of Computation book by Sipser. Both books are pretty good.

Professor Pryby made some very helpful supplemental videos and office hours videos to go with the legacy Udacity videos from the previous course professor (I think his name was Charlie).

Overall I prefer “code slinging” over theory, but this class was a good change of pace (6th OMSCS course for me).

Several changes were introduced this semester to address many of the concerns raised by students in previous semesters.

There were no graded homework assignments. Instead, there were problem sets which students were free to discuss on Piazza.

The absence of graded homework assignments was compensated by more exams. Instead of 2 exams, there were 5 exams! However, each exam covered only three weeks of material at a time, so it was manageable.

There were several supplementary YouTube videos that helped clarify concepts that were inadequately addressed in the Udacity lectures.

There were several office hours and, unlike in the past, these were available for viewing on YouTube at later times.

In my opinion the above changes were a big improvement over the previous formats and this was clearly manifested in the smaller withdrawal rate and improved overall grade distribution. The final grade distribution was:

A 101 32. 0% B 115 36. 4% C 10 3. 2% D 3 0. 9% F 0 0. 0% W 87 27. 5%

This does not mean that the course has been compromised and watered down. Rather, by streamlining the content and redesigning the grading criteria, the learning process has become less burdensome and unnecessary restrictions and time sinks have been eliminated. The course content is still the same, so students still have to put in several hours of work.

Personally, for me, this course was a great learning experience. I took this course by itself so I was able to manage without too much stress. Since my undergrad was not in CS (I have a masters and PhD in Aerospace engineering), I prepared for this course by:

Reading “How to Prove it” by Daniel J. Velleman.

Watching the Harry Porter videos series (based on Sipser).

Reading up on the basics of graph theory and related algorithms

Eventually, despite not having a math or CS undergrad, I was able to score 97. 33% at the end of 5 exams. So with the right kind of preparation, anyone do well in this course.

By far the most difficult course I’ve taken in OMSCS. (I also took 6290 computing architecture, 7641 machine learning) Every homework set is challenging, the exams are no joke, compared to other OMSCS exams. You need to write a lot of things on paper and scan them then upload. Most of the course materials, homeworks and exams are about math reasoning. it is satisfying when problems are solved, but the process is challenging. The piazza discussion helped a LOT, I got hints to the homework problems(but still need a lot of effort and thinking) on piazza discussions. those discussions are really helpful, and helped the thinking process. I heard discussions are not allowed in later semesters though.

Mandatory class. Important class, and I see the benefits i’ve reaped by learning this stuff in other classes. But while I was in it, all I could think of was why I didn’t prep more, why I took it with another class, and if I would survive.

5 exams. 3 questions per exam. 5 points per question. 60 points between you and graduation.

• A: > 80%
• B: > 60%
• C: > 40%
• D: > 20%

These cutoffs utilize a “strictly greater than” policy. That is, to be awarded a B, one must average strictly greater than 3 points per problem.

There have been several changes since the previous time I took this course in Spring 2015:

• Starts with algorithms instead of decidability/complexity.
• New and better videos.
• More active TAs with higher quality office hours.
• No graded homework assignments.
• More exams each with fewer questions.

While there are no graded homework assignments, a problem set consisting of 5-8 questions is made available every week. Practice exams are also provided.

The exams themselves have matched the content and difficulty of the problem sets and practice exams, though one could argue the problem sets and practice exams are more challenging. This appears to be intentional.

I’m glad to see the program is responding to student feedback, even if little by little.

Lastly, the topics covered in this course, especially in algorithms, are invaluable. While your day-to-day as a fill-in-the-blank may not require asymptotic analysis, amortized analysis, dynamic programming, or the like, the critical and analytical thinking skills that this course forces one to develop are well worth the pain.

This is the course that separates the wheat from the chaff. I have never taken a harder course. Part of that is related to the material, which is related to some of the hardest problems in computing. I get that. And the course will stretch your mind and make you really dive deeply into these issues, which is great. However… however… where to begin. Okay, the lectures are not very good. They do not allow you to argue for partial credit on problems. Normally it’s either right or wrong. Get 7 out of 8 steps correct? That’s going to be a zero. The fact that the course worked this way made me assume that they would eventually curve the grades and were doing this to force us to work super hard, but I was wrong. No curving. Grading is basically not on what you have learned or synthesized, but instead is based on perfection. On one of the early homework assignments I got a 4 out 16 because I wasn’t understanding things. It took me 30-40 hours (sometimes as many as 50) hours per week for the rest of the semester to pull my grade up to a B by the end. In the end, I actually had a C but on the final I had answered a question correctly, but not the way he wanted me to and eventually he allowed that I had not only answered it correctly but has proved my answer and so he gave me full credit (I couldn’t argue for partial credit) for the question and I got to a B.

The lectures need to be redone and I think they really need to think about how they have structured the course.

This class is extremely hard…

Taking CCA is kind of like taking LSD. On the one hand it may expand your mind and you’ll see connections and duality of many classes of problems, you’ll spend time trying to fathom infinities that are greater than other infinities and create programs that consume themselves and result in contradictions. On the other hand you may experience extreme anxiety, delusions, dissociation, lack of sleep, and paranoia. You may have a bad trip.

That said this class is not really the monster it is made out to be. Complaints about it being too mathy or taught by a math professor are misguided. It is very mathy and you should accept that for a theoretical computer science course. For a graduate program you should also be prepared to write proofs and reason mathematically about the algorithms.

To stretch the analogy, going into CCA high on anxiety and fear will not help you out. Be prepared but not afraid. To prepare: watch the Harry Porter Theory of Computation series on YouTube while you read along with your copy of Sipser for the Computability part of the course. Watch the first 3 lectures from MIT OCW Math for Computer Science to warm you up on proofs. Start going through chapters of CLRS that match the complexity and algorithms part of the course. In particular pay attention to graph algorithms, dynamic programming and linear programming as they are a big part of the final algorithms section. Practice all the reductions you can for the complexity section. The format may change semester to semester, but here’s a hint: if they give you practice problems - practice them - all of them - because the practice problems may show up on the exams. ;)

Lastly, don’t delay the course. Maybe not make it your 1st course, but making it the last is not advised since that will just add to the stress of taking it. The best way to prepare for CCA is to take CCA. Good luck.

Charlie Brubaker worked very hard to help out the students in this class. So far I have taken 5 courses. This was by all means the hardest class that I have taken, however it was also the most rewarding. There are many key areas that this course covers that are critical if you are doing “computer science”, not just software engineering. What I mean by computer science is algorithms. If you want to work in some of the top companies, this is critical foundational knowledge.

I get a little nervous when I see some of the comments in this thread. Georgia Tech is top program, and top programs should be hard. I hope the professors don’t water down the program by making it easier.

Chris Pryby, you are a disgrace of a professor. A stark mark of shame on the profession of teaching. To the OMSCS program director/coordinator who says that students cannot use outside sources? Chris Pryby! To list a few classes, in networking, software development processes, software architecture and design, I used more than what the text listed. I got the grade I EARNED by reading more than what was listed. A mentality of my way or the highway does not work in industry. To all who register for 6505, avoid Chris Pryby like the plague. You will do yourself, your learning, your career, and more importantly, your sanity a huge favor.

Highly recommend against taking this course. The main issue is the way it is taught (and this is very deliberate by the professor Chris Pryby).

The videos, though interesting and fast-paced, do not actually teach. Take a look at Udacity to preview them. Worse yet, they do not help with the homework.

I’m very interested in this material but ended up dropping the class as I don’t believe it is being taught in a helpful manner. Though changes were made from Fall 2015, the changes are for the worse and only resulting in more of a time suck than anything else.

There is a Readiness Assessment that is provided after adding the class. It really needs to be posted on the official OMS site so that people have an idea about what this class will be like.

You need to handwrite and scan in your homework.

Very poorly taught (or really not taught at all). Avoid the class. This course cannot scale in its current form. Please fix it.

This course is needlessly difficult in ways that impede learning outcomes. The Udacity lectures are simplistic and useless, although hilarious, since the presenter sounds like Elmer Fudd. The new Prof prioritized making this a weeder course. Valid solutions were not provided for prob sets, reason given was to have students work things out on their own. Side effect was that graded HW feedback could not be argued by students, as there was no ground truth to compare to. Much time was spent trying to “prove” things that had little to no practical real world value, (Cantor’s diagonal argument). Difficulty defending any proof other than what TA’s had in mind, or on answer sheet. Akin to religious argumentation. Prof mentioned struggling with 6505 himself when he took it recently. Seems this was payback time for the next batch of students.

Warning, all online resources were banned. An ultimatum was issued halfway through the course for students to admit to having “Googled” to receive 0 on an assignment and have a note added to their permanent record to avoid more severe punishment. It seems several students had OSI investigations launched and received “I” incomplete or “F” on their transcripts. Imagine having this happen to you for looking something up on Wikipedia.

Update: IRP stats are now up. http://www. irp. gatech. edu/reports/grades_by_instructorsmry. php. Pryby - Spring2016 A:32, B:63, C:64, F:8, I:3, Total:170, (W:132) 44% failed Brubaker - Spring2015 A:38, B:15, C:9, D:11, U:1, Total:74, (W:107) 28% failed Considering a C is not a passing grade for many specializations it is pretty severe that 44% of the non withdrawn students do not receive an acceptable grade.

You need to have previous experience on mathematical language, how to read and write proofs, discrete math. Trying to learn those skills while taking this course won’t work at all. To be honest, the instructor clearly explains that, and gives a fair warning on the first week of class. Trying to do that would be like trying to learn Pre-Calculus and Calculus at the same time (as someone recently mentioned).

The instructor and TA seem very involved in improving the experience for all students. New for this semester: they returned a first submission of homework with feedback, and we had a resubmission opportunity for 100% of the grade (6 homework assignments - 3 problems each). Also new this semester: the course is now divided in three sections, for each one of them there’s a proctored exam (closed book, one sheet of notes - two sided). So it was easier to study than for previous terms, when there were two exams.

The exam problems were very similar to the problem sets given for each unit. There were no “official” solutions for the ungraded problem sets, the philosophy of the instructor is that we should work on them on our own (but collaboration in study groups was encouraged - I know there were study groups on G+ Hangouts, Slack, and locally held meetings). Working on study groups really helped. An informal statistic for a group had: 11 A’s, 10 B’s, 6 C’s. So that really makes a difference.

It was mentioned that there will be further enhancements to this course next term. Something else: do try to take advantage of every extra credit opportunity (if given).

I definitely can say that I learned A LOT. There where weeks were I spent my weekdays after office 8pm-1am, and weekends all day long reading, working on homework, watching lectures from other universities. Take advantage of the instructor/TA’s! Don’t be afraid of asking any question about the material, I don’t remember a question left unanswered.

This class is very hard. The prerequisites are reasonable but you probably haven’t used them since you were last in college so you will probably be rusty. Make sure to prepare for this course in advance. You’ll want to focus mostly on proof writing, make sure you understand how to prove direct, induction, and by contradiction.

When taking the class, make sure to take time to work through the problem sets. The homework is harder than the exams, but you have two weeks for each assignment and have the ability to submit revised answers based on the homework feedback, so don’t let the homework take too much time away from working through problem sets as they will help sharpen your intuition. Get the CLRS book, it’s not really optional.

The lectures videos aren’t that good, the videos Chris made for select problem set solutions were great and helped a lot before the exam.

Overall it’s a good class. Would be better with better videos. You probably won’t be able to apply anything here, but I do feel like it will sharpen your mind and improve your problem solving skills. It’s a lot of work so either take it alone or take it with an easier class.

Let me first state that my review isn’t really fair since I had to spend more time with an even more difficult course, Big Data for Health Informatics.

This class taught me a lot. I ended up with a C, and I think it was just due toward the end of the class where I couldn’t focus on it so much because I was spending all my time with my other life sucker of a class.

The material in this course is dense, rigorous, but it did seem regularized. The professor really wanted to clamp the students down to his style of learning. In a way, I enjoyed the “isolation” method that was suppose to bring about ones own ability to solve a problem. I think to some extent it worked. I felt like I was really using my brain, and I felt I was generally sharper in my daily life. These were the homework assignments. They were difficult, but we were given another chance to submit after they had been graded. I didn’t do too bad on these, but honestly I spent too much time on them. I should have been focusing on the concepts as a whole which would have helped me on the tests which I never did too hot on. I spent forever on the HW assignment, and I never had time to do the challenge problems. I really had a time crunch, but like I said, I unknowingly set myself up for it by taking the big data class.

There could be something fundamental I was not getting, but over all, even if I liked it to some extent, this isolation method didn’t seem like the best way to learn. I get it, that a degree in any establishment is given better credit when the students are not spoon fed answers. Yet, I felt like I did not have the proper tools to achieve an A. It’s frustrating for sure, I don’t know if I should take another semester and switch specializations or just try it again. I am a bit discouraged after it all. I did try to understand the material as I have done with my other classes.

Yeah, don’t take this with any other high demanding course. Please don’t.

Absolutely horrible course. Video lectures are completely useless for learning. Instructors have implemented a very poor teaching style. Practice problems with no solutions? What is the point of practicing without something to align yourself against? Your work is being sent off into a void. Vague homework feedback that mostly consists of “you did the problem wrong”? Yea, thanks. One TA grading something correct, another TA grading the same exact thing incorrect. Homeworks that consist of 3 problems that most people spend 20+ hours on… followed by exams that consist of 6 problems with only 3 hours? Right… The final exam had you calculating inverse matrices involving 1/12th fractions by hand? What is the point of that? And every single homework and exam problem demanded that you produce a solution in some exact particular format or way, yet you rarely have any glimpse into what that format or way should look like. I learned WAY more while enrolled in 6505 from simply watching video lecture material and reading PDF note packages from other non-OMSCS courses. I learned next to nothing from 6505 directly, and the entire course was an exercise in futile frustration. For comparison, I took ML… ML was a tough class, but doable if you invest the time. 6505 is something else entirely. Avoid this course at all costs.

It’s unfortunate that this course is so bad too, because the material under consideration is vital to a thorough understanding of CS theory. The material in this course is what separates CS from code monkeys. This is why you’re better off not taking this course, and obtaining that knowledge through other sources.

You are expected to have an advanced background in theoretical computer science, which obviously nobody has. There are 6 problem sets, which you can get regraded after feedback. So there are really 12 problem sets and 3 full length proctortrack exams.

Do not take this class, unless you are alright with getting a C. The professor made about 3 one hour youtube videos to walk through some problems. Those were helpful, but besides that you are on your own. The current professor is not very helpful and seems like since he isn’t the one in the udacity videos, he wanted the udacity videos to play a small role in the course.

This class needs to be redesigned to not use proofs, then people would learn a lot more. You can learn the concepts of turing machines, graph theory, and NP without having to work out proofs. Teaching the overall concepts of the different algorithms would have been much more beneficial.

Update: YOU CAN PASS THIS! There is quite a lot of negative going on in the reviews. You will spend way more time than you think in order to pass. You will be stressed out. But you will learn a ton of math. Just be ready to work a lot. No other courses, no large commitments. Good luck!

I spent 20+ hours every week of the semester on this class. 8 hours in an online study group, the rest by myself working the homework problems or the problem set. I learned a lot about LaTeX.

This is a math course. It’s probably better off without the python. But you also probably don’t know enough about writing in Math yet, so this is really difficult. From set theory and countability of infinite sets to graph theory and vertex covers and maximum matchings. There is a lot of math. The programs you will discuss are programs that will always output the reverse of the program given as an input, or a program that when run will output a program that when run that will output…. (etc. ) There is a lot of Logic.

The professor and TAs are working to make the course delivery better. Ideas have already paid off and they have more. They know it’s tough and a lot to learn. The real problem, though, is that it’s really two 3 credit courses given in the time of one. So this course is about as fun as drinking from a firehose. And I didn’t even want to learn this much math. SOME math, sure. But this is a ton.

Advice: Work all the problem set problems. A few of them showed up exactly from the problem set on the test. Others illustrate how to push boundaries of the section’s ideas. Also read Sipser. Generally avoid the udacity lectures, which seem rushed and not very instructive.

The perfect combination of a challenging subject, insufficient materials, and a swap of ownership. It would simply be a tragedy if it was not required for almost every specialization. As it stands, this is the critical flaw in the whole OMSCS program. I would warn you, but, you have to take the class. Good luck.

This class is not like any other class in the program (as of today). Most of the comments already here describe the experience well, so I’ll concentrate on advice. 1) Study the prereqs specified for the course, but don’t expect for a moment that will get you by. Read the assigned textbook for the course (Sipser) and try, try, try to understand it before you attempt the course (yes, all of it). If you don’t, you will not likely do well in this course. Use the Internet to help your understanding of the material (watch the Harry Porter Theory of Computation video series). 2) The teaching/videos in the class are terrible. Sadly, most of the stuff I found on the Internet presents the material in the exact same way. Your best bet? Find a group to work with to help you try and understand the material. And really try to understand it, because you will need to turn in homework that is based on your own thoughts. Additionally, your group will not be there to help you on the exams. 3) Your grade is based on you and you alone. You will not get a good grade just because you did better than a certain percentage of the class. If that what you need to succeed, this class is not for you. 4) Don’t expect to ever know how you truly stand in the class. Grading (under the current grading style) is very vague and inconsistent. If the thought of this drives you crazy, stay far away. 5) If you feel you are doing poorly in 1st half of the class, don’t assume you will do better in the 2nd half. It is possible that you will. It is likely that you won’t. Past [student] performance is no indication of your success [or failure]. 6) Conversely to #5, feeling you are doing great in the 1st half is no indication of how you will do in the 2nd half. Persevere. 7) Try out the class. It is a good experience. But don’t be afraid to drop the class if you are doing poorly. There is no shame in not completing this class or switching to a specialization that doesn’t require it.

This course is very challenging, however I think some people struggle with it more than others. If you have recently taken something similar to CCA in your undergrad then the material in this course is not that hard. If you have been a programmer professionally for years and forgotten most of your undergrad then this course will be extremely difficult. The grading in Spring of 2016 was also very opaque and led to some unnecessary challenges. My advice for this class would be:

• Take this class alone. I am a single guy with no family and I would not want to have taken any other classes with this one. If you have any family I would highly recommend you take this class by itself.
• Do not ignore the pre-reqs. Make sure you satisfy all of them before you come in.
• This class is very mathy and proof based so be ready for that. I personally really like math and think it has its place inside a Computer Science degree from a research institution, but if you’re expecting to be programming a lot you may get caught off guard.
• Do not take this class alone, make sure you are on a chat group with other students or very active on Piazza.
• Use all of the additional text books, especially if Sipser’s is the main text book. I really like Algorithms by Dasgupta

This course is required for almost all of the specializations right now so you basically have to take it, but do not take it lightly. This course was harder for me than taking two courses in previous semesters and I have a strong math background and took a similar course in my undergrad.

Yes, this course is hard, but it is just as rewarding. Remember the old adage - no pain, no gain! This course is very helpful in many ways, one of which is that the concepts covered here are used in pretty much every other course (and I’ve taken 2 others so far). At the end of the day, computer science is a lot about math - not just programming, and understanding the principles behind the programs we write is just as important. I was just as frustrated when taking the course - the countless times I’ve complained, the near nervous breakdowns and the constant frustration of not being able to solve the assignment problems on my own. However, it’s been over a year since I took this course and I am still enjoying the fruits of it. Also, it doesn’t matter if you get an A or a B on this course - what matters is how much you learn. To be honest grades don’t really dictate success in life anyways. A few things to succeed in this course

• Be prepared - take some preparatory courses if this is the first time you are taking such a course. There are plenty on Coursera on Design of Algorithms.
• Set aside at-least 30 hours a week. If you are working and have a family, ensure that this is the only course you take that term.
• Struggle on the assignments - try as hard as you can on each of the problems. But don’t be afraid to ask the TAs for hints and to Google for help (don’t cheat, but ask for help and cite your references).
• The video lectures are not sufficient. Read the textbooks - especially ones recommended for each section.
• Solve as many problems as you can - Google for exam papers from other colleges.

The 16 weeks over which I took CCA have been, without a doubt, the most miserable of my entire life. It’s not so much that the course material is hard, but the material is so poorly taught (the lecture videos do not match the style and level of difficulty of the assignments and exams) and the marking scheme so sensitive to even the slightest error (one minor error in a problem can result in the loss of 1/3 of your validity points and two small errors can result in the loss of 2/3 of them) that getting a decent score on an assignment or exam is a constant struggle. Having now completed this course, I feel incredibly proud of myself, regardless of what my grade ultimately turns out to be. However, had I known just how awful this course was going to be four months ago, I would definitely have thought twice about signing up for it, and for the OMSCS program in general.

The way this class is taught does not belong in a computer science department. It is being taught as a completely theoretical math course by an instructor who is a math phd. As a computer scientist you can expect pretty much every job interview to include algorithmic questions. This class will not prepare you at all for it. You spend most of the time figuring out how to encode Turing machines or theorizing about esoteric mathematical graph properties, both of very little use for computer scientists. The instructor really didn’t do much throughout the entire class. His attitude is either you already know the material and you’ll pass, or if you don’t he can’t really teach it to you. The lectures (prepared by another instructor) don’t really give you the background needed to solve the homework or the exams as set by the current instructor. You mostly have to make up your own curriculum and hope that what you studied gives you the math background needed to barely pass this class. I don’t recommend taking this class until they change the current instructor or he changes the way it’s taught. When half the class drops by the withdrawal date and the remaining half gets a C or lower, you’re really not teaching anything and you actually didn’t do your job as an instructor, in my opinion.

I am not finished yet, but it is hard to put into words how awful an experience this class has been. I have never watched so many lectures from other schools in any course, because the gatech ones are so bad. There is little interaction between students because of the draconian plagiarism policy. No teaching. Just threats, dictates, and grades. I am riding it out mostly as an experiment and will not re-take it when I flunk. I am so glad this is not my first OMSCS class, because I would absolutely quit the program if it were. Treat this as a certification exam on your PhD level understanding of discrete math symbology and language, proofs (which many have not been bothered with since the 9th grade), and 1800 pages of at least 2 if not 5 incredibly dense textbooks. Know it up front, because you won’t learn it from the class. A Computer Science class where you can’t use a computer or calculator is just ironic and tragic. If you really want to learn this stuff you need to take this on-campus and choose your professor carefully. I see minimal value in the knowledge required to get an A in this class unless you are going into academia or just want to sit around with mathematicians and argue about P vs NP theory (I assure you the professional STEM world has better things to do).

It sounds like the course in Spring 2016 is MUCH different from previous semesters, so beware. In my opinion they are phoning it in now.

I am not a formal math person, and if you aren’t either, then this is going to be rough

First, treat this as a 6-credit course because it’s gonna take twice as much time as the average OMSCS course (some exception like ML and HPCA)

Second, unless you are super disciplined, it is not easy to prepare in advance. If you think you can, get the book “theory of computation” by sipser and read and re-read chapter 1-5, 7, 10 and make sure you can do the exercises at the end of each chapter. If you can do this on your own, then you won’t have any surprise going into the class.

Third, there isn’t much hand holding from the instructors / TAs, they all have full time jobs and only instructing the class part time. Do not have high expectation coming in to the class, there is no spoon feeding. You are pretty much on your own with your fellow classmates and you should form offline/online study groups asap. Try to proactively organize discussion on piazza about the problem set and collaborate with your classmate and attack them as soon as possible. You might (policy can change) see those questions reappearing in the exams.

A tip about getting most out of your study group, be very WELL prepared. Do not expect to discuss and learn on the fly, you’ll fall behind and/or not understanding what is being discussed. Read all the material and understand the question in advance.

Part 1 is the warmup of the course, if you’re rusty with writing proof, here’s your chance to practice, this is the least difficult part of the course, which will still kick your butt.

Languages & Countability Turing Machines Church-Turing Thesis Universality Undecidability

Part 2 of the course starts with P and NP and ends with Approximation & Randomized Algorithms (they are harder to prove).

P and NP NP - Completeness NPC Problems Approximation Algorithms Randomized Algorithms

Part 3 of the course will kick your butt. Some people struggle with DP while others LP.

Dynamic Programming Maximum Flow BP Matching Linear Programming Duality

Expect to work hard and spend a lot of time studying.

Lacking pedagogical strategy: The current “instructor” doesn’t actually “instruct” or “teach” the course. He more or less establishes a standard (most consider it on the overzealous side of the spectrum) and grades accordingly. It is rather appalling to take a course where the instructor doesn’t instruct, the lectures are given by a previous instructor and TA, but they aren’t always on target with the course requirements and the level of rigor that is required, the instructors are somewhat responsive on the forum (the only clsas contact is via Piazza), office hours are explicitly NOT conducted, and NO outside resources or collaboration are allowed on homework! Basically, self-teach, but you’re not even allowed differing perspectives to help really solidify what the student is supposed to learn. Sure, there are problem sets that are circulated that students are allowed to collaborate on and use outside resources for, but there really isn’t much time to do those if focusing on the required homeworks first. Also, it’s more miss than hit that the instructor will provide solutions to the practice problems to know if you’re getting it or not. If you’re up for a quite hefty challenge that definitely is a psychological one as well, go for it, but know it will be rough. It’s fairly demoralizing, and I’ve taken undergrad algorithms, theory, discrete math and proofs within the past 7 years! There were some changes between this past fall and the present semester, but unless they make MAJOR changes to where this course is actually taught and supported, I’d recommend going with the II specialization unless you’re determined to struggle for the specialization you really want. I understand it’s a tough subject and students should expect a challenge, especially from an institution like GA Tech, but the department really should evaluate their strategy for this one. Also, check the instructor’s reviews prior to the program… not very positive previously w/ other subjects!

I was not impressed with the over all pedagogy of this class. Yes the material can be difficult to understand, but the majority of the hardship of this class stems from a severely lacking online education strategy. The lectures and assigned text are not adequate and need to be updated to reflect the heavier math and proof focus of the course. There is wide variation in the grading and a simple mistake followed by a completely correct proof can land you with a huge penalty. I decided to drop the course before the first exam because I wasn’t getting enough out of the course to continue to go through the extremely draining process of keeping up with their pacing and assignments for another 10 weeks. Will get more learning the material at my own pace. Instructor interaction with students is good - best so far in the program, but still not adequate for the level of mastery they expect of students. Need more modeling and scaffolding. Not too much to expect in an intro grad course.

This class was very difficult though I also learned a lot.

Prerequisite to succeed in this class are discrete math, mathematical proofs, automata, languages, basic knowledge of algorithms, data structures, linear algebra, set theory, and graph theory.

In some cases, it will be easier to read either the Sipser book, CLRS book, or look up other resources for the material.

The lectures and homework were created by an old professor. The exams are created by a new professor. The new professor is very math oriented. There is a disconnect between the old content and what the professor expects in the exams.

Unlike some, I do not have a very favorable opinion of this class. I did learn quite a bit. But the bottom-line; the amount of time used was excessive compared to the value of the knowledge gained. So, a highly inefficient learning experience overall. I have a strong CS background. As an undergraduate, I received a 3. 97 GPA for my computer science work and have received an A in every other class in the OMSCS program that I have taken for a grade except for this one. In this class, I received a B. In fact, only 16% of the students in this class received an A, and as can be seen by looking at Course Critique (https://critique. gatech. edu/course. php?id=CS6505), the grade distribution with the current instructor is skewed in a direction generally unfavorable to students. So beware, if you choose to take this course, you are in for a huge amount of work and perhaps a significant amount of stress. In my opinion, it would be perfectly reasonable to choose your specialization such that you could avoid this class. Alas, at the moment that would mean that you specialize in Interactive Intelligence, although there might be other ways to dodge this class while specializing in Robotics or Machine Learning in the future if they expand their algorithms offerings. Anyway, in my opinion, this class isn’t going to give you any deep insights about the world; but it will seriously mess up your schedule for the semester. It is a perfectly reasonable choice to choose your specialization specifically so you can avoid this class.

The current instructor, Chris Pryby, has a Ph. D. in mathematics, not in computer science. Not surprisingly, this class has a certain bias towards mathematics. I would say that the way that the class was administered in Fall of 2015 that it is about 80% math and only 20% computer science. Of course, if the instructor were to change, it is perfectly possible for this bias to change as well. To make the point: if you were to choose your undergraduate major based on your desire to complete this class, I would recommend that you major in math rather than computer science. Alas, since most of you have probably finished undergrad, this is a useless point as a practical matter but very important in terms of how you should prepare yourself for success in this class. What is important in this class is not so much your ability to implement any algorithm or concept, but instead to produce mathematical proofs that relate to them.

As a side note. The mathematics in this class is not particularly hard. I had a colleague at work who was a mathematics major before receiving his Ph. D. in bioinformatics assert that the level of mathematics in this course appeared to be at about an undergraduate level when he saw what I was doing as far as the homework. It is not the formal level of mathematics in this class that makes the course hard, it is the way that this mathematics is taught (or more accurately, really not taught in the class) that makes the course hard. Basically, for this class, you either know the mathematics (including proof techniques) already or you are going to have to teach yourself. I would personally put this up as one of my pet peeves about the course. (And full disclosure, I have several such pet peeves). The lectures are sort of computer science oriented and sometimes even interesting when Lance Fortnow was in the picture. But the homework is really all math. And the math in the homework is not anything that is covered in the lectures. So, if you are someone who likes to learn from lecture like I do, you will be at a disadvantage, because you are going to have to teach yourself any undergraduate-level math concepts you are missing from the Internet or from a textbook or whatever on your own. And you had better hope, based on previous experience, that how you setup the problem is sensible, because there will not be any feedback in terms of lecture about how to solve problems UNLESS you try to find a lecture recorded for some other class that covers the same topic, which can be a hit or miss endeavor. Anyway, as a practical matter for those reading this review, here is my advice. Don’t watch the lecture and expect it to help you with the homework, the midterm, or the final all that much. Indeed, there is only a limited relationship between the lecture and the things that determine your grade. Instead of focusing too much on the lecture, I would recommend that you focus on the homework problems and consider the lecture but one resource that MIGHT sometimes be useful in figuring out how to solve the cs-themed math problems that are the bread and butter of this course. As often or not, an outside resource will be more valuable to you than the actual lecture. Do not be surprised by this. For example, at the beginning of the class, I would highly recommend a strong focus on the “optional” Sipser textbook in particular. (Oh, and don’t be fooled by the syllabus. There is nothing “optional” about the recommended textbooks UNLESS you already own a textbook that is substantial similar. ) In fact, if you are taking CS 6505, why are you even reading this review? You should be reading Sipser.

A note about office hours. In the Fall of 2015, there were two types of office hours. Office hours where lecture was watched together and office hours that covered the homework. As I was taking two classes, I personally did not have time to show up to many “watch together” type office hours. But the few I did go to were not all that useful. But don’t get confused. If you find the “watch together” office hours less than useful, don’t make the mistake of assuming (like I did early on), that the office hours are a waste of time. In fact, the office hours that go over the homework are pretty much must watch for most people. Indeed, if I were to take the class over again, the first thing I would do when I received the homework is review it and try to complete as much of it as possible before office hours covering that homework is held. Then you will be well-positioned to maximally benefit from office hours and just maybe, have something resembling a normal life. As others have mentioned, it is in office hours that many of the “hints” to the “tricks” that will otherwise end up consuming your entire life are given. Thus, being properly prepared for office hours is often the only efficient means of solving the homework and the way to steal back some free time from this time-sucking course. So, do not make the mistake I did, which is to insist on watching the lectures before attempting the homework. The lectures (which still are not optional) probably will not help you that much with the homework anyway. Just as often, it will be some third-party source of information that is key. I would also argue if you are a visual learner who likes to learn from seeing others work out problems, that Chris Pryby’s office hours should not be skipped, since he has a tablet and works out problems. Other TAs often resort to typing out math in chat, which, in my opinion, barely works and is highly inefficient even when it does work. Oh, and if your schedule doesn’t allow you to make it to office hours one week? At least in the Fall of 2015, too bad. Office hours are not recorded like they should be in order to give everyone the same access to the same information. People who have time in their schedule for office hours will have an information advantage over those who do not. (And this is especially critical, because while the lectures often aren’t that helpful to solving the homework, midterm, or final, the office hours do cover that sort of information. )

Another point. The title of the course Computation, Complexity, and Algorithms. Low and behold, other courses offered at Georgia Tech, but not yet to OMSCS students include Computational Complexity Theory, Design and Analysis of Algorithms, Graph Algorithms, Approximation Algorithms, and Randomized Algorithms. CCA includes all of these topics, albeit on a sort of superficial level. You would think that since all of these topics are covered, that the course would focus heavily on the interrelationships between them. But despite some noises in the lectures about such interconnections, that is far from the focus in the class. No or little knowledge of interconnections between these topics will help you in the homework, midterm, or final. Anyway, my experience in this class was essentially this. At just about the time I start feeling comfortable, maybe even competent, dealing with one area, it is time to move on to the next. So, don’t expect to acquire an especially strong foundation or confidence in any of the topics above as a reward for taking this class (although you should have a reasonable introduction). Maybe the exception is computation, but for that, I would credit the excellent Sipser book, much more than this class. Also, the earlier lectures are much better than later lectures.

Anyway, I am nearly done with my rant. As you might infer from the tone, I did not much like this class. My view is that it is too much work for too little return. Something to be endured, not enjoyed. If CCA were a stock, I would sell it short. But that said, if you take this class, you will learn a lot. It is just that you will have to put in a disproportionate amount of work in learning it. (I feel I would have benefitted more from self-study, where I would control the agenda. ) In terms of grading, you can expect low scores that are then generously curved. But in the end, as a practical matter, much of the class is nearly as much of a test of pre-existing knowledge and mathematical skills as anything else, especially when it comes to setting up problems or figuring out the cute “tricks” necessary to get to the end. (And it shouldn’t have to be said, but knowing how to setup the problem is probably 50% of the challenge. So focus on that first. ) And while I have seen classes that grade on a curve being well-done, in this case, I believe the curve disguises the fact that the course designers do not have a particularly clear agenda regarding what skills and knowledge they actually expect students to acquire from the class. It is more of, lets test them on a bunch of stuff and see what sticks sort of thing. A curve can (in theory) be the most fair way to grade students; but it can also be a way of concealing flawed course design. In this particular case and for this particular class, I believe it is the latter not the former.

Now, there is a particular sort of person that enjoys this class. And without exception, I believe that what sets those people apart is that they are very well-prepared in terms of mathematics and perhaps in terms of schedule (probably they are only taking one course). As I have said, neither the mathematics nor the insights in the course are all that hard, in retrospect. But what is hard is the amount of material you are expected to cover with inadequate time to cover it systematically and thoroughly due to the lack of a focused and clear learning agenda. For those who come into the course with very solid skills (such that they probably do not even need to take the course, really), then it is a pretty fun problem-solving experience. Maybe it even hits the sweet spot for optimal learning. For everyone else who is going to take this course, I do not believe that you will find this course to be anywhere close to enjoyable or a great use of your time relative to the reward. I certainly did not enjoy the class or feel that it is was a good use of my time. But then again, I am not a math major. Perhaps if I had been one, I would have enjoyed this course too.

It was a very challenging course yet I enjoyed it very much. I did some theoretical computer science research during my undergraduate study. Therefore I am quite familiar with the all the course materials yet still it’s very challenging for me.

The first half of the course was about Turing Machine, Decidable, Recognisable and NP-complete, NP-hard. It requires very strong math proving skills. It’s ok if you don’t understand these concepts prior to the class. Nevertheless, you should be comfortable with reading the proof and checking if one proof is correct or not and writing proofs you know for sure is correct. If you don’t know whether you can do these, try to prove quick-sort is O(n^2) in the worst case and is O(nlogn) in expectation. Try to prove that fibonacci series equation F_n = (a^n-(-a)^(-n))/sqrt(5), where a = (1+sqrt(5))/2 by mathematical induction. Also the HW0 is somewhat similar to these problems. If you are not comfortable with HW0, drop the course immediately.

Thorough out the first half of the course, you should find that most proving problems follow a pattern. For example, how to prove something is undecidable, you reduce it to HALT. how to prove something is decidable, you find a decider. How to prove something is NP-Complete, you first prove it’s in NP by providing a verifier verifies the instance in polynomial time and second you reduce the problem to some known NP-Complete problem. As long as you follow the proving patterns, you are in the right direction. Google for solutions of the homework also helps but make sure you understand it and then close the webpage and write your own proof and cite the website in the homework.

The second half of the course focuses on solvable problems and polynomial time algorithms. While implementing the algorithm is mandatory in the homework, it still places most of the attention on proving the algorithm is correct and analysing the time complexity. Some basic graph concepts and algorithms like bfs, dfs and shortest path will help. Learning these algorithms doesn’t mean you can implement the algorithm. Instead, it means you know how to prove the correctness of the algortihm (like what I said, you know for sure your proof is valid) and you know how to analysis the time complexity.

The homework is hard but try doing all homework including the bonus as much as possible. I particularly enjoy the moment when I solve the problem after 3 hours intensive thinking. Also, I personally think it’s better to handwrite all the homework so that writing proof for middle exam and final exam won’t be uncomfortable. I don’t have much suggestions for the exams. Try doing your best.

Hope you all doing well on this course.

It’s my favorite course, but it could’ve killed me in many ways. It’s math-heavy and requires a lot of effort and tricks.

You should avoid it if you:

• have other commitment and can’t put in a lot of hours every week.
• want to get a solid A easily by watching and memorizing the videos
• need time to pick up writing math proofs

If you decide to take it, make sure you:

• understand basic algorithms such as sorting, depth-first-search, breath-first-search etc
• know some linear algebra and be comfortable with matrices

Lectures: be prepared to spend 20 min on a 5 min video. Either you watch it 3, 4 times to finally get it, or find a 20-min YouTube video that covers the same material but is easier to follow. In a way it’s good because you’ll end up learning so much. However it’s very time consuming and there’s a lot of responsibilities on the students. The recommended books are helpful too.

Homework: the problems are interesting but tough. Most requires some tricks. Try your best to complete all. You effort will be rewarded on the exams. Start early. Twice I started the homework on Saturday and had to stay up until 3am on Monday. I don’t know if they’ll continue to offer extra credit for doing peer reviews, but if they do, don’t skip them. Any extra credit will help with your grade.

Exams: spending 3 hours with difficult problems are just brutal. On both exams I spent a lot of time on the 1st question just because I was too nervous. I didn’t finish all the questions, but at the end I accepted my fate and turned it in. Expect to feel depressed after the tests and expect to get bad scores. Don’t be too sad though since there’s a big curve afterwards. The grading on the exams is more generous than the homework. If you writing down any clue, as long as it’s in the right direction, you’ll get more scores than you expect.

To get an A: take every assignment and exam seriously. Try to stay above 75% on everything. Unlike previous semesters, only ~16% got an A this semester. To get a B: try to stay above the average every time.

This is a very difficult class. I spent at least 30 hours a week on homework, and I have a CS/Math background. Some things I’d recommend before beginning the class:

• Get familiar with mathematical notation. I spent lots of time early on just trying to figure out how to read and understand the assignments, let alone work through solutions.
• Familiarize yourself with basic proof methods (induction, direct, contradiction). Luckily I had an old discrete math book from undergrad lying around that was very helpful in the beginning weeks of the course. It’s also worth skimming over general topics in discrete math (and probably some from graph theory as well).

I can’t emphasize enough how little free time I had during this class. I had time to go to work, come back home and study/do homework for 3-4 hours, and then go to bed. I also spent most weekends working on homework. 16 weeks of this is draining–I can’t imagine doing this with a family and/or other obligations. However, the work I put in definitely paid off. I was able to get over 100% as my homework average, which balanced out a mediocre performance on the final. I ended up with an A (barely).

Lectures: The lectures for this class were very hit and miss for me. I really enjoyed the first half of the class, and thought the lectures did a better job of thoroughly explaining the concepts. The second half of the class was less enjoyable for me. The lectures seemed to assume a very strong background in linear algebra and didn’t work through examples at some crucial points (thinking specifically of the linear programming lectures). I took linear algebra in undergrad and so that part wasn’t so bad, but the lack of examples on things like the Simplex method really made things difficult. Don’t try to breeze through the lectures. When watching, I would rewind a portion 3 or 4 times with pencil and paper in front of me. If I didn’t understand a concept, I’d rewatch until I could write it out in my own words. This helped in the long run, but was excruciatingly slow. There were several times, especially during the second half of the semester, that consulting Google for lecture notes from other programs was beneficial. If you do this, make sure you cite your source if you’re working on homework.

Homework: For me, the homework in this class was the most valuable part of the class. Dr. Pryby’s assignments were extremely difficult (hours and hours of work), but they forced you to understand the concepts in the lectures, and stretched you to think deeply about the topics. The feeling you get when you figure out that key piece of insight is amazing. This is where you should really focus your efforts. It is possible to get > 100 as your homework average if you work hard enough, and this can help pick up crucial slack for the midterm and final. The only real complaint I have about the homework is that sometimes the solutions were not presented very well. I’d prefer to see solutions in as dumbed-down terms as possible so that the class can easily follow how a particular solution was derived. Go to as many office hours as you can–occasionally I didn’t think I needed any help on a homework, but joined anyway and the TA would basically give you the answer, or give you an insight that made you change your answer for the better.

If there’s one thing to take away from this review, it’s to start the homework early. Being able to grind away at a proof over the course of 2 or 3 days is just not something you can pack into an hours long window (unless you’re a math whiz). Give yourself enough time to really think about the problems. Write an answer out, then come back to it a few days later and see if it makes sense.

Tests: The tests were extremely stressful. Unless you’re a genius, you probably aren’t going to finish all of the problems. You have 3 hours to complete 8 to 10 problems, some of which are formal proofs. That gives you 18 to 22 minutes on each problem. One strategy I adopted was to go through the entire test and work on problems that I immediately had insight on. It’s not worth spending 30 minutes on a problem you just don’t get, and then missing a problem that you might have been able to quickly grasp. The reality for me was that in a timed situation, I was either going to immediately have some insight into the problem, or I wasn’t (and if I didn’t get it immediately, spending 10-20 minutes on it was not likely to help). I felt absolutely terrible after both tests, but the average turned out to be in the 40s or 50s for each one, so as long as you meet or exceed the average, you should be fine. Another tip–the graders want to give you points. Write down anything , even if you know it’s not totally right or if it seems silly. You never know–you might end up getting a fraction of a point. And for this class, every little bit helps.

Part of the stress for me with the tests was the ProctorTrack system that was used. I was terrified that my internet connection would drop, someone would come in the room, or some other infraction would occur and I’d fail.

Grading/Administration: This is only my second class, but the TAs all were very helpful, I thought. They were empathetic with students and were encouraging during office hours. They held frequent office hours and had “watch together” sessions. They were also very available on Piazza (at least compared to the other class I’ve taken). Dr. Pryby was also fairly active on Piazza. One feedback that I think most students had was that the office hours should be recorded. There was some pushback from the instructors on this, but maybe they’ll change it in future semesters.

As for the grading–for a class involving writing proofs, I thought the grading was quite fair. If you think about it, any error in a proof makes the entire proof totally invalid. From this perspective, getting partial credit is generous. Show all of your work, and if you’re not sure if you should include or explain something–just go ahead and do so. This should go without saying, but participate in as much extra credit as you possibly can. You need every point you can muster.

Books: Just go ahead and get both of them. At some points during the semester, I needed a combination of book + videos to understand the concepts. In many cases, the books were much clearer than the lectures. CLRS is probably worth having on your bookshelf anyway.

Conclusion: This was a very rewarding class. I feel like the my knowledge of the foundations of computing is now very solid. At the same time it was extremely stressful. I wouldn’t recommend taking it and expecting an A if you have other life commitments. Good luck!

50% of students got a C or less (and that’s after many students withdrew following the midterm results). Of course each student is responsible for his/her own grade, but there’s a problem if half the students are essentially failing the course. Expect a lot of outside study of the material. The lectures are barely useful. They gloss over the material and give no concrete examples that are on par with the homework. These are some of the shortest lectures of any OMSCS course I’ve taken (out of 6) and this is the hardest of any of the OMSCS courses by far. That’s a problem. I also think the level of mastery expected by the professor is unreasonable in a single course. There should be a prerequisite for this course. The difficulty is just unreasonable for students that are new to the material. It sounds like earlier professors were more reasonable about this and graded accordingly.

My advice? Until they resolve this situation, skip this one and take the “Interactive Intelligence” specialization.

This class is very interesting, great TA support on Piazza, lot’s of office hours (don’t ask the TAs to record them, they have good reasons not to in this course, it’s a touchy subject). BUY / RENT THE BOOKS. start homework EARLY. form study groups, practice solving the example final / midterm USING PEN AND PAPER. you have to pause the videos and do some intermediate steps on your own on pen and paper or it will make no sense to you. also add an excel with questions to next office hours. do not skip office hours. ask all the questions. this is why it is critical to start HW early, so you will have covered all questions. Aim for an A in this course, but be aware that getting a B is not easy, and if you got a B, I would be happy with it. (I’m happy with mine and I really worked hard aiming for an A, got an A in the midterm, A on the HW but the final bent me down to a B. I’m still happy with it… )

This is course is very challenging, but you will learn a tremendous amount about the various topics covered. This semester had the absolute best TA / Prof interaction in any OMS course. There were literally office hours every single day. I spent a lot of time working on this course (at least 20 hours per week), and I did have a CS undergrad for what it’s worth (its almost 8 years old).

The grading scheme is 1/3 homework, 1/3 midterm and 1/3 final. The homework assignments are very challenging, and often times the mean score for an assignment was around 10-11 of 16. There were opportunities for extra credit to improve the homework score. A small minority of these problems are python programming assignments. This should not be your focus in preparation.

The questions on the midterms and final are easier than the homework, but they are timed and I was unable to attempt all problems on either test. This was very common among other students as well. The mean grades for the exams were in the 50s. The grades are all “curved” for lack of a better term to be normalized to a standard 10 point grade bracketing.

You will definitely want to prepare ahead of time for the course. Some things I wish I had studied prior (and other useful topics): Mathematical Notation : Summation, Dot Product, etc Set Theory Graph Theory Asymptotic Runtime Analysis (Big-O notation) Time Complexity Classes

I highly recommend you check out the lectures on the public Udacity site prior. While they won’t necessarily prepare you for the assignments, if you can’t understand the notation used in the lectures, you should review it until you do.

One thing I will mention regarding some of the other reviews: there is a very specific academic integrity guideline when it comes to using outside resources (not the lectures or prescribed textbooks). We had some significant issues with plagiarism concerns on one of the homeworks which led to some grades being lowered to 0. Just follow it to a T and you should have no problem using outside resources to help with the homework problems.

If you do not have a discrete mathematics background, this class will be very challenging.

Homework assignments take the full amount of time allocated to complete, and even that may not feel sufficient.

The rare programming assignments require Python/Numpy knowledge. The exams ended up with >50+ curves, which should be telling, since they are clearly too difficult or the teaching leading up to them is inadequate.

This class is very difficult, but not artificially so. The instructors and TAs are available and willing to help. The material being covered, however, is inherently difficult. Be sure to brush up on your big-O analysis and linear algebra and feel comfortable with proofs. The instructor this semester is different from previous semesters and so far it appears that the class is even more difficult than before. You will not have your hand held and you will spend a lot of time on this class but you will hone your critical thinking skills and refresh much of your math background.

Very theoretical, mathematical material. I wish there was a similar course with a more practical emphasis, but I know the background understanding will be useful. I get the impression that the professor is more interested in making this a weeder course, than actually helping students be succesful. The learning curve is a cliff on every section of the course. The lectures gloss over the material and then the homework dives right in to extremely difficult esoteric problems (and the homeworks are graded very harshly). Just understanding the problem can take hours of research (but be careful not to violate the ‘code of contact!’) I think it’s being presented in a way that’s making it more difficult than necessary. You may find yourself considering the Interactive Intelligence track since it doesn’t require a ‘B’ from this course.

(mid term review)… I’ve found this class challenging, but also very enlightening. Instructor/TAs are very active in piazza and feedback turn around is pretty prompt. The HW’s and midterm were pretty tricky and can take a bit of work to even figure out what they’re asking for. Once given a solution it can even sometimes be difficult to parse the solution, but I’m definitely getting better at it through the semester. I’m a little concerned that the grading may be even more strict than it has been in the past, but we’ll see how that falls out in the end. I’ve been very pressed for time and wish I had more to be able to dig further into the material and get the full experience the course offers. I would not recommend pairing this with another class.

Looks like this semester neither prof nor instructors are up to the task. Main emphasis is on not revealing the nature of the homework solutions (as people above wrote, there is usually some trick that solves it). Very often that results in lengthy ‘around the bush’ explanations, whch may lead student to the wrong ideas. Office hours mostly are review of the videos, and many of Charlies videos are very compressed ‘fly overs’. But expecting TAs to ‘spell it out’ would be too much. So, office hours are not very helpful. Prof and some TAs are ‘sensitive’ to the discourse among the students. So, when people expressed too many conserns with the course, professor responded with the warnings about plagiarizm in homeworks and actually lowered the grades of several students. That worked, and no one complained much sinse. Piazza messaging was very active, but mostly from those who were ‘lost’. Those who could be helpful did not really try to help because they were afraid to break ‘code of conduct’ by giving too much help, and also because of the curve (if others fail, your grade goes up). Even though the material is very interesting and very useful, I would not recommend taking this class the way it is this semester, but most of us have no choice because it is part of the requirement.

Very diffcult class. You will finally lost if you do not have previous CS background in such as automation and language theory. TA’s grading is very tough, and the homework is tricky. I feel that TAs want to make your grade as low as possible. The mean of grade distribution is very low (like 10/16). Becareful! They give the some problem just the same as problems somewhere online. But, do not simply follow online solution’s approach. Otherwise, they will charge you of plagiarism. To be on the safe side, you’d better to cite relevant references. The first half of this class is useless. From the survey, you may see postive opinions about this course, yet the course is neither fair nor fun. In first few days, people dropped a lot. I dropped, too, before mid-exam. Have to say the person who completes this class is great!

I’d agree with almost everything said. Hard class, worth it, you will learn a lot, demanding. I didn’t (don’t?) have a strong background in Math nor in theoretical computer science. Right now I’m hoping I can get the B. The only thing I would disagree is that professor was not involved, he was to a good extent responsive during piazza and he always held his office hours and spent a good amount of time answering any questions, it’s up to you to come prepared to ask the right question. Overall I really enjoyed the class and I’m happy I took it. I wouldn’t recommend to take it along other class unless you are really ready to sacrifice. I have a demanding full time job and family and had to wrestle time to put up here.

very difficult.

Very math heavy and theoretical class. First section touches on all sorts of big theoretical CS problems specifically reaching P vs NP. The algorithms portion of the course was very cool and gave some good techniques to a lot of problem subsets. This class gets into some proofs, but it isn’t as math intensive as a graphics course might be. The weekly assignments really drill in the information and if you do well on them the rest of the course won’t be too hard.

The first half of the course is a bit challegening, but not too bad. Homework and exams expect only basic understanding of the material.

The course was very informative. At times the homework/exams felt more like guess work, but there was aggressive curving. I did not care for the initial reduction section. P and NP sections were very clear/interesting.

The class was both way too much and way too little. Way too much in that it covered over a dozen genious level concepts from the past few hundred years. Way too little in that the video would spend 5 minutes on something that you might spend 5 hours trying to understand. ‘And here’s the proof, blam!’ Don’t understand it… oh well. Don’t take any other course with this one if you are working full time (big mistake on my part). While there was lots of interesting stuff, and I really did learn a lot, by the time it was done I was just glad it was over – not a desirable educational outcome.

This class is very interesting. The TAs and Professor are quick to respond to questions and issues. All in all it was a great course, though very difficult. If you have a strong math background this class may be slightly easier for you. There’s a lot of math notation.

It’s an interesting course - learning curve is quite steep, especially as my first semester and back to school after 5+ years. The first half of the course is mostly theoritical and time-consuming, while the second half was quite easy but requires math. The lectures touch upon the concepts but for assignments and home works, there’s a good amount of study required. Mere lectures wont be enough. Python was easy to pick up along the class. The best resource was Piazza forum - maximizes your understanding and lots of help. The homeworks are a great way to learn and mostly tailor along the recommended BOOK s - so that was quite a relief! Don’t take the course lightly - it is demanding and start your homeworks early. There was always a homework every two weeks. And I found the exams tougher than regular assignments. Nonetheless, I loved the content of the course.

Strong background in mathematics is recommended. Get yourself familiar with Discrete math, Logic and Graph Theory. Lots of proofs. You need to invest a lot of time in problem solving, that is where this course takes all of your time. Even in programming assignments you are likely to be asked to prove correctness of your algorithm, and also provide its runtime complexity. So DO NOT take it easy.

Do not take this as your first course if you have been away from college for 10+ years, raising a family, and working full time. The time commitment is overwhelming and trying to learn some of the topics and programming lanquages in the class are very very time consuming. I found it very difficult because I do not have a math background and since I have been out of school for so long found myself relearning the math concepts along with trying to learn the material. I should have dropped the class but tried to stick it out with no success. I will be taking it again sometime in the future. The instructor and TAs were great in the office sessions.

I have seen comments on other courses, and there seems to be a lot of courses that instructors do not pay enough attention to students’ questions. Compared to those courses, this courses is very well managed and the instructor and TAs are very approachable (the instructor answered almost every question in piazza). I have a bachelor degree in CS and Math from a good CS school, but still I feel that this course is not easy for me, and each assignment consumed a lot of time. But I have to say the time is worth it and really make you evolve. I will recommend to take this course only or along with a light-weight course in one semester. I believe that if you manage to pass this course, other courses would be much easier for you.

I have loved this class. I always liked the theory classes in my undergrad because that IS the science in Computer Science. Understanding these topics makes you better in all aspects of CS, and I think most (if not all) of the other OMSCS classes that I have taken have touched on some of the topics here. As others have noted, the class does have 2 distinct parts. The first part is theoretical, and the second part dives into some pretty heavy topics with algorithm analysis. I actually found the first half of the class easier to understand just because of the shear volume of information in the second part. As far as time commitment, you have 8 assignments due roughly every 2 weeks, and each assignment took me ~10 hours or so. Add in time for going through the lectures and studying/preparing for the tests. Grading is very fair. I really like Charles as an instructor and a TA, and he is very involved and approachable. There are a lot of resources to help people in this class- the TAs held office hours at midnight Georgia time to be accomodating to people. Don’t be too scared of this class, it really is very rewarding!

I found the time demand of the first half of the course (computability and complexity) to be a lot more than the second half (algorithms), but I suspect that is background-dependent. I had no background at all on the theory of computation or formal languages, but plenty on linear algebra, FFT, numerical approximation, and other applied math topics. The first half of the course is extremely theory-heavy and you need a strong understanding of set theory to do well. The curve is pretty generous. I ended up with a raw 85 on the midterm and that curved to a 100, so don’t be discouraged if you aren’t getting everything exactly correct. The main challenge is the logic-puzzle nature of the homework. Sometimes an answer will click pretty quickly and sometimes you’ll stare at it for days and make no progress. Attend at least one office hours session each week and check in frequently on Piazza because both your peers and the TAs are a great resource here. There’s always a little tip or trick that is obvious in retrospect to solve each problem.

I was quite familiar with the topics presented here, or at least I’d seen them before. This is math-heavy and I can see how if you’re not accustomed to it, it would be very difficult. Lots of office hours, which is good, including watching the videos together. I’m not finding Piazza to be a good resource as far as getting student answers (maybe because it’s a combination of knowing math and being able to explain things), so I usually just post privately, or if possible, use stackexchange instead. There are good resources all over the internet if you don’t understand the lectures (sometimes they were confusing), and I recommend (these are Carnegie Mellon courses) material from 21-127, 15-251, 15-451. I’m sure there are other good materials or lectures available, too.

This course is hard. It’s pushing me to my limit. I’m taking 2 other CS courses concurrently which is just barely manageable with a full-time effort. But I’m learning a ton. It’s an incredible foundation for Theoretical Computer Science (really, CS as a whole). It’s looking like I’ll end up with a B, which is okay by me. The workload is highest during the first few weeks, then it slows to a more manageable pace as HWs are due every other week. Not having a strong background in Theory before this course, the HW assignments take me about 12-18 hours each and require some serious thought and effort. The lecture videos are great, but I wouldn’t be passing without reading the text BOOK (also great) as well. Exams are fair—difficulty of questions was on par with HW problems, maybe a bit easier—but I didn’t have time to finish. Was panicking before I got my (generously) curved grade back. Overall, really fantastic class. High quality course materials. Interesting subject matter. Highly applicable (I’m already seeing the concepts cropping up everywhere I look). Just don’t underestimate the time and effort commitment.

This is a very difficult course, especially if you lack a Math background and/or are not familiar with the fundamentals of algorithms already. It’s not an introductory course to really anything that’s discussed. The homework is due every other weekend so I would usually watch lecture videos during the week and then spend the entire weekend doing the assignments. Tests are brutally hard. They’re 3 hours long and, despite studying, I struggled on both and needed at least an additional hour (which is not available) to finish. The curve on the final was, I think, about 35% for reference. It’s a great class and you’ll learn a lot. The lectures often do not directly map to the homework assignments and require additional reading.

I hope math and formalism is your first language. I din’t feel like the content was difficult, but translating and understanding the questions took a lot of time. The grading on the exams was tough, but the curve generous.

Very tough course with lots of theory behind it. Professors and TAs were usually involved with the class. If you have a strong background in Math, this class shouldn’t be too bad

After a great intro into the OMSCS program with 6300 over Summer, I made the mistake of taking this class alongside 6310. If you are a working professional such as myself with a young family without a strong grasp in theory, I HIGHLY recommend that you take this class alone. After dropping 6310 a month into the semester, I found this class very enjoyable and the second half was much easier to me than the first. ProctorU is horrible and caused me to lose half of my final time allotment through computer freezes/crashes (and the final is 30% of the grade). I will stear clear of ProctorU courses after this. I was unhappy with the intructor’s logic leaps in many places, this class is not for people without a whole lot of time and/or theoretical CS knowledge.

The class does everything it advertises it will. The material is theroetical and well explained, covering Turing Machines, computability, P, NP, dynamic programming, max flow/min cut, and linear programming. The quizzes and tests are fair but challenging. Be aware that this will be a difficult class if you’re not used to theory anymore.

Great class if you are interested in algorithms and theoretical computer science. The first half of the class tries to answer what computers can do, and what they can do efficiently. The second half is about algorithm design, and how to reduce a problem to one you’ve already solved. Definitely a ton of work. Don’t procrastinate! You definitely have to spend time thinking about the material, and rewatching lectures, to understand it. If you have a busy life, I would recommend taking this class alone unless you’re already familiary with this material.

You almost have to take this class as it fills in so many specialty tracks. This is a weeder class. The first time you watch the lectures it will seem like they are being taught in another language, unless you are one of the top students in the class. This is a class where students with strong math and theoretical computation backgrounds will shine. Most however, will have a very tough time, including myself. But fear not, the curve is very generous if you have the fortitude to stick it out. My advice for future students is to watch the lectures, but do not rely on them alone. You should get both BOOK s, do further research on the internet, do the supplimental exercises, participate in Piazza, go to office hours, join a study group, etc. But most importantly, just stick it out. It will be tough, but worth it. I feel like I learned a lot. Some of it was interesting, but some was just complicated. My hope is that they spruce up the lectures for future classes. Again, they were very hard to understand for the average student.

Great instructors, great response to student concerns, well-designed class. Everything about the class is great except the material! Super difficult and theory-heavy. I found I had a lot of trouble understanding the first half of the course until a few days before the midterm (which I ended up doing well on). Now I feel I don’t understand the second half of the course at all, and there’s about a week and a half until the final. Hoping it clicks soon.

it takes a lot of repetitions and seeking out other sources to understand the material

If you like Math, this is a great class. The material will engage you, and the instructors are very good. The lessons move quickly, and assume some proficiency in Discrete Mathematics, and formal proofs. Additional reading and research will help fill in the gaps. Plenty of practice with problems is essential for exams. In summary, I enjoyed this class, even though it was very demanding.

This is a challenging course. The material is very theoretical and tends towards proofs. There are a small number of python programming questions, but the programming component is minimal. Most of your time will be spent trying to understand the theory.

Very theoretical course. Programming assingments in Python. ‘Optional’ text BOOK really isn’t - you need to read the appropriate sections to get more of the nuance to answer some homework assignments. Instructors work well together and complement each other well. Due to scheduling issues/Google Hangout issues, I haven’t been able to attend a single office hour, and material discussed there is very secretive – possibly my only complaint about the course.

I dropped it this semester so I can take it by itself. This one definitely takes some study time and hours invested to figure out the homework. I’m definitely looking forward to finishing this course… the material is really interesting.

I am like Josh Power above. I felt like I kept studying. Looking over the materials and watching the videos but I never felt like I learned much. When I did it felt like I kept maybe getting one thing only for five more questions to arrise. Be careful with this class and do not take it lightly. If you are REALLY good with theoretical Math, then take it with another class. Otherwise take alone.

The first half of the course is heavy on logic propositions, formal proofs, and mathematical syntax. If you haven’t had formal logic in awhile it would be worth it to brush up. HW grading is pretty coarse; it seems like any mistake costs half credit for the whole question and they’re inconsistent on what you’re allowed to assume is ‘well known’ (hint: don’t assume - write down a source for every theorem or identity you use). The second half of the course is more focused on programming; it is mostly in Python through the Udacity site, so brush up on Python syntax. Project Euler problems are similar to the kind of problems in the later homeworks.

FYI: I dropped the class before the W date. Anyway I thought that this class took a significant amount of time and I always found myself questioning if I was doing the right thing in the end. I never felt like I grasped the material.

I will recommend to have some understanding in graph theory before taking this class. Otherwise it is painful to learn the algorithm and graph theory at the same time. Python is a ‘nice-to-have’ skill so that you can have an edge in completing homework.

Great class. Homework is generally short, but can take a deceptively long amount of time.

Very theoretical course. The few programming assignments you do get are in Python. Most of the assignments are looking for proofs. Not a fun class, but the material was interesting enough and its just one of those necessary courses that everyone has to take (weeder course). Word of advice: Go to the office hours. That is where I did most of my learning. This course was one of the few courses where office hours is pretty much a necessity.

Online Master of Science in Computer Science (OMSCS)

College of computing, cs 6515: intro to graduate algorithms, instructional team.

Gerandy Brito

Eric Vigoda

Rocko Graziano

Jamie McPeek

David Harris

Christian Stober

Emily Lentz

Aja Woolworth

This course is a graduate-level course in the design and analysis of algorithms. We study techniques for the design of algorithms (such as dynamic programming) and algorithms for fundamental problems (such as fast Fourier transform FFT). In addition, we study computational intractability, specifically, the theory of NP-completeness. The main topics covered in the course include: dynamic programming; divide and conquer, including FFT; randomized algorithms, including RSA cryptosystem;  graph algorithms; max-flow algorithms; linear programming; and NP-completeness.

Sample Syllabus

Spring 2024 syllabus (PDF) Summer 2023 syllabus (PDF) Spring 2023 syllabus (PDF)

Note: Sample syllabi are provided for informational purposes only. For the most up-to-date information, consult the official course documentation.

Course Content

To access the public version of this course's content, click here , then log into your Ed Lessons account. If you have not already created an Ed Lessons account, enter your name and email address, then click the activation link sent to your email, then revisit that link.

Before Taking This Class...

Suggested background knowledge.

Students are expected to have an undergraduate course on the design and analysis of algorithms. In particular, they should be familiar with basic graph algorithms, including DFS, BFS, and Dijkstra's shortest path algorithm, and basic dynamic programming and divide and conquer algorithms (including solving recurrences). An undergraduate course in discrete mathematics is assumed, and students should be comfortable analyzing the asymptotic running time of algorithms.

CS 8001 OLP is a one credit-hour seminar designed to fulfill prerequisites to succeed in CS 6515. More information is available on the CS 8001 Seminars page .

Academic Integrity

All Georgia Tech students are expected to uphold the Georgia Tech Academic Honor Code . This course may impose additional academic integrity stipulations; consult the official course documentation for more information.

Instantly share code, notes, and snippets.

akolybelnikov / LCS.js

• Download ZIP
• Star 0 You must be signed in to star a gist
• Fork 0 You must be signed in to fork a gist
• Embed Embed this gist in your website.
• Share Copy sharable link for this gist.
• Clone via HTTPS Clone using the web URL.
• Learn more about clone URLs
• Save akolybelnikov/9439172498da96e1fa8cb259d415640c to your computer and use it in GitHub Desktop.

Victor Mukhin

• Scientific Program

Title : Active carbons as nanoporous materials for solving of environmental problems

However, up to now, the main carriers of catalytic additives have been mineral sorbents: silica gels, alumogels. This is obviously due to the fact that they consist of pure homogeneous components SiO2 and Al2O3, respectively. It is generally known that impurities, especially the ash elements, are catalytic poisons that reduce the effectiveness of the catalyst. Therefore, carbon sorbents with 5-15% by weight of ash elements in their composition are not used in the above mentioned technologies. However, in such an important field as a gas-mask technique, carbon sorbents (active carbons) are carriers of catalytic additives, providing effective protection of a person against any types of potent poisonous substances (PPS). In ESPE “JSC "Neorganika" there has been developed the technology of unique ashless spherical carbon carrier-catalysts by the method of liquid forming of furfural copolymers with subsequent gas-vapor activation, brand PAC. Active carbons PAC have 100% qualitative characteristics of the three main properties of carbon sorbents: strength - 100%, the proportion of sorbing pores in the pore space – 100%, purity - 100% (ash content is close to zero). A particularly outstanding feature of active PAC carbons is their uniquely high mechanical compressive strength of 740 ± 40 MPa, which is 3-7 times larger than that of  such materials as granite, quartzite, electric coal, and is comparable to the value for cast iron - 400-1000 MPa. This allows the PAC to operate under severe conditions in moving and fluidized beds.  Obviously, it is time to actively develop catalysts based on PAC sorbents for oil refining, petrochemicals, gas processing and various technologies of organic synthesis.

Victor M. Mukhin was born in 1946 in the town of Orsk, Russia. In 1970 he graduated the Technological Institute in Leningrad. Victor M. Mukhin was directed to work to the scientific-industrial organization "Neorganika" (Elektrostal, Moscow region) where he is working during 47 years, at present as the head of the laboratory of carbon sorbents.     Victor M. Mukhin defended a Ph. D. thesis and a doctoral thesis at the Mendeleev University of Chemical Technology of Russia (in 1979 and 1997 accordingly). Professor of Mendeleev University of Chemical Technology of Russia. Scientific interests: production, investigation and application of active carbons, technological and ecological carbon-adsorptive processes, environmental protection, production of ecologically clean food.   

Quick Links

• Conference Brochure
• Tentative Program

Turn Your Curiosity Into Discovery

Latest facts.

11 Facts About National Love Your Produce Manager Day April 2nd

10 Facts About National Clean Out Your Medicine Cabinet Day April 19th

40 facts about elektrostal.

Written by Lanette Mayes

Modified & Updated: 02 Mar 2024

Reviewed by Jessica Corbett

Elektrostal is a vibrant city located in the Moscow Oblast region of Russia. With a rich history, stunning architecture, and a thriving community, Elektrostal is a city that has much to offer. Whether you are a history buff, nature enthusiast, or simply curious about different cultures, Elektrostal is sure to captivate you.

This article will provide you with 40 fascinating facts about Elektrostal, giving you a better understanding of why this city is worth exploring. From its origins as an industrial hub to its modern-day charm, we will delve into the various aspects that make Elektrostal a unique and must-visit destination.

So, join us as we uncover the hidden treasures of Elektrostal and discover what makes this city a true gem in the heart of Russia.

Key Takeaways:

• Elektrostal, known as the “Motor City of Russia,” is a vibrant and growing city with a rich industrial history, offering diverse cultural experiences and a strong commitment to environmental sustainability.
• With its convenient location near Moscow, Elektrostal provides a picturesque landscape, vibrant nightlife, and a range of recreational activities, making it an ideal destination for residents and visitors alike.

Known as the “Motor City of Russia.”

Elektrostal, a city located in the Moscow Oblast region of Russia, earned the nickname “Motor City” due to its significant involvement in the automotive industry.

Home to the Elektrostal Metallurgical Plant.

Elektrostal is renowned for its metallurgical plant, which has been producing high-quality steel and alloys since its establishment in 1916.

Boasts a rich industrial heritage.

Elektrostal has a long history of industrial development, contributing to the growth and progress of the region.

Founded in 1916.

The city of Elektrostal was founded in 1916 as a result of the construction of the Elektrostal Metallurgical Plant.

Located approximately 50 kilometers east of Moscow.

Elektrostal is situated in close proximity to the Russian capital, making it easily accessible for both residents and visitors.

Known for its vibrant cultural scene.

Elektrostal is home to several cultural institutions, including museums, theaters, and art galleries that showcase the city’s rich artistic heritage.

A popular destination for nature lovers.

Surrounded by picturesque landscapes and forests, Elektrostal offers ample opportunities for outdoor activities such as hiking, camping, and birdwatching.

Hosts the annual Elektrostal City Day celebrations.

Every year, Elektrostal organizes festive events and activities to celebrate its founding, bringing together residents and visitors in a spirit of unity and joy.

Has a population of approximately 160,000 people.

Elektrostal is home to a diverse and vibrant community of around 160,000 residents, contributing to its dynamic atmosphere.

Boasts excellent education facilities.

The city is known for its well-established educational institutions, providing quality education to students of all ages.

A center for scientific research and innovation.

Elektrostal serves as an important hub for scientific research, particularly in the fields of metallurgy, materials science, and engineering.

Surrounded by picturesque lakes.

The city is blessed with numerous beautiful lakes, offering scenic views and recreational opportunities for locals and visitors alike.

Well-connected transportation system.

Elektrostal benefits from an efficient transportation network, including highways, railways, and public transportation options, ensuring convenient travel within and beyond the city.

Famous for its traditional Russian cuisine.

Food enthusiasts can indulge in authentic Russian dishes at numerous restaurants and cafes scattered throughout Elektrostal.

Home to notable architectural landmarks.

Elektrostal boasts impressive architecture, including the Church of the Transfiguration of the Lord and the Elektrostal Palace of Culture.

Offers a wide range of recreational facilities.

Residents and visitors can enjoy various recreational activities, such as sports complexes, swimming pools, and fitness centers, enhancing the overall quality of life.

Provides a high standard of healthcare.

Elektrostal is equipped with modern medical facilities, ensuring residents have access to quality healthcare services.

Home to the Elektrostal History Museum.

The Elektrostal History Museum showcases the city’s fascinating past through exhibitions and displays.

A hub for sports enthusiasts.

Elektrostal is passionate about sports, with numerous stadiums, arenas, and sports clubs offering opportunities for athletes and spectators.

Celebrates diverse cultural festivals.

Throughout the year, Elektrostal hosts a variety of cultural festivals, celebrating different ethnicities, traditions, and art forms.

Electric power played a significant role in its early development.

Elektrostal owes its name and initial growth to the establishment of electric power stations and the utilization of electricity in the industrial sector.

Boasts a thriving economy.

The city’s strong industrial base, coupled with its strategic location near Moscow, has contributed to Elektrostal’s prosperous economic status.

Houses the Elektrostal Drama Theater.

The Elektrostal Drama Theater is a cultural centerpiece, attracting theater enthusiasts from far and wide.

Popular destination for winter sports.

Elektrostal’s proximity to ski resorts and winter sport facilities makes it a favorite destination for skiing, snowboarding, and other winter activities.

Promotes environmental sustainability.

Elektrostal prioritizes environmental protection and sustainability, implementing initiatives to reduce pollution and preserve natural resources.

Home to renowned educational institutions.

Elektrostal is known for its prestigious schools and universities, offering a wide range of academic programs to students.

Committed to cultural preservation.

The city values its cultural heritage and takes active steps to preserve and promote traditional customs, crafts, and arts.

Hosts an annual International Film Festival.

The Elektrostal International Film Festival attracts filmmakers and cinema enthusiasts from around the world, showcasing a diverse range of films.

Encourages entrepreneurship and innovation.

Elektrostal supports aspiring entrepreneurs and fosters a culture of innovation, providing opportunities for startups and business development.

Offers a range of housing options.

Elektrostal provides diverse housing options, including apartments, houses, and residential complexes, catering to different lifestyles and budgets.

Home to notable sports teams.

Elektrostal is proud of its sports legacy, with several successful sports teams competing at regional and national levels.

Boasts a vibrant nightlife scene.

Residents and visitors can enjoy a lively nightlife in Elektrostal, with numerous bars, clubs, and entertainment venues.

Promotes cultural exchange and international relations.

Elektrostal actively engages in international partnerships, cultural exchanges, and diplomatic collaborations to foster global connections.

Surrounded by beautiful nature reserves.

Nearby nature reserves, such as the Barybino Forest and Luchinskoye Lake, offer opportunities for nature enthusiasts to explore and appreciate the region’s biodiversity.

Commemorates historical events.

The city pays tribute to significant historical events through memorials, monuments, and exhibitions, ensuring the preservation of collective memory.

Promotes sports and youth development.

Elektrostal invests in sports infrastructure and programs to encourage youth participation, health, and physical fitness.

Hosts annual cultural and artistic festivals.

Throughout the year, Elektrostal celebrates its cultural diversity through festivals dedicated to music, dance, art, and theater.

Provides a picturesque landscape for photography enthusiasts.

The city’s scenic beauty, architectural landmarks, and natural surroundings make it a paradise for photographers.

Connects to Moscow via a direct train line.

The convenient train connection between Elektrostal and Moscow makes commuting between the two cities effortless.

A city with a bright future.

Elektrostal continues to grow and develop, aiming to become a model city in terms of infrastructure, sustainability, and quality of life for its residents.

In conclusion, Elektrostal is a fascinating city with a rich history and a vibrant present. From its origins as a center of steel production to its modern-day status as a hub for education and industry, Elektrostal has plenty to offer both residents and visitors. With its beautiful parks, cultural attractions, and proximity to Moscow, there is no shortage of things to see and do in this dynamic city. Whether you’re interested in exploring its historical landmarks, enjoying outdoor activities, or immersing yourself in the local culture, Elektrostal has something for everyone. So, next time you find yourself in the Moscow region, don’t miss the opportunity to discover the hidden gems of Elektrostal.

Q: What is the population of Elektrostal?

A: As of the latest data, the population of Elektrostal is approximately XXXX.

Q: How far is Elektrostal from Moscow?

A: Elektrostal is located approximately XX kilometers away from Moscow.

Q: Are there any famous landmarks in Elektrostal?

A: Yes, Elektrostal is home to several notable landmarks, including XXXX and XXXX.

Q: What industries are prominent in Elektrostal?

A: Elektrostal is known for its steel production industry and is also a center for engineering and manufacturing.

Q: Are there any universities or educational institutions in Elektrostal?

A: Yes, Elektrostal is home to XXXX University and several other educational institutions.

Q: What are some popular outdoor activities in Elektrostal?

A: Elektrostal offers several outdoor activities, such as hiking, cycling, and picnicking in its beautiful parks.

Q: Is Elektrostal well-connected in terms of transportation?

A: Yes, Elektrostal has good transportation links, including trains and buses, making it easily accessible from nearby cities.

Q: Are there any annual events or festivals in Elektrostal?

A: Yes, Elektrostal hosts various events and festivals throughout the year, including XXXX and XXXX.

Was this page helpful?

Our commitment to delivering trustworthy and engaging content is at the heart of what we do. Each fact on our site is contributed by real users like you, bringing a wealth of diverse insights and information. To ensure the highest standards of accuracy and reliability, our dedicated editors meticulously review each submission. This process guarantees that the facts we share are not only fascinating but also credible. Trust in our commitment to quality and authenticity as you explore and learn with us.

Share this Fact:

• Entertainment
• Sports Sports Betting Podcasts Better Planet Vault Mightier Autos Newsletters Unconventional Vantage Experts Voices
• Subscribe for $1
• Sports Betting
• Better Planet
• Newsletters
• Unconventional

Russia Maps Show 25% of Moscow Without Power Amid Winter Freeze 'Emergency'

Russian President Vladimir Putin has ordered the nationalization of an ammunition plant in Moscow after a mechanical failure caused tens of thousands of Muscovites to lose heat and water amid freezing temperatures beginning last week.

On January 4, a heating main burst at the Klimovsk Specialized Ammunition Plant in the town of Podolsk, which is around 30 miles south of central Moscow. Since then, tens of thousands of Russians are reported to have no heating in their homes in the Moscow region amid subzero temperatures.

Affected areas include the cities of Khimki, Balashikha, Lobnya, Lyubertsy, Podolsk, Chekhov, Naro-Fominsk, and Podolsk, a map published by a Russian Telegram channel and shared on other social media sites shows.

⚡️Map of European cities where people complain about the lack of heating and electricity due to the restriction of #ruZZian energy supplies 😆😆😆😆😆 pic.twitter.com/o0kldiLwiy — Aurora Borealis 🤫 (@aborealis940) January 8, 2024

Other Russian media outlets reported that in Moscow, residents of Balashikha, Elektrostal, Solnechnogorsk, Dmitrov, Domodedovo, Troitsk, Taldom, Orekhovo-Zuyevo, Krasnogorsk, Pushkino, Ramenskoye, Voskresensk, Losino-Petrovsky, and Selyatino are also without power.

That means that in total, more than a quarter of Moscow's cities have been hit with power outages and a lack of heating.

Newsweek has contacted Russia's Foreign Ministry for comment via email.

Many residents have taken to publishing video appeals on social media to complain about their freezing conditions. In one clip, people living in Moscow say that they are left with no choice but to warm their homes with gas stoves, heaters, and "whatever else we can find." Others said they are lighting fires in the streets to keep warm.

Andrei Vorobyov, governor of the Moscow region, announced on Tuesday that Putin ordered the ammunition plant to be nationalized because two of its owners have been "located abroad." He didn't name the individuals.

"We received the right to take control of this boiler house within the framework of an emergency," Vorobiev said, adding that the plant's boiler room was managed "very poorly" and there was "virtually no qualified competent personnel."

Russia's Investigative Committee has opened a criminal case over Klimovsk Specialized Ammunition Plant not meeting safety requirements.

On Tuesday, the committee said that because of the incident, the deputy head of Podolsk's administration, the head of the plant's boiler house, and the general director of the ammunition plant had been detained.

Residents of Selyatino have described the situation as "some kind of struggle for survival," Russian Telegram channel ASTRA reported.

Power outages have also struck St. Petersburg, Rostov, Volgograd, Voronezh, Primorsky Territory, and Yekaterinburg.

Do you have a tip on a world news story that Newsweek should be covering? Do you have a question about the Russia-Ukraine war? Let us know via [email protected].

Uncommon Knowledge

Newsweek is committed to challenging conventional wisdom and finding connections in the search for common ground.

About the writer

Isabel van Brugen is a Newsweek Reporter based in Kuala Lumpur. Her focus is reporting on the Russia-Ukraine war. Isabel joined Newsweek in 2021 and had previously worked with news outlets including the Daily Express, The Times, Harper's BAZAAR, and Grazia. She has an M.A. in Newspaper Journalism at City, University of London, and a B.A. in Russian language at Queen Mary, University of London. Languages: English, Russian

You can get in touch with Isabel by emailing [email protected]  or by following her on X @isabelvanbrugen

To read how Newsweek uses AI as a newsroom tool, Click here.

• Newsweek magazine delivered to your door
• Newsweek Voices: Diverse audio opinions
• Enjoy ad-free browsing on Newsweek.com
• Comment on articles
• Newsweek app updates on-the-go

Top stories

Why the Supreme Court Can't Solve All of Donald Trump's Legal Problems

Arizona Republicans Rage at Fake Elector Indictments: 'Blatant Abuse'

Russia Spooks US With Space Nukes Pivot

Mike Johnson On Marjorie Taylor Greene: 'I Don't Think About Her At All'