Coding Our Optimal Solution And Testing On LeetCode

Master the Coding Interview: Big Tech (FAANG) Interviews

Introduction

Master The Coding Interview: Big Tech (FAANG) Interview (2:34)
Course Breakdown (11:04)
Exercise: Meet Your Classmates and Instructor
Download All Code + Solutions
ZTM Plugin + Understanding Your Video Player
Set Your Learning Streak Goal

Arrays - Question #1 Google Interview Question Two Sum (Easy)

Interview Question #1 Two Sum (7:14)
How To Approach Our Problem (11:45)
Writing Our Brute Force Solution (6:40)
Testing Our Solution With Our Test Cases (9:23)
Submitting To Leetcode (1:49)
Analyzing Space and Time Complexity (10:37)
Optimizing Our Solution (8:06)
Coding Our Optimal Solution (5:21)
Testing Our Optimal Solution With Our Test Cases (8:02)
Checking Performance On LeetCode (3:24)
Solution In Other Languages
Let's Have Some Fun (+ Free Resources)

Arrays - Questions #2 - Container With Most Water (Medium)

Interview Question #2 - Container With Most Water (4:46)
Coming Up With Test Cases (4:19)
Thinking Through A Logical Brute Force Solution (12:49)
Coding Out Our Brute Force Solution (7:20)
Stepping Through Our Code (4:44)
Thinking About Our Optimal Solution (13:52)
Coding Our Optimal Solution And Testing On LeetCode (9:50)
Unlimited Updates

Arrays - Questions #3 - Trapping Rainwater (Hard)

Interview Question #3 - Trapping Rainwater (7:19)
Thinking About A Logical Solution (12:45)
Coding Our Brute Force Solution (8:52)
Figuring Out Our Optimization Strategy (24:26)
Coding Our Optimal Solution (13:26)
Optimal Code And Testing On LeetCode (2:09)
Course Check-In

Strings - Question #4 - Typed Out Strings (Easy)

Interview Question #4 -Typed Out Strings (7:08)
Logic Of Our Brute Force Solution (8:02)
Coding Our Brute Force Solution (9:37)
Space And Time Complexity (7:22)
Coming Up With Optimal Solution (11:52)
Coding Our Optimal Solution (12:35)
Submitting To LeetCode (5:51)
Implement a New Life System

Strings - Question #5 - Longest Substring Without Repeating Characters (Medium)

Interview Question #5 - Longest Substring Without Repeating Characters (6:39)
Coming Up With A Brute Force Approach (6:34)
Coding Our Brute Force Solution (9:57)
Space And Time Complexity (3:16)
Sliding Window Technique (5:18)
Hints For Optimizing Our Solution (2:15)
Thinking About Optimal Solution (9:09)
Coding Our Optimal Solution (8:30)
Note: Correction for explanation of +1
Optimal Code And Testing On LeetCode (3:18)

Strings - Question #6 - Valid Palindrome & Almost Palindrome

Intro To Palindromes (9:41)
Interview Question #6 - Valid Palindrome (8:39)
Almost A Palindrome (10:15)
Figuring Out Our Solution (6:50)
Coding Our Solution (9:46)

Introducing Linked Lists - Basics and Reverse A Linked List

Linked List Introduction (3:58)
Basic Algorithm: Reverse a Linked List (8:21)
Thinking About Our Solution (10:55)
Coding Reverse A Linked List Solution (7:07)

Linked List - Question #7 - M, N Reversals (Medium)

Interview Question #7 - M, N Reversals (6:50)
Coming Up With A Logical Solution (16:33)
Coding Our Solution (15:38)

Linked List - Question #8 - Merge Multi-Level Doubly Linked List (Medium)

Interview Question #8 - Merge Multi-Level Doubly Linked List (8:52)
Figuring Out Our Test Cases (8:34)
Thinking About Our Approach (16:47)
Coding Out Our Solution (14:37)

Linked List - Question #9 - Cycle Detection (Medium)

Interview Question #9 - Cycle Detection (11:39)
Floyd's Tortoise And Hare (3:04)
Coding Floyd's Algorithm (8:54)
Optional: Proof Of How Floyd's Algorithm Works (25:51)

Stacks - Question #10 - Valid Parentheses (Easy)

Intro to Stacks and Queues (3:11)
Interview Question #10 - Valid Parentheses (9:23)
Walking Through Our Problem - Identifying The Need For A Stack (8:15)
Coding Our Solution With A Stack (9:18)

Stacks - Question #11 - Minimum Brackets To Remove (Medium)

Interview Question #11 - Minimum Brackets To Remove (7:38)
Thinking About Our Solution (12:45)
Coding Our Solution (10:53)

Queues - Question #12 - Implement Queue With Stacks (Easy)

Question #12 - Implement Queue With Stacks (4:10)
Figuring Out Our Solution (10:19)
Coding Our Solution (8:27)

Recursion (Sorting and Hoare's QuickSelect) - Question #13 - Kth Largest Element

Introducing Recursion (3:07)
Optional: Tail Recursion (19:54)
Sorting (2:23)
Interview Question #13 - Kth Largest Element (6:50)
Insights From Quick Sort (12:36)
Understanding Divide And Conquer (8:17)
Coding Quicksort Into Our Solution (14:53)
Understanding Hoare's Quickselect Algorithm (6:55)
Coding Our Solution With Quickselect (11:47)
Correction About Time Complexity!

Recursion (Binary Search) - Question #14 - Start And End Of Target (Medium)

Understanding Binary Search (9:32)
How To Code Binary Search (6:22)
Question #14 - Start And End Of Target In A Sorted Array (5:05)
Walking Through Our Solution (10:48)
Coding Our Solution (12:55)

Binary Trees - Question #15 - Maximum Depth Of Binary Tree (Easy)

Intro to Binary Trees (1:52)
Question #15 - Maximum Depth of Binary Tree (6:54)
Learning The Process For Solving Binary Tree Problems (19:12)
Coding Our Solution (6:11)

Binary Trees - Question #16 - Level Order Of Binary Tree (Medium)

Question #16 - Level Order Of Binary Tree (5:28)
Walking Through Our Solution (17:27)
Coding Out Level Order Traversal (11:38)

Binary Trees - Question #17 - Right Side View of Tree (Medium)

Question #17 - Right Side View of Tree (6:43)
Understanding The Breadth First Search Approach (8:26)
Understanding The Depth First Search Approach (9:22)
Thinking About Pre-Order, In-Order, and Post-Order Traversals For Our Solution (12:23)
Completing Our DFS Solution (7:41)
Coding Our Final DFS Solution (11:55)

Full & Complete Binary Trees - Question #18 - Number Of Nodes In Complete Tree

Question #18 - Number Of Nodes In Complete Tree (8:31)
Thinking Deeply About A Full Binary Tree (10:26)
Figuring Out Number Of Nodes At Last Level (15:28)
Coding Out Our Full Solution (20:39)

Binary Search Tree - Question #19 - Validate Binary Search Tree (Medium)

Question #19 - Validate Binary Search Tree (8:47)
Thinking About Our Logical Solution (15:04)
Figuring Out Our Boundaries (6:53)
Coding Our Our Full Solution (7:58)

Heaps & Priority Queues

Introducing Heaps (8:45)
Insertion In Heaps - Understanding Sift Up (7:35)
Deletion In Heaps - Understanding Sift Down (10:48)
Starting To Code Our Priority Queue Class (10:48)
Coding Our Insertion And Sift Up Methods (5:49)
Coding Our Deletion And Sift Down Methods (13:00)

Intro To 2D-Arrays - Basics & Traversal Algorithms

Introducing 2D Arrays - What Are They? (7:23)
Depth First Search In 2D-Arrays (7:24)
Coding DFS - Setting Up For DFS (9:43)
Coding DFS - Implementing Recursive DFS (8:40)
Breadth First Search In 2D-Arrays (7:48)
Coding BFS (10:05)
Exercise: Imposter Syndrome (2:55)

2D-Arrays - Question #20 Number Of Islands (Medium)

A General Approach To Thinking About Most Graph Questions (9:09)
Question #20 Number Of Islands (7:50)
Approaching Our Problem - Thinking Deeply About The Values (16:11)
Approaching Our Problem - Thinking About Traversals (8:55)
Coding Our Solution (19:08)
Thinking About Space And Time Complexity (14:38)

2D-Arrays - Question #21 Rotting Oranges (Medium)

Question #21 Rotting Oranges (6:57)
Figuring Out Our Initial Logic (11:04)
Figuring Out The Rest Of Our Solution (14:27)
Coding Out Our Solution (14:47)

2D-Arrays - Question #22 - Walls And Gates (Medium)

Question #22 - Walls And Gates (6:19)
Figuring Out Our Logical Solution (12:16)
Coding Out Our Solution (11:45)

Intro to Graphs - Representation & Traversal Algorithms

Introduction To The Types Of Graphs (11:06)
Representing Our Graphs - Adjacency List & Adjacency Matrix (7:19)
Breadth First Search In Graphs (4:39)
Coding BFS (7:53)
Depth First Search In Graphs (3:03)
Coding DFS (7:03)

Graphs - Question #23 - Time Needed to Inform All Employees (Medium)

Question #23 - Time Needed to Inform All Employees (12:51)
Verifying Our Constraints And Thinking About Test Cases (8:12)
How To Represent Our Graph As An Adjacency List (9:37)
Solving Our Problem Logically Using DFS Traversal (7:48)
Coding Our DFS Solution (10:01)

Graphs - Question #24 - Course Scheduler (Medium)

Question #24 - Course Scheduler (10:24)
Thinking About Our Initial Solution - BFS (7:56)
Coding Out Our Initial BFS Solution (15:28)
What is Topological Sort? (7:55)
Thinking About A Solution With Topological Sort (4:49)
Coding Our Final Solution (15:47)

Graphs - Question #25 - Network Time Delay (Medium)

Question #25 - Network Time Delay (12:39)
Thinking About How To Approach The Problem (8:37)
Greedy Method & What Is Dijkstra's Algorithm? (15:30)
Thinking About A Solution With Dijkstra's Algorithm (8:55)
Coding Our Solution With Dijkstra (17:32)
Time And Space Complexity Of Our Solution (13:08)
Thinking About Negative Weights (7:41)
What is The Bellman-Ford Algorithm? - Conceptualizing Dynamic Programming (16:22)
What is The Bellman-Ford Algorithm? - The Algorithm Itself (16:17)
Coding Our Solution With Bellman-Ford (9:19)

Dynamic Programming - Question #26 - Minimum Cost Of Climbing Stairs (Easy)

Question #26 - Minimum Cost Of Climbing Stairs & How To Approach DP (9:38)
Understanding & Identifying Recurrence Relation (15:48)
First Step - Recursive Solution From Recurrence Relation (5:34)
Second Step - Memoizing Our Redundant Recursive Calls (7:49)
Coding Our Memoization Optimization (7:50)
Understanding The Bottom Up Approach (Tabulation) (6:29)
Third Step - Bottom Up Tabulation (5:24)
Fourth Step - Bottom Up Optimization (6:52)

Dynamic Programming - Question #27 - Knight Probability In Chessboard (Medium)

Question #27 - Knight Probability In Chessboard (10:09)
Thinking About Test Cases To Help Us (3:51)
Identifying The Recurrence Relation (15:29)
First Step - Recursive Solution From Recurrence Relation (5:10)
Second Step - Memoizing Our Redundant Recursive Calls (14:13)
Figuring Out The Logic For Our Bottom Up Solution (13:59)
Third Step - Bottom Up Tabulation (8:31)
Fourth Step - Bottom Up Optimization (6:55)
Dynamic Programming Question List

Backtracking - Question #28 - Sudoku Solver (Hard)

Understanding The Basics Of Backtracking (7:06)
Question #28 - Sudoku Solver (4:19)
Learning The Backtracking Template (11:18)
Applying Our Backtracking Template To Sudoku Solver Logic (6:42)
Coding How To Get Box ID (7:49)
Setting Up Our Solution Code (7:05)
Coding The Recursive Backtracking Portion Of Our Solution (19:18)
Thinking About The Space And Time Complexity (6:58)

Interface Design - Question #29 - Monarchy

Understanding Interface Design & Question #29 - Monarchy (10:52)
Figuring Out Our Test Cases (5:57)
Thinking About The Logical Of The Monarchy (9:41)
Coding Our Monarchy Solution (14:57)

Tries - Question #30 - Implement Prefix Trie (Medium)

Introducing Tries (1:07)
Question #30 - Implement Prefix Trie (9:49)
Understanding The Logic For Our Methods (3:54)
Implementing Our Prefix Trie Data Structure Solution (15:15)

Where To Go From Here?

Thank You! (1:17)
Review This Course!
Become An Alumni
Learning Guideline
ZTM Events Every Month
LinkedIn Endorsements

Appendix: Big O

Note About Appendix Videos
Section Overview (2:24)
What Is Good Code? (6:57)
Big O and Scalability (11:08)
O(n) (5:39)
O(1) (6:10)
Exercise: Big O Calculation
Solution: Big O Calculation (5:54)
Exercise: Big O Calculation 2
Solution: Big O Calculation 2 (2:29)
Simplifying Big O (1:50)
Big O Rule 1 (4:28)
Big O Rule 2 (6:36)
Big O Rule 3 (3:13)
O(n^2) (7:13)
Big O Rule 4 (6:47)
Big O Cheat Sheet (3:18)
What Does This All Mean? (5:32)
O(n!) (1:18)
3 Pillars Of Programming (3:32)
Space Complexity (2:22)
Exercise: Space Complexity (6:24)
Exercise: Twitter (7:13)
Section Summary (4:43)

Appendix: Arrays

Arrays Introduction (13:51)
Static vs Dynamic Arrays (6:40)
Optional: Implementing An Array (17:19)

Appendix: Hash Tables

Hash Tables Introduction (4:10)
Hash Function (5:56)
Hash Collisions (9:43)
Hash Tables VS Arrays (2:01)

Appendix: Linked Lists

Linked Lists Introduction (2:26)
What Is A Linked List? (4:36)
Exercise: Why Linked Lists? (2:05)
Solution: Why Linked Lists? (5:35)
What Is A Pointer? (5:45)
Doubly Linked Lists (3:18)
Singly VS Doubly Linked Lists (2:40)
Linked Lists Review (5:07)

Appendix: Stacks + Queues

Stacks + Queues Introduction (2:58)
Stacks (3:28)
Queues (3:30)
Exercise: Stacks VS Queues (3:06)
Solution: Stacks VS Queues (3:39)
Stacks + Queues Review (2:19)

Appendix: Trees

Trees Introduction (6:23)
Binary Trees (5:45)
O(log n) (7:00)
Binary Search Tree (6:12)
Balanced VS Unbalanced BST (3:42)
BST Pros and Cons (2:26)
Trie (3:16)

Appendix: Searching + BFS + DFS

Graph + Tree Traversals (3:56)
BFS Introduction (2:44)
DFS Introduction (3:23)
BFS vs DFS (3:20)
Exercise: BFS vs DFS (0:44)
Solution: BFS vs DFS (3:16)
breadthFirstSearch() (9:15)
PreOrder, InOrder, PostOrder (5:21)
depthFirstSearch() (12:03)

Appendix: Recursion

Recursion Introduction (5:36)
Stack Overflow (6:17)
Anatomy Of Recursion (10:27)
Recursive VS Iterative (4:16)
When To Use Recursion (4:00)
Recursion Review (2:47)

Appendix: Sorting

Sorting Introduction (7:01)
The Issue With sort() (6:51)
Sorting Algorithms (3:37)
Bubble Sort (3:45)
Exercise: Bubble Sort
Solution: Bubble Sort (5:06)
Selection Sort (2:39)
Exercise: Selection Sort
Solution: Selection Sort (2:23)
Dancing Algorithms (1:36)
Exercise: Insertion Sort
Insertion Sort (2:38)
Solution: Insertion Sort (2:06)
Merge Sort and O(n log n) (8:59)
Exercise: Merge Sort
Solution: Merge Sort (4:44)
Quick Sort (7:40)

Coding Our Optimal Solution And Testing On LeetCode

This lecture is available exclusively for ZTM Academy members.

If you're already a member, you'll need to login.

Join ZTM To Unlock All Lectures