Algorithms to study: FB | Google | Amazon | More | 2020 New graduate looking for FANG jobs

March 9, 2022

Here is the link.

Offers from Google L4 | Facebook E3 | Microsoft L60 | Amazon SDE1 (Experience)

Last Edit: April 1, 2020 4:48 AM

42.3K VIEWS

I would like to share my experience interviewing with Google, Facebook, Microsoft, Apple. I had a return offer from Amazon (SDE1). In the last 2 months, I took 6 phone screen, 4 onsites and got offers from Google (L4), Facebook (E3), Microsoft (L60). The TC information is at the end. I am also including my internship interview experience with Amazon.

I will try to add the equivalent leetcode questions (as many as I can remember).
Hope this will be helpful.

Profile:
MS in computer science (graduating in May 2020)
YOE : 2 before masters
Others: 1 internship at Amazon
Leetcode : 754 (E : 177, M : 451, H : 126)

Google | SDE L4 | Mountain View | March 2020 | (Accepted)

Application:
Contacted by recruiter. The position was for people with at least 2 YOE. The level will be decided by interview performance.

phone screen (45 min):
1 easy (string) , 1 hard (binary search, divide conquer) , 1 medium (string)
All 3 questions were LC questions, can be found in google's list in LC.
I felt the focus was more on basic understanding and approach towards the problem (rather than optimal solution). Bugs, incorrect syntax is totally fine as long as you can recognise them and fix it. One small note, practising coding on Google Doc can be a make or break factor. You don't want to get caught balancing braces during a LC hard.

virtual onsite:
4 technical rounds (45 min each), 1 behavioral round (45 min).
technical round 1 : 1 medium (linked list, recursion, multiple followups)
technical round 2 : 1 medium (string), 1 hard (graph)
technical round 3: 1 medium (Queue, follow-up on concurrency), 1 hard (binary search tree)
technical round 4: 1 easy (string), 1 hard (ad-hoc, minimax)
behavioral: Standard Googlyness questions (can be found online)

All questions were exact or slight variation of LC questions, more specifically from Google's list. Focus was more on optimal solution.

Leetode equvalent questions

1. median of two sorted array
2. Group Shifted Strings
3. Flatten a Multilevel Doubly Linked List
4. Redundant connection II
5. Bulls and Cows
6. Guess the word
7. Recover Binary Search Tree

Decision Process:
Google has a lengthy process following onsite: hiring committee approval, team matching, executive committee approval. The time required to complete this steps depends on recruiter, other deadlines, interview performance. Mine was completed in 10 days (onsite to receiving offer letter).
For compensation negotiation, levels.fyi is very helpful. It's always best to go to them asking for way more than you expect. They generally do not take that as a negative.

Overall experience was awesome.

Facebook | SDE E3 | Mountain View | March 2020 | (Offered)

Application:
Applied for new grad position. Standrad new grad application.

Phone Screen:
1 medium (string, followup: Dynamic programming)
1 medium(array, hashmap, followup : array, hashmap)
All questions were LC questions, can be found in facebook's list. The focus was on correctness, finding optimal solution.

Virtual Onsite
2 technical rounds, 1 behavioral + technical round
Technical round 1: 1 medium (binary search tree), 1 hard (DFS)
Technical round 2: 1 medium(string, not LC), 1 medium(backtracking, multiple followup: backtracking)
Technical + behavioral round: Standard facebook behavioral questions, 1 medium (not LC, backtracking, DP question)

All but 2 questions can be found in facebook's list. There was multiple followup in all questions. My last round did not go well (partly because of connection issues, and partly because I messed up).

Leetcode equivalent questions

1. Binary Tree Maximum Path Sum
2. Combination I & II
3. Valid Palindrome II & III
4. Subarray Sum Equals K
5. Product of Array Except Self
6. Next Permutation

decision process
It took them around 7 business days to make decision and another 2 days for paperwork.

Overall experience was great.

Microsoft | L60 | Redmond | March 2020 (Offered)

Application:
Contacted manager over linkedIn. This was a domain specific research SDE role and did not follow the standard new grad process. Manager worked with recruiter to setup everything.

Phone screen
1 medium (BFS).
Discussion on past project, experience and domain specific topics.

Onsite
5 technical rounds. Focus was on coding, domain knowledge, system design
Technical 1 : discussion on past publication, project, domain knowledge. No coding questions.
Technical 2 : 1 hard (Trie, BFS), 1 hard (string). 1 system design. domain specific case based questions.
Technical 3 : some behavioral, past experience, research related questions. case based questions
Technical 4: 1 hard (array), 1 medium(BFS).
Technical 5: Past experience, research related questions, case based questions.

All coding questions can be found in Microsoft's list in LC. System design question a standrad question found in Grkking the System design interview.
The domain specific questions were difficult and lot more focused on how handle scale.

Leetcode equivalent questions

1. Trapping Rain Water
2. Regular expression matching
3. Word search II
4. Maximum Width of Binary Tree
5. Shortest Path in Binary Matrix

Decision Process
They took 10 days to make a decision and sending an offer. This is strictly my personal opinion, but the negotiation process was not a great experience (lowballing with level, compensation, asking/hinting repetitively to sign).
Overall experience, mixed. (Team/engineers: great, recruiting process: not so much)

Apple | ML Engineer | Seattle | March 2020 (Passed)

Passed phone screens, Onsite was scheduled. But I had to cancel it.

Application
Contacted Manager over linkedIn.

Phone screen 1
1 medium (string), 1 medium (BFS). one ML case based question.
The coding questions can be found in Leetcode's top 100 questions.

Phone screen 2
This was focused around ML, no coding questions. ML questions were difficult and the interviewer went into details of each concept. Discussion around past experience, project, publication.

After 2 phone screen and another call with manager, they decided to schedule a onsite.
The overall experience was very very bad. Each phone screen was followed by a prolonged silence from recruiter. Because of that it took nearly 3.5 months to just complete 2 phone screens. Which is just ridiculous. I would have preferred to get rejected early on rather than continuing with this mess for so long.

I also, interviewed and got rejected from these companies/roles:

1. Facebook | Operation research scientist | Onsite reject
2. Stripe | new grad | Onsite reject
3. Bloomberg | new grad | Onsite reject

Stripe | new grad | Bay Area | October 2019 | Rejected
Application:
Applied through career page with referral.

Phone Screen:
1 extremely easy question related to custom sorting.

Onsite
3 Technical rounds, 1 behavioral round
Technical round 1 (Integration interview) : Use an HTTP library to implement some HTTP request testing. Clone a Git repo. It will contain couple of JSON files with HTTP request information, query information and expected response. Design the request and response functionality and check correctness of your implementation. I messed up in this round.
Behavioral round: Questions on past experience, projects, future goals. Standard behavioral questions.
Technical round 2 (Coding interview) : 1 easy question (similar to optimal account balancing, if you are not asked to do it optimally, i.e. the total number for transaction need not be minimum. Followup : optimal account balancing)
Technical round 3 (Bug squashing) : Clone a Git repo. It will have two/three bugs. You have to fix them. I fixed one and identified the source of the second bug but couldn't fix it.

Stripe is known for their unique interview process. I knew about the rounds and what kind question will be there, but still they caught me off guard. It's because there is no way to practice the integration and bug squash interview. The only weakness in their process is they don't have too many different questions and have limited number of tricks (but damn, they were good).

Amazon | SDE Intern | Seattle | March 2019 | Accepted
Application:
Carrer page with referral.

Online assessment:
Amazon sends 2 online assessments (OA) for internship. One OA includes 2 coding questions and another OA includes 6/7 debugging questions. To my knowledge, people solving more 4 debugging questions and 2 coding questions are safe.

Phone screen:
This is the final round for Amazon SDE intern role. Usually 1/2 questions. I was asked:
Number of islands
LRU cache

Decision Process:
I got result within 1 day. Generally, Amazon has a 5 business day response policy.

Interview process was pretty streamlined.
Amazon does not have the greatest recruiting team and it takes a while to get a response. Probably because they hire so many SDEs. Also, you generally don't have any control on team selection or project.

Preparation
I would love to share more of my experience and process. But, there is a lot of great preparation/experience posts on Leetcode, reddit and more importantly, I am too lazy to write. But, here's something I understood in this process.

1. Preparation is very subjective. Posts/guidelines are often not very helpful and unintentionally misleading. (yes, I see the irony here). If you are new to interviewing, it would be best to assume the first 2-3 interview you give will go horrendously bad (true story). But, that experience will allow you to finetune your process.

2. Most (or atleast FAANG) companies will ask questions from Leetcode or slight modification of a leetcode question( > 90% in my case). The only way to mitigate risk is to increase the number of question you know or have solved before. It's better to solve 800 LC questions than to trust your problem solving skill over phone in a 45 minutes window or in a cold conference room with a bunch of strangers staring at you. Company specific lists are a better option. Company specific lists can be found in section 'Companies' in Problem page (if you can afford leetcode premium, it's worth it).

3. Praticing interviewing over phone, virtual is important. So, something like Prmp can be very helpful. (Prmp offers free mocks). For onsite, if you have the luxury you can apply to 1/2 companies that you have no intention of joining or you know you won't get. This gave me a chance to adjust with travel, interviewing continuously for 3-4 hours (Note: May be considered unprofessional)

4. In most cases, luck is a make or break factor, your skill may not matter. In a FAANG internship interview, one guy was asked a single question : "Two sum", another guy was asked "AVL tree". This kind of messed up things happen all the time. I am pretty sure, if I am interviewed again I may or may not pass all the interviews. I just got lucky. The only way to deal with that is same as point 2.

5. If you need to use different languages for different interviews (in my case, ML interviews expected python and I prefer C++ for SDE interview) dedicate time to context switching. This might cause issues if you are not very comfortable with continous context switch.

TC information
TC includes base, stock (first year), sign-on bonus, performance bonus
Google L4 (MTV) : base 155K, TC : 325K
Facebook E3 (MTV): base 123K, TC 240K
Microsoft L60 (Redmond) : base 118K, TC 210K
Amazon L4 (Seattle): base 112K, TC 152K

googlefacebook offermicrosoft

March 19, 2022 - I like to take some time to prepare my own notes. 

My notes - I like to review those algorithms quickly:

1. median of two sorted array
2. Group Shifted Strings
3. Flatten a Multilevel Doubly Linked List
4. Redundant connection II
5. Bulls and Cows
6. Guess the word
7. Recover Binary Search Tree

1. Binary Tree Maximum Path Sum
2. Combination I & II
3. Valid Palindrome II & III
4. Subarray Sum Equals K
5. Product of Array Except Self
6. Next Permutation

1. Trapping Rain Water
2. Regular expression matching
3. Word search II
4. Maximum Width of Binary Tree
5. Shortest Path in Binary Matrix

Create a public list on Leetcode.com using my account. I did like to review and code carefully the algorithm called Recover binary search tree, Leetcode 99. 

Google India | New Grad 2021 | Bangalore/Hyderabad | October 2020 [Reject]

 Here is the link. 

Take my notes in the following:

Facts or arguments:

If you have not explained your approach, reached at right optimality and written code for 2 problems in a round, consider that interview as a doomed. No one will tell you this, but yes you are expected to do 2 questions flawlessly to get a HIRE verdict. Follow-ups may not be expected to be super correct but 2 questions must be coded and explained without their follow up variants. This comes from my extensive research and own experience.

My Background

• Final year student, B.Tech. CSE from a well known tier-2 college in India.
• Good amount of dev experience in Full Stack, Mobile and Embedded Linux.
• Internship in an AR hardware startup.
• Have an offer from a Unicorn Startup (Campus Placements).
• Decent academic record and did competitive coding for about an year (Not including LeetCode).

How I got the interview?

Recruiter approached me through email in the month of June (before my campus placements started) asked for fresh copy of my CV. Later in August I was contacted for a Google meet briefing and was told that I have been shortlisted for first round of Telephonic Interview, what's the process is going to be further and so on.

I don't know exact details of why I was approached by recruiter in the first place, but that could be due to Resume/LinkedIn profile/Kickstart performances. Try to maintain all three IMHO.

Preparation Style and Skill Level

At present and just before onsites, I had completed 607 questions with a split of 131 easy, 372 medium and 104 hard questions, Apart from this as I mentioned, I have some competitive coding experience of about 20-25 contests on Codeforces/Codechef.

My LeetCode contest rating is about 1800, with 25 contests so far.

Before telephonic rounds I had completed around a 500 questions. I don't remember the exact ratio of E:M:H but it was quite similar to what it is now.

My grinding intensified in first 3-4 months of lockdown, but I was more or less regular after that too.

The Telephonic Round

It was scheduled sometime around August end or September start.
I was asked 2 questions with follow up on 2nd question after some modifications.
First question was just a warmup, really easy implementation based. Second was a modified form of multisource parallel BFS. Kinda similar to Rotten Oranges, but with an element of parallelism involved where you had to run multisource BFS for two different sides (or lets say, two teams).

For this BFS question a matrix was provided initially, after I completed my solution he gave me a follow up that do we really need to pass a matrix to our function to solve this? He basically wanted an approach where you can only access matrix from an API and can't edit any cells.

Tip 1: This happens a lot in Google interviews, they want production level code from you in very first go actually. By production level I mean, use of APIs, proper abstractions and Iterator patterns (if problem involves iterating over some data). Using static variables or any other stuff like that will give nothing but wrong impression and will result in a NO-HIRE verdict irrespective of the fact that you were able to solve problem or not.

Tip 2: Follow ups in Google interviews are much more common than any other firms (or for those which I have interviewed with). You should keep that in mind that solving the initial question alone will almost never be enough and a follow up is waiting for you surely.

This round went well, I was able to solve everything nicely.
Recruiter called few days later and gave me my feedback. Although it was a green signal for on-sites, review wasn't really what I was expecting.

Review for Telephonic Interview

They said although my thinking and algorithmic skills were fine, I had done few syntax errors on the way. And even though I was able to rectify my code at the time of dry run or debug phase, It's not expected to be like that and should be perfect on the first go.

Yes you heard me right, They knit pick everything and why won't they. When you have a huge pool of talented applicants, things like these happen. So make sure you keep your mind and eyes open at all the times as this almost costed me onsites.

Onsites

Initially onsites were supposed to happen the very next week but my new point of contact advised me to take as much time as I needed for preparation as there will be a 9 month cool-down if I get rejected now. I then asked for 2 weeks time and he was okay with it.

For those who don't know, for onsites Google has 5 total rounds. 4 tech interviews, 1 Googlyness round.

Timeline: 3 tech rounds on one day, and remaining 1 tech + Googlyness round on some other day only if review is positive from first three rounds.

Onsite Interview 1

• Question 1

  Given an array A, where A[i] = j denotes the fact that player j finished the race before player i, and for the winner of race let's  say player k, A[k]=-1.  
  You need to print the order of the positions of players after race finishes
  
  Follow up: What if the data (array A) got courrupted, how will you take care of that. Return  -1 if there data is courrupted and order of player otherwise.
  

  Pretty easy warmup question. First version of the problem is pretty easy, just create an inverse mapping of array values and index and everything else is basically clear.

  For the second part I suggested that we can visualize this mapping as a dependency graph and then apply topological sort on it. If there is an error like cycle etc, it will be detected.

  He looked satisfied with this approach however I could clearly see that he knows that there exists a simple solution for this. My hunch is that this includes some kind a case work to enumerate all the possible error cases. Topological sort just felt natural to me at the moment.

• Question 2
  This was a hard one for me. As a matter of fact this problem appeared in a contest very next day of my interview.
  Window Queries Problem.
  Idea here is a tricky modification of merge intervals and sliding window.

  This is in fact a classic example of how Google interview questions are like, they are hardly ever about a hard CS concept, an algo or a fancy DS. But they are all about observation and application.

  I came close to solving this problem, finally gave right idea but at that point only 5 minutes were remaining so he asked me to code just the brute force solution.

Before I forget, I would like to add that no matter what anyone says, If you have not explained your approach, reached at right optimality and written code for 2 problems in a round, consider that interview as a doomed. No one will tell you this, but yes you are expected to do 2 questions flawlessly to get a HIRE verdict. Follow-ups may not be expected to be super correct but 2 questions must be coded and explained without their follow up variants. This comes from my extensive research and own experience.

Onsite Interview 2

This was 30 minutes after the first one.

Okay this was one of my worst interview performances ever, primarily because of bad taste from first interview as a result of not being able to code 2nd problem.

Given an array A, and the Q queries with each query having an integer K,
Return an interval A[i:j] that minimizes the following expression for each query/given K
| sum(A[i:j])-K |

Quickly gave a sub optimal, improved brute force solution involving prefix sums to calculate all the possible sum values of intervals, use a hashmap of these sum->intervals and binary search over keys of the hashmap to find value nearest to K

She needed a better approach. I should have given up, but I did a pretty bad thing, went on to try a wrong idea without thoroughly exploring it and checking it for correctness, so in middle of it I realize that its wrong and finally went with sub optimal solution. This interview was bombed for sure.

Here people have discussed a nice approach to this problem.

Onsite Interview 3

This was an enjoyable interview, but then again I was able to do only one question, actually the interviewer kept modifying it so you can say it was one questions with a lot of follow ups.

The question was exactly the same - Maximum Points You Can Obtain from Cards

Without wasting anytime I threw a DP solution with code, O(NK). He asked if I could do any better. I was confused at first, and reason for that is my skillset/background. I have solved problems on OJs, and not given many interviews. For me a problem like this screems dynamic programming if you have not given me any constarints to start with. And that is how situation was at that point. Immediate idea was to try my greedy hypothesis, and that failed as expected. Over next 5 minutes I came up with some micro optimization on DP solution but he finally said that linear time is possible and I should think in that direction. He said my core idea was right, but one insight is missing. This hint was enough and I came up with expeted approach. He asked me to code it, went over it and did some more micro optimizations.

Then he asked some follow ups.

Overall this was a good interview but I knew that even this one is practically screwed as I took alot of time in supposedly warmup variant of this question.

Tip 3: Interviewers will be happy to provide you with hints when you are stuck but keep in mind that every hint is a -10 points on your score cards in reality.

Onsites Review

Immediately after this final interview I had chat with my recruiter. She shared review and as expected overall it was not positive. Feedback stated that my coding style was nice, it was clean and upto the standard but my algorithmic skills were not up to the mark.

Well ofcourse I was sad, questioned my abilities and luck as any normal human being would do. But I accepted verdict nicely. For the next several days I went on to see what I missed in my preparation and what went wrong.

So here is what I lacked.

What went wrong/missing?

If you open up LinkedIn and see most of new grad or L3 engineers at Google India, you will find one thing common. All of them have extensive Competitve Coding profiles. Many of them are Candidate Masters or even Masters at codeforces.

In a country which produces millions of software engineers a year, competition is bound to be tough. We in India are at a point where competitve coding is compulsory to get a job and not a mind sport anymore.

So yes, a hardcore competitve coding experience was missing from my profile but that is not the only reason I failed, it was something else, it had something to do with my style of preparation.

• Most of my preparation was focussed on getting a campus placement and not an offcampus job. Oncampus placements have only one hurdle, online assessment. Once you clear OA, rest of the interviews are damn easy. But here in campus drives, OAs are focused on DS/Concept heavy questions for example having knowledge of articulation points, Bell's numbers and DP with bitmasking.
• This is quite opposite to Google interviews which are all ad-hoc, and logic focused
• I am now quite good with all these fancy DPs and complicated algorithms. But I suck at greedy problems.
• Even knowing that I lack ability to crack greedy/constructive problems, I ignored it (There is less chance that a non classic greedy problem would appear in any OA, and classic greedy problems I have got covered)
• Leetcode contests are helpful, but these days they are not, atleast for India. The easy first problems are sometimes about string formatting or running a loop, this will never appear in any companie's recruitments in India. The other problems at last are almost 3x difficulty of first two sometimes and hence whole contest becomes imbalanced.

So how will I prepare now?

Having seen that recruitment at Google requires alot that I dont have, a smart thing would be to work on that.
For the time being I will shift to websites like Binary Search and AtCoder where problem statements are short and don't require pointless mathematics that codeforces/codechef requires and at the same time helps in building good reasoning and logic.
I would still give weekly contests here, and hope they improve and become balanced.

Word of suggestion to LeetCode

There is a great need of content that is India focused, level of interviews here is just a little harder than west world. Maybe leetcode-in or something like that would be helpful as I am sure there is a huge Indian traffic on this site.

PS: Thanks LeetCode for the job offer I have right now, It might not be sufficient but for sure is a neccessary resource for coding interviews :).

Word of advice to New-Grads aspiring for Google

• Stop wasting time in anything else you are doing right now, start today because when this interview chance knocks on your door, you might not be ready and wished you had started training a year earlier.

• Extensive competive coding experience + lesser dev experience is often better that lesser competitve coding experience and more dev experience atleast for freshers.

Feel free to comment if you agree/disagree with my thoughts. Also if you have any better approaches for any of the above problems, please share. Thankyou

binary-searchgoogle-indiacompetitve-programming

Leetcode discuss: Leetcode 10: regular expression

Here is the link. 

Case study - mock interview as an interviewer on July 2, 2017

July 2, 2020

Introduction
It is a good idea to review what I learned as an interviewer and then write a post after three years. Here is the blog about mock interview.

The following is C# code to pass online judge.

public class Solution {
    //public bool IsMatch(string s, string p) {
    public bool IsMatch(string text, string pattern)
        {
            if (text == null || pattern == null)
            {
                return false;
            }

            if (pattern.Length == 0)
            {
                return text.Length == 0; 
            }

            var test_pattern = pattern[0]; //#
            bool isStar = pattern.Length > 1 && pattern[1] == '*';
            bool firstCharMatching = text.Length > 0 &&
                                    (test_pattern == '.' || text[0] == test_pattern);            

            if (pattern.Length > 1 && isStar)
            {
                return IsMatch(text, pattern.Substring(2)) ||
                (firstCharMatching &&IsMatch(text.Substring(1), pattern));                 
            }
            else if (firstCharMatching)
            {
                return IsMatch(text.Substring(1), pattern.Substring(1));
            }
            else
            {
                return false; 
            }
        }
}

Leetcode discuss: Leetcode 10: regular expression

Here is the link.

Case study: dynamic programming solution on January 26, 2018

July 2, 2020
My practice was on January 26, 2018. Here is my blog to document my experience.

Case study
It is a good idea to work on a simple test case, and then build a table to calculate the value of regular expression matching.

I like to share the table I prepared on my blog in 2018. Here is the blog.

Test case: acd with "abc" pattern string

public class Solution {
    public bool IsMatch(string text, string pattern)
        {
            if (text == null || pattern == null) // false 
            {
                return false;
            }

            var tLength = text.Length; // 0 
            var pLength = pattern.Length; // 4

            var dp = new bool[tLength + 1, pLength + 1]; // 1, 5

            dp[0, 0] = true; // 

            for (int i = 1; i < tLength + 1; i++)
            {
                dp[i, 0] = false;
            }

            // "" matches "a*b*" etc. 
            for (int i = 1; i < pLength + 1; i++)
            {                
                dp[0, i] = i >= 2 && pattern[i - 1] == '*' && dp[0, i - 2]; 
            }

            for (int row = 1; row < tLength + 1; row++)
            {
                for (int col = 1; col < pLength + 1; col++)
                {
                    var visitChar = text[row - 1];
                    var patternChar = pattern[col - 1];

                    var isStar = patternChar == '*';
                    if (!isStar)
                    {                        
                        dp[row, col] = (patternChar == '.' || visitChar == patternChar) && dp[row - 1, col - 1];                        
                    }
                    else
                    {                                  
                        dp[row, col] = col >= 2 &&
                             // zero time
                            (( dp[row, col - 2]) ||
                             //                                                                  one time         || more than one time
                             ((pattern[col - 2] == '.' || visitChar == pattern[col - 2]) && (dp[row - 1, col - 2] || dp[row - 1, col])));
                    }

                    /*
                     * code review on May 9, 2019
                     * "mississippi"
                       "mis*is*p*."
                    else
                    {                            //   zero time          one time           more then one time        
                        dp[row, col] = col >= 2 && (dp[row, col - 2] || dp[row, col - 1] || dp[row - 1, col]);
                    } 
                     */
                }
            }

            return dp[tLength, pLength];
        }
}

Leetcode discuss: Leetcode 10: regular expression

Here is the link. 

C# My showcase of practice starting from 2017

July 2, 2020

It take some time for me to review all my past practice on this hard level algorithm. What I like to do is to write a few discussion posts first, and then I will figure out how to review those practice.

I went through very good learning experience to work with over 10 programmers as an interviewer or interviewee. I documented my p-r-a-m-p mock interview website over 10 times practice here.

Leetcode 10: regular expression
July 2, 2017
Case study - mock interview as an interviewer on July 2, 2017

C# code review memoization practice on July 2 2017

January 26, 2018
Case study: dynamic programming solution on January 26, 2018

April 21, 2018
Case study: mock interview as an interviewee on April 21, 2018

Practice with a bug
March 29, 2018
Case study: dynamic programming solution with a bug on March 29, 2018