Class Central is learner-supported. When you buy through links on our site, we may earn an affiliate commission.

Zero To Mastery

Master the Coding Interview: Big Tech (FAANG) Interviews

via Zero To Mastery

Go to class Write review

Overview

Get hired by Google, Amazon, Facebook, Microsoft, Apple, Netflix by acing their coding interview. This course gives you the step-by-step guide and framework for solving their toughest technical questions!
  • Ace the coding interview at top tech companies (Google, Amazon, Facebook/Meta, Apple, Microsoft, Netflix + others)
  • Step-by-step guide to solving common questions and how to best present them during the tech interview
  • The ultimate resource to prepare for coding interviews, tech interviews and programming interviews
  • Insider tips & tricks from instructors who have worked for big tech companies and actually gone through and aced the interview process
  • A mental framework on how to approach solving coding problems so that you can become a better problem solver and answer ANY question companies throw at you
  • Use the right Data Structures and Algorithms to pass coding interview questions that have the optimal solution
  • Become a better developer by mastering Computer Science fundamentals
  • Learn exactly what you need to answer the most difficult questions

Syllabus

  •   Introduction
    • Master The Coding Interview: Big Tech (FAANG) Interview
    • Course Breakdown
    • Exercise: Meet Your Classmates and Instructor
    • Download All Code + Solutions
    • How-to's: Speed up videos, Downloading videos, Subtitles
    • Unlimited Updates
  •   Arrays - Question #1 Google Interview Question Two Sum (Easy)
    • Interview Question #1 Two Sum
    • How To Approach Our Problem
    • Writing Our Brute Force Solution
    • Testing Our Solution With Our Test Cases
    • Submitting To Leetcode
    • Analyzing Space and Time Complexity
    • Optimizing Our Solution
    • Coding Our Optimal Solution
    • Testing Our Optimal Solution With Our Test Cases
    • Checking Performance On LeetCode
    • Solution In Other Languages
  •   Arrays - Questions #2 - Container With Most Water (Medium)
    • Interview Question #2 - Container With Most Water
    • Coming Up With Test Cases
    • Thinking Through A Logical Brute Force Solution
    • Coding Out Our Brute Force Solution
    • Stepping Through Our Code
    • Thinking About Our Optimal Solution
    • Coding Our Optimal Solution And Testing On LeetCode
  •   Arrays - Questions #3 - Trapping Rainwater (Hard)
    • Interview Question #3 - Trapping Rainwater
    • Thinking About A Logical Solution
    • Coding Our Brute Force Solution
    • Figuring Out Our Optimization Strategy
    • Coding Our Optimal Solution
    • Optimal Code And Testing On LeetCode
  •   Strings - Question #4 - Typed Out Strings (Easy)
    • Interview Question #4 -Typed Out Strings
    • Logic Of Our Brute Force Solution
    • Coding Our Brute Force Solution
    • Space And Time Complexity
    • Coming Up With Optimal Solution
    • Coding Our Optimal Solution
    • Submitting To LeetCode
  •   Strings - Question #5 - Longest Substring Without Repeating Characters (Medium)
    • Interview Question #5 - Longest Substring Without Repeating Characters
    • Coming Up With A Brute Force Approach
    • Coding Our Brute Force Solution
    • Space And Time Complexity
    • Sliding Window Technique
    • Hints For Optimizing Our Solution
    • Thinking About Optimal Solution
    • Coding Our Optimal Solution
    • Note: Correction for explanation of +1
    • Optimal Code And Testing On LeetCode
  •   Strings - Question #6 - Valid Palindrome & Almost Palindrome
    • Intro To Palindromes
    • Interview Question #6 - Valid Palindrome
    • Almost A Palindrome
    • Figuring Out Our Solution
    • Coding Our Solution
  •   Introducing Linked Lists - Basics and Reverse A Linked List
    • Linked List Introduction
    • Basic Algorithm: Reverse a Linked List
    • Thinking About Our Solution
    • Coding Reverse A Linked List Solution
  •   Linked List - Question #7 - M, N Reversals (Medium)
    • Interview Question #7 - M, N Reversals
    • Coming Up With A Logical Solution
    • Coding Our Solution
  •   Linked List - Question #8 - Merge Multi-Level Doubly Linked List (Medium)
    • Interview Question #8 - Merge Multi-Level Doubly Linked List
    • Figuring Out Our Test Cases
    • Thinking About Our Approach
    • Coding Out Our Solution
  •   Linked List - Question #9 - Cycle Detection (Medium)
    • Interview Question #9 - Cycle Detection
    • Floyd's Tortoise And Hare
    • Coding Floyd's Algorithm
    • Optional: Proof Of How Floyd's Algorithm Works
  •   Stacks - Question #10 - Valid Parentheses (Easy)
    • Intro to Stacks and Queues
    • Interview Question #10 - Valid Parentheses
    • Walking Through Our Problem - Identifying The Need For A Stack
    • Coding Our Solution With A Stack
  •   Stacks - Question #11 - Minimum Brackets To Remove (Medium)
    • Interview Question #11 - Minimum Brackets To Remove
    • Thinking About Our Solution
    • Coding Our Solution
  •   Queues - Question #12 - Implement Queue With Stacks (Easy)
    • Question #12 - Implement Queue With Stacks
    • Figuring Out Our Solution
    • Coding Our Solution
  •   Recursion (Sorting and Hoare's QuickSelect) - Question #13 - Kth Largest Element
    • Introducing Recursion
    • Optional: Tail Recursion
    • Sorting
    • Interview Question #13 - Kth Largest Element
    • Insights From Quick Sort
    • Understanding Divide And Conquer
    • Coding Quicksort Into Our Solution
    • Understanding Hoare's Quickselect Algorithm
    • Coding Our Solution With Quickselect
    • Correction About Time Complexity!
  •   Recursion (Binary Search) - Question #14 - Start And End Of Target (Medium)
    • Understanding Binary Search
    • How To Code Binary Search
    • Question #14 - Start And End Of Target In A Sorted Array
    • Walking Through Our Solution
    • Coding Our Solution
  •   Binary Trees - Question #15 - Maximum Depth Of Binary Tree (Easy)
    • Intro to Binary Trees
    • Question #15 - Maximum Depth of Binary Tree
    • Learning The Process For Solving Binary Tree Problems
    • Coding Our Solution
  •   Binary Trees - Question #16 - Level Order Of Binary Tree (Medium)
    • Question #16 - Level Order Of Binary Tree
    • Walking Through Our Solution
    • Coding Out Level Order Traversal
  •   Binary Trees - Question #17 - Right Side View of Tree (Medium)
    • Question #17 - Right Side View of Tree
    • Understanding The Breadth First Search Approach
    • Understanding The Depth First Search Approach
    • Thinking About Pre-Order, In-Order, and Post-Order Traversals For Our Solution
    • Completing Our DFS Solution
    • Coding Our Final DFS Solution
  •   Full & Complete Binary Trees - Question #18 - Number Of Nodes In Complete Tree
    • Question #18 - Number Of Nodes In Complete Tree
    • Thinking Deeply About A Full Binary Tree
    • Figuring Out Number Of Nodes At Last Level
    • Coding Out Our Full Solution
  •   Binary Search Tree - Question #19 - Validate Binary Search Tree (Medium)
    • Question #19 - Validate Binary Search Tree
    • Thinking About Our Logical Solution
    • Figuring Out Our Boundaries
    • Coding Our Our Full Solution
  •   Heaps & Priority Queues
    • Introducing Heaps
    • Insertion In Heaps - Understanding Sift Up
    • Deletion In Heaps - Understanding Sift Down
    • Starting To Code Our Priority Queue Class
    • Coding Our Insertion And Sift Up Methods
    • Coding Our Deletion And Sift Down Methods
  •   Intro To 2D-Arrays - Basics & Traversal Algorithms
    • Introducing 2D Arrays - What Are They?
    • Depth First Search In 2D-Arrays
    • Coding DFS - Setting Up For DFS
    • Coding DFS - Implementing Recursive DFS
    • Breadth First Search In 2D-Arrays
    • Coding BFS
    • Exercise: Imposter Syndrome
  •   2D-Arrays - Question #20 Number Of Islands (Medium)
    • A General Approach To Thinking About Most Graph Questions
    • Question #20 Number Of Islands
    • Approaching Our Problem - Thinking Deeply About The Values
    • Approaching Our Problem - Thinking About Traversals
    • Coding Our Solution
    • Thinking About Space And Time Complexity
  •   2D-Arrays - Question #21 Rotting Oranges (Medium)
    • Question #21 Rotting Oranges
    • Figuring Out Our Initial Logic
    • Figuring Out The Rest Of Our Solution
    • Coding Out Our Solution
  •   2D-Arrays - Question #22 - Walls And Gates (Medium)
    • Question #22 - Walls And Gates
    • Figuring Out Our Logical Solution
    • Coding Out Our Solution
  •   Intro to Graphs - Representation & Traversal Algorithms
    • Introduction To The Types Of Graphs
    • Representing Our Graphs - Adjacency List & Adjacency Matrix
    • Breadth First Search In Graphs
    • Coding BFS
    • Depth First Search In Graphs
    • Coding DFS
  •   Graphs - Question #23 - Time Needed to Inform All Employees (Medium)
    • Question #23 - Time Needed to Inform All Employees
    • Verifying Our Constraints And Thinking About Test Cases
    • How To Represent Our Graph As An Adjacency List
    • Solving Our Problem Logically Using DFS Traversal
    • Coding Our DFS Solution
  •   Graphs - Question #24 - Course Scheduler (Medium)
    • Question #24 - Course Scheduler
    • Thinking About Our Initial Solution - BFS
    • Coding Out Our Initial BFS Solution
    • What is Topological Sort?
    • Thinking About A Solution With Topological Sort
    • Coding Our Final Solution
  •   Graphs - Question #25 - Network Time Delay (Medium)
    • Question #25 - Network Time Delay
    • Thinking About How To Approach The Problem
    • Greedy Method & What Is Dijkstra's Algorithm?
    • Thinking About A Solution With Dijkstra's Algorithm
    • Coding Our Solution With Dijkstra
    • Time And Space Complexity Of Our Solution
    • Thinking About Negative Weights
    • What is The Bellman-Ford Algorithm? - Conceptualizing Dynamic Programming
    • What is The Bellman-Ford Algorithm? - The Algorithm Itself
    • Coding Our Solution With Bellman-Ford
  •   Dynamic Programming - Question #26 - Minimum Cost Of Climbing Stairs (Easy)
    • Question #26 - Minimum Cost Of Climbing Stairs & How To Approach DP
    • Understanding & Identifying Recurrence Relation
    • First Step - Recursive Solution From Recurrence Relation
    • Second Step - Memoizing Our Redundant Recursive Calls
    • Coding Our Memoization Optimization
    • Understanding The Bottom Up Approach (Tabulation)
    • Third Step - Bottom Up Tabulation
    • Fourth Step - Bottom Up Optimization
  •   Dynamic Programming - Question #27 - Knight Probability In Chessboard (Medium)
    • Question #27 - Knight Probability In Chessboard
    • Thinking About Test Cases To Help Us
    • Identifying The Recurrence Relation
    • First Step - Recursive Solution From Recurrence Relation
    • Second Step - Memoizing Our Redundant Recursive Calls
    • Figuring Out The Logic For Our Bottom Up Solution
    • Third Step - Bottom Up Tabulation
    • Fourth Step - Bottom Up Optimization
    • Dynamic Programming Question List
  •   Backtracking - Question #28 - Sudoku Solver (Hard)
    • Understanding The Basics Of Backtracking
    • Question #28 - Sudoku Solver
    • Learning The Backtracking Template
    • Applying Our Backtracking Template To Sudoku Solver Logic
    • Coding How To Get Box ID
    • Setting Up Our Solution Code
    • Coding The Recursive Backtracking Portion Of Our Solution
    • Thinking About The Space And Time Complexity
  •   Interface Design - Question #29 - Monarchy
    • Understanding Interface Design & Question #29 - Monarchy
    • Figuring Out Our Test Cases
    • Thinking About The Logical Of The Monarchy
    • Coding Our Monarchy Solution
  •   Tries - Question #30 - Implement Prefix Trie (Medium)
    • Introducing Tries
    • Question #30 - Implement Prefix Trie
    • Understanding The Logic For Our Methods
    • Implementing Our Prefix Trie Data Structure Solution
  •   Where To Go From Here?
    • Thank You!
    • Review This Course!
    • LinkedIn Endorsements
    • Become An Alumni
    • Coding Challenges
    • Learning Guideline
  •   Appendix: Big O
    • Note About Appendix Videos
    • Section Overview
    • What Is Good Code?
    • Big O and Scalability
    • O(n)
    • O(1)
    • Exercise: Big O Calculation
    • Solution: Big O Calculation
    • Exercise: Big O Calculation 2
    • Solution: Big O Calculation 2
    • Simplifying Big O
    • Big O Rule 1
    • Big O Rule 2
    • Big O Rule 3
    • O(n^2)
    • Big O Rule 4
    • Big O Cheat Sheet
    • What Does This All Mean?
    • O(n!)
    • 3 Pillars Of Programming
    • Space Complexity
    • Exercise: Space Complexity
    • Exercise: Twitter
    • Section Summary
  •   Appendix: Arrays
    • Arrays Introduction
    • Static vs Dynamic Arrays
    • Optional: Implementing An Array
  •   Appendix: Hash Tables
    • Hash Tables Introduction
    • Hash Function
    • Hash Collisions
    • Hash Tables VS Arrays
  •   Appendix: Linked Lists
    • Linked Lists Introduction
    • What Is A Linked List?
    • Exercise: Why Linked Lists?
    • Solution: Why Linked Lists?
    • What Is A Pointer?
    • Doubly Linked Lists
    • Singly VS Doubly Linked Lists
    • Linked Lists Review
  •   Appendix: Stacks + Queues
    • Stacks + Queues Introduction
    • Stacks
    • Queues
    • Exercise: Stacks VS Queues
    • Solution: Stacks VS Queues
    • Stacks + Queues Review
  •   Appendix: Trees
    • Trees Introduction
    • Binary Trees
    • O(log n)
    • Binary Search Tree
    • Balanced VS Unbalanced BST
    • BST Pros and Cons
    • Trie
  •   Appendix: Searching + BFS + DFS
    • Graph + Tree Traversals
    • BFS Introduction
    • DFS Introduction
    • BFS vs DFS
    • Exercise: BFS vs DFS
    • Solution: BFS vs DFS
    • breadthFirstSearch()
    • PreOrder, InOrder, PostOrder
    • depthFirstSearch()
  •   Appendix: Recursion
    • Recursion Introduction
    • Stack Overflow
    • Anatomy Of Recursion
    • Recursive VS Iterative
    • When To Use Recursion
    • Recursion Review
  •   Appendix: Sorting
    • Sorting Introduction
    • The Issue With sort()
    • Sorting Algorithms
    • Bubble Sort
    • Exercise: Bubble Sort
    • Solution: Bubble Sort
    • Selection Sort
    • Exercise: Selection Sort
    • Solution: Selection Sort
    • Dancing Algorithms
    • Exercise: Insertion Sort
    • Insertion Sort
    • Solution: Insertion Sort
    • Merge Sort and O(n log n)
    • Exercise: Merge Sort
    • Solution: Merge Sort
    • Quick Sort

Taught by

Yihua Zhang and Andrei Neagoie

Reviews

Start your review of Master the Coding Interview: Big Tech (FAANG) Interviews

Go to class

Never Stop Learning.

Get personalized course recommendations, track subjects and courses with reminders, and more.

Sign up for free
Someone learning on their laptop while sitting on the floor.