Wow, translating the algo into code was tricky! Debugging was
challenging, frustrating, and ultimately rewarding. Two debugging
takeaways I can think of now:
1. Make the test case small, so it's easy to trace the whole thing
through;
2. For bigger test case, the example from lecture notes was helpful. I
just needed to set breakpoint intelligently to see the min and max
arrays.

Also, initializing the min and max value, then use the Math.min and
Math.max was interesting. I may need to remember that, that's why I have
the notes here!

I used the "sleep on it" technique and the algo came to me about the
time I fall asleep. I started working on this based on algo I thought in
my head first thing after my run and shower, and it worked! I then went
to edX forum to see what other people are saying. Frankly those forum
posts were confusing to me.

It was a bit tricky translating algo in course slide to code, especially
regarding array indexing. I left a bit and walked the dogs. After I came
back, my mind was clearer than before. Debugging after that solved the
problem!

Not too bad after case for 2 seqs is done. Just needed to add one more
dimension and take care to set values.

This one is pretty tricky. I solved it after reading online:
http://www.cs.umd.edu/~meesh/351/mount/lectures/lect25-longest-common-subseq.pdf
https://www.geeksforgeeks.org/longest-common-subsequence-dp-4/

To find a good test case that reveals the bug, I tried stress testing
(in commented out code), but the naive but correct algo is so
inefficient that I didn't have enough patience to let it finish. Anyway,
good practice of stress testing anyway.

I do want to record this because the algos were written based on lecture
slides, and it passed all my own tests. However, it didn't pass test 14
of 37 from course grader. I checked forums in both edX and Coursera, I
was not alone in having that issue, but neither forums provided the
answer to the 14th test case used by the grader.

Implementing the algo described in lecture. Getting 2 dimensional array
indexing right took a bit of time. Looking at the picture helped me in
realizing that the dimention should have been n+1 by m+1. First time
dealing with string edit distance and alignment game, pretty
interesting!

Once again, this is a challenging but fun puzzle to solve. Key
reflections are:
1. It pays to read and try to understand the problem as early as
possible. "Sleeping on it" really, really helps. Deep appreciation and
clarity came as I was thinking about it before falling asleep, walking
the dogs, and just be;
2. Small steps, but do take them! They lead to success! Hooray :)

Easy implementation of the algorithm described in course slide. It
helped that I named variables according to the pseudo code. Getting
array indexing right is always a bit tricky so pay attention.