Google Interview Crash Course

Lesson 1: Arrays & Strings

💡 Visual Learning: Throughout this course, you'll see animated visualizations for O(n) algorithms:
• Animated bars show linear growth with input size
• Pulsing badges O(n) highlight time complexity
• Iterating dots demonstrate how algorithms process each element once
These help you understand why these algorithms are efficient!

Why Arrays & Strings at Google?

Arrays and strings are fundamental data structures tested in nearly every Google interview. They assess your ability to manipulate data efficiently and optimize for time/space complexity.

Google Insight: Google emphasizes clean code, optimal solutions, and clear communication. Always discuss your approach before coding.

Two Sum Problem O(n)

One of the most common interview questions. Find two numbers that add up to a target.

# Two Sum - Hash Map Approach
# Time: O(n), Space: O(n)

def two_sum(nums, target):
    """
    Given array of integers, return indices of two numbers
    that add up to target.
    """
    seen = {}  # value -> index

    for i, num in enumerate(nums):
        complement = target - num

        if complement in seen:
            return [seen[complement], i]

        seen[num] = i

    return None

# Example
nums = [2, 7, 11, 15]
target = 9
print(two_sum(nums, target))  # [0, 1]

# Google expects:
# 1. Discuss brute force O(n²) first
# 2. Optimize to O(n) with hash map
# 3. Handle edge cases
# 4. Clean, readable code

String Manipulation - Reverse Words O(n)

# Reverse Words in a String
# Time: O(n), Space: O(n)

def reverse_words(s):
    """
    Reverse the order of words in a string.
    "the sky is blue" -> "blue is sky the"
    """
    # Split by whitespace, filter empty strings
    words = s.split()

    # Reverse and join
    return ' '.join(reversed(words))

# More efficient in-place approach (if allowed)
def reverse_words_inplace(s):
    # Convert to list (strings are immutable)
    chars = list(s.strip())

    # Reverse entire string
    reverse(chars, 0, len(chars) - 1)

    # Reverse each word
    start = 0
    for i in range(len(chars) + 1):
        if i == len(chars) or chars[i] == ' ':
            reverse(chars, start, i - 1)
            start = i + 1

    return ''.join(chars)

def reverse(chars, left, right):
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1

print(reverse_words("  hello world  "))  # "world hello"

Longest Substring Without Repeating Characters O(n)

Classic sliding window problem frequently asked at Google.

# Longest Substring Without Repeating Characters
# Time: O(n), Space: O(min(m,n)) where m is charset size

def length_of_longest_substring(s):
    """
    Find length of longest substring without repeating characters.
    "abcabcbb" -> 3 ("abc")
    """
    char_index = {}  # char -> last seen index
    max_length = 0
    left = 0

    for right in range(len(s)):
        char = s[right]

        # If char seen and in current window, move left
        if char in char_index and char_index[char] >= left:
            left = char_index[char] + 1

        char_index[char] = right
        max_length = max(max_length, right - left + 1)

    return max_length

# Examples
print(length_of_longest_substring("abcabcbb"))  # 3
print(length_of_longest_substring("bbbbb"))     # 1
print(length_of_longest_substring("pwwkew"))    # 3

Move Zeroes O(n)

# Move Zeroes - Two Pointer Technique
# Time: O(n), Space: O(1)

def move_zeroes(nums):
    """
    Move all zeroes to end while maintaining order.
    Modify in-place.
    [0,1,0,3,12] -> [1,3,12,0,0]
    """
    # Position to place next non-zero
    write_pos = 0

    # Move all non-zeros forward
    for i in range(len(nums)):
        if nums[i] != 0:
            nums[write_pos] = nums[i]
            write_pos += 1

    # Fill rest with zeros
    for i in range(write_pos, len(nums)):
        nums[i] = 0

    return nums

# Optimized with swap
def move_zeroes_swap(nums):
    write_pos = 0

    for i in range(len(nums)):
        if nums[i] != 0:
            nums[write_pos], nums[i] = nums[i], nums[write_pos]
            write_pos += 1

    return nums

nums = [0, 1, 0, 3, 12]
print(move_zeroes(nums))  # [1, 3, 12, 0, 0]

Google Interview Tips for Arrays & Strings

Clarify inputs: Ask about duplicates, empty arrays, Unicode vs ASCII
Discuss approach: Explain your thinking before coding
Start simple: Mention brute force, then optimize
Test edge cases: Empty, single element, all same, negatives
Time/Space complexity: Always analyze and state it

Common Patterns:
• Hash Maps for O(1) lookups
• Two Pointers for in-place operations
• Sliding Window for subarray/substring
• Sort first for easier manipulation

Lesson 2: Linked Lists & Trees

Linked Lists at Google

Google frequently tests linked list manipulation. Focus on pointer manipulation and edge cases.

# Linked List Node
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# Reverse Linked List - EXTREMELY COMMON O(n)
# Time: O(n), Space: O(1)

def reverse_list(head):
    """
    Reverse a singly linked list.
    1 -> 2 -> 3 -> None  becomes  3 -> 2 -> 1 -> None
    """
    prev = None
    current = head

    while current:
        # Save next
        next_temp = current.next

        # Reverse pointer
        current.next = prev

        # Move forward
        prev = current
        current = next_temp

    return prev

# Detect Cycle in Linked List (Floyd's Algorithm)
def has_cycle(head):
    """
    Detect if linked list has a cycle.
    Use fast and slow pointers.
    """
    if not head or not head.next:
        return False

    slow = head
    fast = head.next

    while slow != fast:
        if not fast or not fast.next:
            return False
        slow = slow.next
        fast = fast.next.next

    return True

# Merge Two Sorted Lists
def merge_two_lists(l1, l2):
    """
    Merge two sorted linked lists.
    """
    dummy = ListNode(0)
    current = dummy

    while l1 and l2:
        if l1.val <= l2.val:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next

    # Attach remaining
    current.next = l1 if l1 else l2

    return dummy.next

Binary Trees - Essential Patterns

# Binary Tree Node
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# Maximum Depth of Binary Tree
def max_depth(root):
    """
    Find maximum depth of binary tree.
    Recursive approach.
    """
    if not root:
        return 0

    left_depth = max_depth(root.left)
    right_depth = max_depth(root.right)

    return max(left_depth, right_depth) + 1

# Validate Binary Search Tree
def is_valid_bst(root):
    """
    Check if tree is valid BST.
    Left < Node < Right for all nodes.
    """
    def validate(node, min_val, max_val):
        if not node:
            return True

        if node.val <= min_val or node.val >= max_val:
            return False

        return (validate(node.left, min_val, node.val) and
                validate(node.right, node.val, max_val))

    return validate(root, float('-inf'), float('inf'))

# Level Order Traversal (BFS) O(n)
def level_order(root):
    """
    Return level order traversal.
    [[root], [level 1], [level 2], ...]
    """
    if not root:
        return []

    result = []
    queue = [root]

    while queue:
        level_size = len(queue)
        current_level = []

        for _ in range(level_size):
            node = queue.pop(0)
            current_level.append(node.val)

            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        result.append(current_level)

    return result

Lowest Common Ancestor (LCA)

Very popular Google interview question.

# Lowest Common Ancestor in BST
def lowest_common_ancestor_bst(root, p, q):
    """
    Find LCA in Binary Search Tree.
    Use BST property for efficient solution.
    """
    while root:
        # Both in left subtree
        if p.val < root.val and q.val < root.val:
            root = root.left
        # Both in right subtree
        elif p.val > root.val and q.val > root.val:
            root = root.right
        # Found split point (LCA)
        else:
            return root

    return None

# Lowest Common Ancestor in Binary Tree
def lowest_common_ancestor(root, p, q):
    """
    Find LCA in regular binary tree.
    """
    if not root or root == p or root == q:
        return root

    left = lowest_common_ancestor(root.left, p, q)
    right = lowest_common_ancestor(root.right, p, q)

    # If both found in different subtrees, root is LCA
    if left and right:
        return root

    # Return whichever is not None
    return left if left else right

Serialize and Deserialize Binary Tree

# Serialize and Deserialize Binary Tree
# Google loves this problem!

class Codec:
    def serialize(self, root):
        """
        Encode tree to string using preorder traversal.
        """
        def helper(node):
            if not node:
                return "null,"

            return str(node.val) + "," + helper(node.left) + helper(node.right)

        return helper(root)

    def deserialize(self, data):
        """
        Decode string to tree.
        """
        def helper(values):
            val = next(values)

            if val == "null":
                return None

            node = TreeNode(int(val))
            node.left = helper(values)
            node.right = helper(values)

            return node

        values = iter(data.split(","))
        return helper(values)

# Usage
codec = Codec()
tree = TreeNode(1, TreeNode(2), TreeNode(3))
serialized = codec.serialize(tree)
deserialized = codec.deserialize(serialized)

Common Mistakes:
• Forgetting null checks (always check if node is None)
• Not handling single-node or empty tree
• Modifying original structure when not asked
• Confusing BST with regular binary tree

Google Tree Interview Patterns:
• DFS (Recursion): Max depth, path sum, LCA
• BFS (Queue): Level order, min depth
• Validate BST: Use range checking
• Serialize: Preorder with null markers

Lesson 3: Dynamic Programming

Why DP Matters at Google

Dynamic Programming is a favorite at Google. It tests problem-solving skills, optimization, and ability to recognize patterns.

DP Recognition: If you see "maximum/minimum", "count ways", or overlapping subproblems, think DP!

Climbing Stairs - Entry Level DP O(n)

# Climbing Stairs
# Time: O(n), Space: O(1)

def climb_stairs(n):
    """
    You can climb 1 or 2 steps at a time.
    How many distinct ways to reach top?

    Pattern: dp[i] = dp[i-1] + dp[i-2]
    This is Fibonacci!
    """
    if n <= 2:
        return n

    # Space optimized
    prev2 = 1  # ways to reach step 1
    prev1 = 2  # ways to reach step 2

    for i in range(3, n + 1):
        current = prev1 + prev2
        prev2 = prev1
        prev1 = current

    return prev1

# Example
print(climb_stairs(5))  # 8 ways

Coin Change - Classic DP

# Coin Change - Minimum Coins
# Time: O(amount * n), Space: O(amount)

def coin_change(coins, amount):
    """
    Find minimum number of coins to make amount.
    Return -1 if impossible.

    coins = [1,2,5], amount = 11 -> 3 (5+5+1)
    """
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0  # 0 coins needed for amount 0

    for i in range(1, amount + 1):
        for coin in coins:
            if coin <= i:
                dp[i] = min(dp[i], dp[i - coin] + 1)

    return dp[amount] if dp[amount] != float('inf') else -1

# Coin Change 2 - Count Ways
def coin_change_ways(coins, amount):
    """
    Count number of ways to make amount.
    """
    dp = [0] * (amount + 1)
    dp[0] = 1  # 1 way to make 0

    for coin in coins:
        for i in range(coin, amount + 1):
            dp[i] += dp[i - coin]

    return dp[amount]

print(coin_change([1, 2, 5], 11))       # 3
print(coin_change_ways([1, 2, 5], 5))   # 4 ways

Longest Increasing Subsequence (LIS)

Very common in Google interviews.

# Longest Increasing Subsequence
# Time: O(n²), Space: O(n)

def length_of_lis(nums):
    """
    Find length of longest increasing subsequence.
    [10,9,2,5,3,7,101,18] -> 4 ([2,3,7,101])
    """
    if not nums:
        return 0

    n = len(nums)
    dp = [1] * n  # Each element is a subsequence of length 1

    for i in range(1, n):
        for j in range(i):
            if nums[i] > nums[j]:
                dp[i] = max(dp[i], dp[j] + 1)

    return max(dp)

# Optimized with Binary Search - O(n log n)
def length_of_lis_optimized(nums):
    """
    Use binary search for O(n log n) solution.
    Maintain array of smallest tail for each length.
    """
    if not nums:
        return 0

    tails = []

    for num in nums:
        # Binary search for position
        left, right = 0, len(tails)

        while left < right:
            mid = (left + right) // 2
            if tails[mid] < num:
                left = mid + 1
            else:
                right = mid

        # Replace or append
        if left == len(tails):
            tails.append(num)
        else:
            tails[left] = num

    return len(tails)

print(length_of_lis([10,9,2,5,3,7,101,18]))  # 4

Word Break

# Word Break
# Time: O(n² * m), Space: O(n)
# n = string length, m = word check time

def word_break(s, word_dict):
    """
    Check if string can be segmented into dictionary words.
    s = "leetcode", wordDict = ["leet","code"] -> True
    """
    word_set = set(word_dict)
    n = len(s)
    dp = [False] * (n + 1)
    dp[0] = True  # Empty string

    for i in range(1, n + 1):
        for j in range(i):
            # If s[0:j] can be segmented AND s[j:i] is in dict
            if dp[j] and s[j:i] in word_set:
                dp[i] = True
                break

    return dp[n]

# Example
s = "leetcode"
word_dict = ["leet", "code"]
print(word_break(s, word_dict))  # True

Edit Distance (Levenshtein Distance)

Transform one string to another with minimum operations.

# Edit Distance
# Time: O(m*n), Space: O(m*n)

def min_distance(word1, word2):
    """
    Minimum operations to convert word1 to word2.
    Operations: insert, delete, replace

    "horse" -> "ros" = 3
    (replace h->r, remove o, remove e)
    """
    m, n = len(word1), len(word2)

    # dp[i][j] = edit distance for word1[0:i] and word2[0:j]
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    # Base cases
    for i in range(m + 1):
        dp[i][0] = i  # Delete all from word1

    for j in range(n + 1):
        dp[0][j] = j  # Insert all from word2

    # Fill table
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]  # No operation needed
            else:
                dp[i][j] = 1 + min(
                    dp[i-1][j],      # Delete
                    dp[i][j-1],      # Insert
                    dp[i-1][j-1]     # Replace
                )

    return dp[m][n]

print(min_distance("horse", "ros"))  # 3

DP Approach at Google:
1. Define state (what does dp[i] represent?)
2. Find recurrence relation
3. Identify base cases
4. Implement (top-down or bottom-up)
5. Optimize space if possible

Google DP Tips:
• Start with brute force recursive solution
• Add memoization for top-down DP
• Convert to bottom-up for better space
• Always explain your state definition

Lesson 4: System Design Basics

System Design at Google

For mid-level and senior roles, Google assesses your ability to design scalable systems. This tests architectural thinking, trade-offs, and real-world experience.

Interview Format: 45 minutes to design a system like "Design YouTube", "Design Google Drive", or "Design URL Shortener". Focus on discussing trade-offs, not perfect solutions.

Key Concepts to Know

Concept	Description	When to Use
Load Balancer	Distributes traffic across servers	High traffic, horizontal scaling
CDN	Content Delivery Network for static assets	Global users, images/videos
Caching	Store frequent data in memory (Redis, Memcached)	Read-heavy, reduce DB load
Database Sharding	Partition data across multiple DBs	Large datasets, write-heavy
Message Queue	Async communication (RabbitMQ, Kafka)	Decouple services, handle spikes
Microservices	Independent services communicating via API	Complex systems, team scalability

System Design Framework (RESHADED)

Requirements: Clarify functional and non-functional requirements
Estimation: Calculate traffic, storage, bandwidth
System Interface: Define APIs
High-level Design: Draw architecture diagram
Detailed Design: Deep dive into components
Bottlenecks: Identify and address them
Scale: How to scale each component

Example: Design URL Shortener

# URL Shortener Design

## 1. Requirements
Functional:
- Given long URL, generate short URL
- Redirect short URL to original URL
- Custom aliases (optional)
- Expiration (optional)

Non-Functional:
- High availability
- Low latency for redirects
- Scalable (billions of URLs)

## 2. Estimation
- 100M URLs created per month
- 100:1 read/write ratio
- 10B redirects per month
- Storage: 100M * 500 bytes * 12 months * 10 years = 6TB

## 3. API Design
createURL(api_key, original_url, custom_alias=None, expiration=None)
  -> Returns: short_url

getURL(short_url)
  -> Returns: original_url or 404

## 4. Data Model
URL Table:
- id: bigint (primary key)
- short_code: varchar(7) (indexed)
- original_url: varchar(2048)
- user_id: bigint
- created_at: timestamp
- expires_at: timestamp

## 5. Core Algorithm - Base62 Encoding

def encode_base62(num):
    """Convert number to base62 string"""
    chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    if num == 0:
        return chars[0]

    result = []
    while num:
        result.append(chars[num % 62])
        num //= 62

    return ''.join(reversed(result))

def decode_base62(string):
    """Convert base62 string to number"""
    chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    num = 0
    for char in string:
        num = num * 62 + chars.index(char)
    return num

# Generate short URL
def create_short_url(original_url):
    # Get auto-increment ID from database
    url_id = database.insert(original_url)

    # Encode to base62 (7 chars = 62^7 = 3.5 trillion URLs)
    short_code = encode_base62(url_id)

    return f"https://short.url/{short_code}"

## 6. Architecture Components

┌─────────┐
│ Client  │
└────┬────┘
     │
┌────▼────────┐
│Load Balancer│
└────┬────────┘
     │
┌────▼────────────────────────────┐
│   Application Servers (Cluster) │
└────┬────────────────────────────┘
     │
     ├──────┬──────────┬──────────┐
     │      │          │          │
┌────▼───┐ ┌▼────┐ ┌──▼──────┐  │
│ Redis  │ │MySQL│ │Analytics│  │
│(Cache) │ │(DB) │ │         │  │
└────────┘ └─────┘ └─────────┘  │
                                 │
                          ┌──────▼────┐
                          │ CDN       │
                          └───────────┘

## 7. Scaling Strategies
- Database: Master-slave replication, sharding by hash(short_code)
- Cache: Cache popular URLs in Redis (80/20 rule)
- Rate Limiting: Prevent abuse
- Analytics: Separate service for tracking clicks
- Cleanup: Background job to delete expired URLs

CAP Theorem

Fundamental concept for distributed systems.

# CAP Theorem: Pick 2 of 3

Consistency (C): All nodes see same data at same time
Availability (A): Every request gets a response
Partition Tolerance (P): System works despite network failures

In distributed systems, network partitions WILL happen.
So you must choose between C and A:

CP Systems (Consistency + Partition Tolerance):
- MongoDB, HBase, Redis
- Sacrifice availability during partition
- Use when: Financial transactions, inventory

AP Systems (Availability + Partition Tolerance):
- Cassandra, DynamoDB, CouchDB
- Sacrifice consistency (eventual consistency)
- Use when: Social media feeds, analytics

CA Systems (Consistency + Availability):
- Traditional RDBMS in single node
- Not truly distributed

Common Google System Design Questions

Design Google Search: Crawling, indexing, ranking, caching
Design YouTube: Video upload, encoding, CDN, recommendations
Design Google Drive: File storage, sync, sharing, versioning
Design Gmail: Email storage, search, labels, spam detection
Design Google Maps: Location services, routing, real-time traffic

Google System Design Tips:
• Clarify requirements first (15 min)
• Don't jump to solutions immediately
• Discuss trade-offs explicitly
• Start simple, then add complexity
• Draw diagrams clearly
• Know your numbers (latency, throughput)

Common Mistakes:
• Designing without understanding requirements
• Over-engineering from the start
• Not discussing trade-offs
• Ignoring bottlenecks
• Poor communication and diagram skills

Lesson 5: Behavioral & Cultural Fit

Google's Behavioral Interview

Google uses "Googleyness & Leadership" rounds to assess cultural fit, collaboration, and how you handle challenges. These are just as important as technical skills.

Google Values: Innovation, collaboration, user focus, intellectual humility, and comfort with ambiguity.

STAR Method

Structure your answers using STAR:

Situation: Set the context (what, when, where)
Task: Explain the challenge or goal
Action: Describe what YOU did (not "we")
Result: Share outcomes with metrics if possible

# Example STAR Answer

Question: "Tell me about a time you had to handle a difficult team member."

STAR Response:

Situation:
"In my last project, I was leading a 5-person team building a
recommendation engine. One senior engineer consistently missed
deadlines and was unresponsive in meetings."

Task:
"I needed to address this without damaging team morale and ensure
we met our product launch deadline in 6 weeks."

Action:
"First, I had a 1-on-1 conversation to understand their perspective.
I learned they felt overwhelmed by unclear requirements. So I:
1. Broke their work into smaller, clearer tasks
2. Set up daily 15-min check-ins for support
3. Paired them with another engineer for knowledge sharing
4. Documented all requirements in a shared wiki"

Result:
"Within 2 weeks, their productivity increased 3x. We launched on time,
and they later thanked me for the support. This taught me the
importance of clear communication and understanding root causes
before jumping to solutions."

Common Google Behavioral Questions

Category	Example Questions
Leadership	Tell me about a time you led a project without formal authority
Conflict	Describe a disagreement with a teammate and how you resolved it
Failure	Tell me about your biggest professional failure and what you learned
Innovation	Describe a time you challenged the status quo
Ambiguity	Tell me about a project with unclear requirements
Impact	What's the most impactful project you've worked on?

Prepare 6-8 Stories

Have concrete examples ready for these categories:

Leadership: Leading without authority, mentoring, decision-making
Teamwork: Collaboration, handling conflict, building consensus
Problem-Solving: Complex technical challenges, innovative solutions
Failure & Growth: Mistakes, lessons learned, resilience
Impact: Projects with measurable business value
User Focus: Putting user needs first, customer empathy

Questions to Ask Google

Prepare thoughtful questions to show genuine interest:

# Good Questions to Ask

Technical/Team:
- "What does a typical sprint look like for this team?"
- "How does the team balance technical debt vs. new features?"
- "What's the most challenging technical problem your team is solving?"
- "How do you measure success for this role?"

Growth:
- "What learning opportunities are available at Google?"
- "How does Google support career development?"
- "What skills should I focus on in my first 6 months?"

Culture:
- "How does the team collaborate across time zones?" (if applicable)
- "What do you enjoy most about working at Google?"
- "How does Google foster innovation in this team?"

Product:
- "What's the product roadmap for the next year?"
- "How does user feedback influence product decisions?"

Avoid:
- Questions easily answered by Google search
- Salary/benefits in first round (wait for recruiter)
- Anything negative about current employer

Red Flags to Avoid

Blaming others: Always focus on your role and learning
Vague answers: Be specific with metrics and details
Only "I" no "we": Show collaboration skills
No weaknesses: Show self-awareness and growth mindset
Memorized responses: Be authentic, not robotic

Googleyness Traits:
• Intellectual humility (admitting what you don't know)
• Comfort with ambiguity
• Collaboration over competition
• User focus and empathy
• Growth mindset
• Taking initiative

Interview Tips:
• Practice STAR stories out loud
• Quantify results when possible
• Show learning from failures
• Be honest, not perfect
• Ask clarifying questions

Lesson 6: Interview Day & Final Tips

Google Interview Process

Understanding the process helps you prepare strategically.

# Typical Google Interview Process

1. Recruiter Screen (30 min)
   - Background, experience, motivation
   - High-level technical discussion
   - Logistics and expectations

2. Phone/Video Technical Screen (45 min)
   - 1-2 coding problems
   - Use Google Doc or CoderPad
   - Can compile and run code

3. Onsite/Virtual Onsite (4-5 rounds, 45 min each)
   - Coding & Algorithms (2-3 rounds)
   - System Design (1 round, for L4+)
   - Googleyness & Leadership (1 round)
   - Optional: Domain-specific (ML, Android, etc.)

4. Team Matching
   - After passing interviews
   - Match with teams based on skills/interests
   - Can take 1-6 months

5. Hiring Committee Review
   - Reviews interview feedback
   - Decides hire/no-hire
   - Level determination

6. Offer
   - Compensation, team, location
   - Negotiation possible

Day Before Interview

Review fundamentals: Don't learn new algorithms, review what you know
Prepare environment: Test webcam, mic, internet connection
Practice whiteboarding: Use a whiteboard or paper, not IDE
Prepare questions: Have 3-5 thoughtful questions ready
Get supplies: Water, pen, paper, charger
Rest well: Sleep is more important than last-minute cramming

During the Interview - Communication

# Interview Communication Framework

1. LISTEN CAREFULLY
   - Take notes while interviewer explains problem
   - Don't interrupt
   - Ask clarifying questions

2. CLARIFY REQUIREMENTS
   "Just to confirm, the input is..."
   "Should I handle negative numbers?"
   "What should happen if the array is empty?"
   "Are there any constraints on time/space complexity?"

3. DISCUSS APPROACH
   "My initial thought is to use a hash map because..."
   "I'm considering two approaches: [A] and [B]"
   "Let me walk through my approach..."

4. THINK OUT LOUD
   "I'm thinking about edge cases..."
   "This loop will iterate through..."
   "I'm using this data structure because..."

5. CODE CLEARLY
   - Use meaningful variable names
   - Add comments for complex logic
   - Write clean, readable code
   - Don't worry about perfect syntax

6. TEST YOUR SOLUTION
   "Let me trace through an example..."
   "Edge case: what if input is [1]?"
   "Time complexity: O(n), Space: O(1)"

7. OPTIMIZE IF TIME ALLOWS
   "I can optimize this from O(n²) to O(n) by..."
   "The space complexity could be reduced by..."

Problem-Solving Template

# Step-by-Step Problem Solving

STEP 1: Understand (5 min)
□ Restate the problem in your own words
□ Ask about inputs: type, size, constraints
□ Ask about outputs: format, edge cases
□ Clarify assumptions
□ Ask about time/space requirements

STEP 2: Examples (3 min)
□ Create 2-3 test cases
□ Include edge cases
□ Walk through expected outputs

STEP 3: Approach (5 min)
□ Discuss brute force solution
□ Identify optimization opportunities
□ Choose data structures
□ Estimate complexity
□ Get feedback before coding

STEP 4: Code (20 min)
□ Write clean, organized code
□ Use helper functions
□ Add comments for clarity
□ Think out loud
□ Don't stress about syntax

STEP 5: Test (5 min)
□ Walk through your code with examples
□ Check edge cases
□ Look for bugs
□ Fix issues

STEP 6: Optimize (5 min)
□ Analyze time/space complexity
□ Discuss potential improvements
□ Implement if time allows

STEP 7: Discuss (2 min)
□ Trade-offs
□ Alternative approaches
□ Real-world considerations

Common Pitfalls to Avoid

Mistake	Impact	Solution
Jumping to code immediately	Wrong approach, wasted time	Discuss approach first, get buy-in
Silent coding	Interviewer can't help you	Think out loud constantly
Giving up too quickly	Missed signals for help	Ask for hints when stuck
Ignoring hints	Not collaborative	Listen carefully to suggestions
Not testing code	Bugs remain undetected	Always test with examples
Memorizing solutions	Can't adapt to variations	Understand patterns, not answers

Final Week Preparation Checklist

Algorithms: Review 50-100 LeetCode problems (Easy/Medium)
Patterns: Master two pointers, sliding window, DFS/BFS, DP
Data Structures: Arrays, strings, trees, graphs, hash maps
System Design: Study 3-5 common designs in depth
Behavioral: Prepare 6-8 STAR stories
Mock Interviews: Do 3-5 with peers or platforms
Google Research: Understand products, culture, mission

Resources

# Recommended Resources

Coding Practice:
- LeetCode (focus on Google tagged questions)
- HackerRank
- CodeSignal

System Design:
- "Designing Data-Intensive Applications" by Martin Kleppmann
- "System Design Interview" by Alex Xu
- ByteByteGo (YouTube channel)

Behavioral:
- "Cracking the Coding Interview" (behavioral section)
- Google's re:Work guide
- Practice with friends/mentors

Mock Interviews:
- Pramp (free peer mock interviews)
- Interviewing.io
- LeetCode Mock Interviews
- Friends in tech

Remember on Interview Day:
• You were selected for a reason - believe in yourself
• Interviewers want you to succeed
• Communication > perfect code
• It's okay to say "I don't know, but here's how I'd figure it out"
• Take a breath, think, then speak
• Enjoy the intellectual challenge!

If You Don't Get the Offer:
• Google has a 12-month reapply policy
• Ask for feedback (though specifics are limited)
• Use it as learning experience
• Many Googlers failed their first attempt
• Keep improving and try again!