Видео

What a sweet and simple explanation, thank you!

Very good explination!

from where can i find the slides, for any future revision

very good teaching, thank you!

Thank you so much professor Califf

thank you so much for this playlist

i am very thankful for you , i was losing my mind! until i watched your video❤

Thanks so much for a video. Clear explanation. Love it

thanks professor my professor was lowk trolling with this one!

This helped me so much, you explained it really well. Thank you

thank you so much for this video

Very clear! I love the way you explain it.

ABSOUELTLY THANK YOU

I need to know when do we include "term" and "factor" in the parse tree and how are they used.

Thanks for the video i love this

Thank you

This was great explanation. Thanks for the video. Subscribed right after!

very smooth explanation. thanks, Dr.

You just turned my prof's entire two hour lecture into a fifteen minute video. Thank you so much

I hate BNF.

At 18:25 we expected the difference between memory addresses in neighboring indexes to be 8 bytes, but looks like the difference between index 1 and 2 is only 2 bytes?

i have my oops exam tmrw, thankyu for this

I found this video not knowing anything about parse three and guezz what im thrilled getting 2 examples done

This was a great class to refresh my c++ knowledge for my new job. Straight to the point. The timestamps were very helpful to focus on the things I forgot. Thanks a lot!

It is very similar to Context-Free Grammar!

Thanks. The only video that actually made sense after 12 hours of studying gibberish

thank you

ahhhh feels like university again

still uncreal why this algorithm is O(N). We have O(N) non-leafs to visit, and each may have to go all the way down to the leaf, which means each may need O(logN) swaps. What's stopping ths from being O(N*logN)?

Underrated series

Really Well Explained!

Very clear. Thanks!

thank you!!

this is so helpful thank you! finally understand what flushing the buffer actually means

Excellent video/tutorial! Thanks a lot Dr Califf

słabe niestety eh duzo szczekania malo robienia

hello dear ms mary can i contact you privately - iam a begginner want to find ahelp to be a professional progamer and need a hand of help from you if you dont mind. thanks in advance

Finally someone who doesn't simply say that std::endl flushes the buffer, but explains it in more detail! Thank you very much.

thanks a lot! the applications section is very useful!

This is great explanation! Thank you very much! 🙏

You are an amazing teacher, thank you for this

very helpful. thank you

I've coded in C++ but it was ages ago and I've been coding in Java and C# for the last 25 and 15 years respectively. I love this series for all the same reasons as everyone else has said, definitely don't need beginner stuff, just need to understand better how to mentally translate to C++ and to understand the differences. This video says that dynamically allocated arrays are initialized and I'm not sure if it's just different now because of C++20 or something I did wrong, but it doesn't appear to be the case for me. I get some garbage numbers at the beginning of the dynamic and then a pile of zeros instead of it being all zeros like when you showed it. I realize I'm late to this party since all these videos were from a few years ago, but if you are looking for ideas on how to extend this series (or perhaps make a separate series?) I would be very excited to see a series of videos with topics that fit the category of "these are java.util things, and this is how you use C++ STL things that are similar."

Thank you for the video, really appreciate it.

This is it. If you don't understand dijkstra's with heaps, this demystifies it. I just looked at the code implementation and couldn't comprehend it, but this decomposition helped tremendously. The key takeaway is how the priority queue pushes down costly jumps to a node X, so when we get to that item in the queue, that node X will already be "marked" by a shorter path, meaning we can discard that item from the queue, essentially skipping steps. Moreover, since we push "up" the uncostly jumps, our "marks" essentially give us the shortest path to each node, meaning we can stop the algorithm as soon as we have marks equal to the number of nodes. If you imagine a big graph, you're going to "push down" into the queue a bunch of costly items, you're going to "mark" the nodes rather quickly, finding the shortest path as soon as you mark them all, and discarding a considerable amount of items in the process. Notice too, that if you have a huge number of edges, compared to vertices, you're doing a lot of work sorting edges in the queue, that you could spend doing lookups, so intuitively you can start being suspicious that this solution might be equal or worse than the naive approach. I am really pleased with what i unlocked watching this video, thank you Mary. You've also shown me i should, ideally, grab a pen and paper and just go through problems to understand them.

Only thing I would recommend is looking at cmake instead of make files. They are closer to the maven/gradle workflows, java/spring developers are use to.

Dr, why you stopped 😢

live roger reaction

Explained in a way that's very easy to understand and thanks for not giving the code. Now I can try it on my own and test my understanding

I wish I found you 10 years ago