Problem Overview

Difficulty: Easy
LeetCode Pattern: Two Pointers

Given a string s, return true if it is a palindrome, or false otherwise.

Note: A palindrome is a string that reads the same forward and backward after:

• Converting all uppercase letters to lowercase.

• Removing all non-alphanumeric characters (only letters and digits remain).

Input: 
· s = “race 123 car”
Output: 
· False
Reason:
· “race123car” is not a palindrome

Input: 
· s = “Race ,: car”
Output: 
· True
Reason:
· “racecar” is a palindrome

Step 1: Clarify Requirements

• Can the input string be empty?

  • Yes, empty string is a palindrome.

• Can it contain uppercase letters?

  • Yes, treat them as lowercase.

• Can it contain non-alphanum chars?

  • Yes, need to ignore these.

Step 2: Discuss Approaches

1/ Reverse + Compare (Brute Force ⚠️)

• Logic:

  • Clean the string:

    • Remove non-alphanum chars

    • Convert to lowercase

  • Make it’s reversed copy

  • Compare cleaned vs reversed

  • If they match → return True

  • Else → return False

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(n)

2/ Two-Pointers (Optimal ✅)

• Logic:

  • Use two pointers:

    • one starting at the left

    • one starting at the right

  • At each point:

    • Skip non-alphanum chars

    • Then, compare left and right

    • If mismatch → return False

    • Else → move inward

  • If all pairs match → return True

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(1)

Step 3: Write Code

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the string is empty?

  • Our algorithm still works.

  • It will return True as expected.

• What if want case-sensitive check?

  • Just don’t convert to lowercase.

  • Rest of algorithm stays the same.

• What if we need all chars check?

  • Don’t skip non alphanum chars.

  • Rest of algorithm stays the same.

Here are 14 LeetCode Patterns I will study to crack my Google interview.

And no, I won’t “grind 500 problems.”

I will focus on the right patterns and the right problems.

These are the patterns and problems I will practice right before my Google interview:

1/ Arrays & Hashing

1. Contains Duplicate

2. Valid Anagram

3. Two Sum

4. Group Anagrams

5. Longest Consecutive Sequence

6. Valid Sudoku

2/ Two Pointers

1. Valid Palindrome

2. Remove Duplicates from Sorted Array

3. Merge Sorted Array

4. Container With Most Water

5. Two Sum II - Input Array Is Sorted

6. 3Sum

3/ Stack

1. Valid Parentheses

2. Next Greater Element I

3. Remove Outermost Parentheses

4. Min Stack

5. Minimum Add to Make Parentheses Valid

6. Basic Calculator II

4/ Binary Search

1. Binary Search

2. Search Insert Position

3. Kth Missing Positive Number

4. Find Peak Element

5. Search in Rotated Sorted Array

6. Search a 2D Matrix

5/ Sliding Window

1. Maximum Average Subarray I

2. Find the K-Beauty of a Number

3. Contains Duplicate II

4. Longest Substring Without Repeating Characters

5. Subarray Product Less Than K

6. Longest Repeating Character Replacement

6/ Linked List

1. Merge Two Sorted Lists

2. Reverse Linked List

3. Middle of the Linked List

4. Add Two Numbers

5. LRU Cache

6. Reorder List

7/ Trees

1. Same Tree

2. Maximum Depth of Binary Tree

3. Diameter of Binary Tree

4. Binary Tree Level Order Traversal

5. Validate Binary Search Tree

6. Lowest Common Ancestor of a Binary Tree

8/ Trie

1. Longest Common Prefix

2. Count Prefix and Suffix Pairs I

3. Implement Trie (Prefix Tree)

4. Design Add And Search Words Data Structure

5. Find the Length of the Longest Common Prefix

9/ Backtracking

1. Binary Tree Paths

2. Binary Watch

3. Sum of All Subset XOR Totals

4. Subsets

5. Permutations

6. Combination Sum

10/ Heap (Priority Queue)

1. Last Stone Weight

2. Kth Largest Element in a Stream

3. Relative Ranks

4. K Closest Points to Origin

5. Kth Largest Element in an Array

6. Task Scheduler

11/ Graphs

1. Find Center of Star Graph

2. Find the Town Judge

3. Find if Path Exists in Graph

4. Number of Islands

5. Clone Graph

6. Rotting Oranges

12/ Intervals

1. Insert Interval

2. Merge Intervals

3. Non Overlapping Intervals

13/ Greedy & Dynamic Programming

1. Jump Game

2. Jump Game II

3. Gas Station

14/ Advanced Graphs

1. Cheapest Flights Within K Stops

2. Network Delay Time

3. Min Cost to Connect All Points

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Problem Overview

Difficulty: Medium
LeetCode Pattern: Arrays & Hashing

Determine if a 9 x 9 Sudoku board is valid according to the following rules:

1. Each row must contain the digits 1-9 without repetition.

2. Each column must contain the digits 1-9 without repetition.

3. Each of the nine 3 x 3 boxes of the grid must contain the digits 1-9 without repetition.

Note:

• Only the filled cells need to be validated according to the mentioned rules.

• For unfilled cells in the matrix, assume it would be the dot (.) character.

Example 1

• Valid Case.

• It satisfies all properties.

Example 2

• Invalid Case.

• Two 8's in the top left 3x3 box.

Step 1: Clarify Requirements

• Can the board have all empty cells?

  • Yes, that’s possible.

• Can there by values other than 1-9?

  • No, assume values are 1-9 only.

• Can board size be other than 9x9?

  • No, assume 9x9 board only.

Step 2: Discuss Approaches

1/ All Checks (Brute Force ⚠️)

• Logic:

  • For each filled cell:

    • Check every value in that row

    • Check every value in that col

    • Check every value in that box

  • If no match → return True

  • If match found → return False

• Big O:

  • Time Complexity: O(n³)

  • Space Complexity: O(1)

2/ Use Multiple Sets (Optimal ✅)

• Logic:

  • Create 27 sets in total:

    • 9 for rows

    • 9 for cols

    • 9 for boxes

  • For each filled cell:

    • Check value in:

      • row set

      • col set

      • box set

    • If value exists → return False

    • Else → add to sets and continue

  • At the end:

    • return True (valid board)

• Big O:

  • Time Complexity: O(n²)

  • Space Complexity: O(1)

Step 3: Write Code

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the board was nearly empty?

  • Our algorithm still works fine.

  • It will simply skip most cells.

• What if board contains invalid chars?

  • We can add validation checks.

  • If an invalid char is found:

    • Return False (invalid board), or

    • Throw an error (bad input).

• What if the board size was any nxn?

  • Replace hardcoded 9 with n.

  • Box Size is now: sqrt(n) × sqrt(n).

  • Rest of algorithm stays the same.

  • Big O remains the same as well.

Problem Overview

Difficulty: Medium
LeetCode Pattern: Arrays & Hashing

Given an array of strings, group the anagrams together and return them. You can return the answer in any order.

Note: Anagram is a word or phrase formed by rearranging the letters of another word or phrase.

Input: 
· ["eat","tan","nat"]
Output: 
· [["eat"],["nat","tan"]]

Input: 
· ["eat","tan","bat"]
Output: 
· [["eat"],["tan"],["bat"]]

Step 1: Clarify Requirements

• Can input array be empty?

  • Yes, return an empty array.

• Can strings have uppercase letters?

  • No, assume lowercase letters only.

• Can there be empty strings?

  • Yes, put them into the same group.

Step 2: Discuss Approaches

1/ Sort + Map (Brute Force ⚠️)

• Logic:

  • For each string:

    • Sort it first

    • Then, put it in the map:

      • key = sorted string

      • value = [original string]

• Big O:

  • Time Complexity: O(n·klogk)

  • Space Complexity: O(n·k)

2/ Use Count Arrays (Optimal ✅)

• Idea:

  • Sorting each string takes time

  • But we don’t need to sort

  • We assume strings only contain:

    • 26 unique chars

    • Lowercase letters only

  • So instead of sorting:

    • We use a fixed-size array

    • To keep char counts

• Logic:

  • For each string:

    • Initialize a fixed-size array

    • Keep char counts in it

    • Convert char counts to a key

    • Put it in the map:

      • Key = char counts string

      • Value = [original string]

  • At the end:

    • Return map values (lists) as a list

• Big O:

  • Time Complexity: O(n·k)

  • Space Complexity: O(n·k)

Step 3: Write Code

Python

Java

C++

Step 4: Answer Follow-Ups

• What if case doesn’t matter?

  • Convert all strings to lowercase.

  • Then run the grouping logic.

• What if input contains Unicode?

  • For Unicode, arrays don’t work.

  • Use a map to count each char.

  • Sort the characters in the map.

  • Turn that into a key string.

  • Group words with the same key.

Problem Overview

Difficulty: Medium
LeetCode Pattern: Arrays & Hashing

Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.

Input: 
· nums = [100,4,200,1,3,2]
Output: 
· 4
Explanation: 
· Longest Seq. = [1, 2, 3, 4]
· It's length is 4

Step 1: Clarify Requirements

• Can input be empty?

  • Yes, return 0.

• Can input include negatives?

  • Yes.

• Can input contain duplicates?

  • Yes.

Step 2: Discuss Approaches

1/ Sort + Linear Scan (Brute Force ⚠️)

• Logic:

  • Sort the array

  • Iterate through it

  • Count consecutive sequences

  • Track their lengths

  • Keep max length

• Big O:

  • Time Complexity: O(n·logn)

  • Space Complexity: O(n)

2/ Set + Linear Scan (Optimal ✅)

• Logic:

  • Put all nums in a set (O(1) lookups)

  • For each num in set:

    • Check if num-1 is not in set

    • If not, it’s start of a sequence

  • For each sequence start:

    • Count consecutive numbers

    • And keep track of max length

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(n)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if duplicates exist?

  • Set removes them automatically.

• Can we return the sequence itself?

  • Yes, keep track of start.

  • Build the sequence after scanning.

Problem Overview

Difficulty: Easy
LeetCode Pattern: Arrays & Hashing

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

Note: Anagram is a word or phrase formed by rearranging the letters of another word or phrase.

Input: 
· s = "anagram"
· t = "nagaram"
Output: 
· true
Explanation: 
· Both strings contain:
  · 'a': 3 times
  · 'n': 1 time
  · 'g': 1 time
  · 'r': 1 time
  · 'm': 1 time
· So they are anagrams.

Input: 
· s = "ram"
· t = "car"
Output: 
· false
Explanation:
· String s contains 'm'.
· But string t does not.
· So they are not anagrams.

Step 1: Clarify Requirements

• Can the input strings be empty?

  • Yes. Return true.

• Can they contain uppercase characters?

  • Yes.

• Are strings ASCII (128 characters)?

  • Yes.

Step 2: Discuss Approaches

1/ Sort Strings (Brute Force ⚠️)

• Logic:

  • Sort both the strings

  • Return true if they are equal

  • Return false otherwise

• Big O:

  • Time Complexity: O(n·logn)

  • Space Complexity: O(n)

2/ Use a Map (Optimal ✅)

• Logic:

  • Initialize an empty map

    • Key will be character

    • Value will be char frequency

  • Loop through the first string:

    • +1 to each char’s count

  • Loop through the second string:

    • -1 to each char’s count

  • At the end, check if any count ≠ 0

    • Return false → not an anagram

  • Otherwise, return true

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(1)

    • Max 128 keys in map (constant)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if you can’t use a map?

  • Use a fixed-size array for counts.

• What if case doesn’t matter?

  • Convert both strings to lowercase.

  • Then run our same algorithm.

• What if input contains Unicode?

  • Our logic still works.

  • But space complexity changes to O(n).

Problem Overview

Difficulty: Easy
LeetCode Pattern: Arrays & Hashing

You are given an array prices where prices[i] is the stock price on i^th day.

Return the max profit you can make by buying on one day and selling on a later day.

Return 0 if no profit is possible.

Input: prices = [3,2,1]
Output: 0
Reason:
· Prices are only decreasing.
· So can't make any profit.

Input: prices = [2,1,5]
Output: 4
Reason: 
· Buy at price = 1
· Sell at price = 5
· Profit = 5-1 = 4

Step 1: Clarify Requirements

• Can the input array be empty?

  • Yes.

  • Return 0 in that case.

• Will it be sorted?

  • No, not always.

• Could prices be negative?

  • Assume they won’t be.

Step 2: Discuss Approaches

1/ Nested Loop (Brute Force ⚠️)

• Logic:

  • For each price:

    • Try selling it on all future days

    • Keep track of the max profit

  • Return the max profit in the end

• Big O:

  • Time Complexity: O(n²)

  • Space Complexity: O(1)

2/ Track Min Price (Optimal ✅)

• Logic:

  • Keep track of min price at all times

  • For each price:

    • Update min price if needed

    • Update max profit if needed

  • Return the max profit in the end

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(1)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• How to return the days (not prices)?

  • Track the min price day index

  • When updating max profit:

    • Store the min price day index

    • Store the current day index

  • Return both indices at the end

• What if multiple buys and sells were allowed?

  • No need to track min price

  • Keep track of total profit

  • Anytime the price increases:

    • add the difference to total profit

  • Return this total profit at the end

Problem Overview

Difficulty: Easy
LeetCode Pattern: Arrays & Hashing

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

Input: 
· nums = [3,3]
· target = 6
Output: 
· [0,1]

Input: 
· nums = [2,7,11,15]
· target = 18
Output: 
· [1,2]

Step 1: Clarify Requirements

• Can the input array be empty?

  • Yes.

  • Return empty array.

• Will it be sorted?

  • No.

Step 2: Discuss Approaches

1/ Nested Loop (Brute Force ⚠️)

• Logic:

  • Start with value at index 0

  • Check its sum with all other values

  • If it adds up to target:

    • return the indices

  • Otherwise:

    • increment index and repeat

• Big O:

  • Time Complexity: O(n²)

  • Space Complexity: O(1)

2/ Use a Map (Optimal ✅)

• Logic:

  • Initialize an empty map

  • Iterate through the list

  • For each element:

    • Check if complement is in map

    • If it exists:

      • We found a solution

    • Otherwise:

      • Store in map and continue

  • Return empty array if no pair found

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(n)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the array is sorted?

  • Use two-pointer technique

  • No map is needed

• How to return all valid pairs?

  • Store pairs in a list instead of returning immediately

  • Return the list after processing all elements

Here are 76 LeetCode Problems I will solve to crack my Apple interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my Apple interview:

1/ Arrays & Hashing

1. Two Sum

2. Pascal’s Triangle

3. Valid Anagram

4. Group Anagrams

5. Valid Sudoku

6. Spiral Matrix

2/ Two Pointers

1. Merge Sorted Array

2. Valid Palindrome

3. Rotate Array

4. Reverse Words in a String

5. String Compression

6. Trapping Rain Water

3/ Stack

1. Valid Parentheses

2. Implement Queue using Stacks

3. Remove All Adjacent Duplicates In String

4. Min Stack

5. Decode String

6. Flatten Nested List Iterator

4/ Binary Search

1. Sqrt(x)

2. Time Based Key-Value Store

3. Find First and Last Position of Element in Sorted Array

4. Search in Rotated Sorted Array

5. Snapshot Array

6. Median of Two Sorted Arrays

5/ Sliding Window

1. Contains Duplicate II

2. Longest Substring Without Repeating Characters

3. Subarray Product Less Than K

4. Find All Anagrams in a String

5. Sliding Window Maximum

6/ Linked List

1. Reverse Linked List

2. Merge Two Sorted Lists

3. LRU Cache

4. Add Two Numbers

5. Delete Node in a Linked List

6. Remove Nth Node From End of List

7/ Trees

1. Maximum Depth of Binary Tree

2. Binary Tree Paths

3. Lowest Common Ancestor of a Binary Tree

4. Binary Tree Level Order Traversal

5. Validate Binary Search Tree

6. Serialize and Deserialize Binary Tree

8/ Trie

1. Longest Common Prefix

2. Word Break

3. Implement Trie (Prefix Tree)

4. Design Add And Search Words Data Structure

9/ Backtracking

1. Generate Parentheses

2. Maximum Rows Covered by Columns

3. Permutations

4. Letter Combinations of a Phone Number

5. Word Search

6. Number of Squareful Arrays

10/ Heap (Priority Queue)

1. Top K Frequent Elements

2. Kth Largest Element in an Array

3. Task Scheduler

4. Merge k Sorted Lists

5. Find Median from Data Stream

6. Find Servers That Handled Most Number of Requests

11/ Graphs

1. Number of Islands

2. Course Schedule

3. Course Schedule II

4. Array Nesting

5. Word Ladder

12/ Intervals

1. Insert Interval

2. Interval List Intersections

3. Merge Intervals

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Maximum Subarray

3. Best Time to Buy and Sell Stock II

14/ Prefix Sum

1. Product of Array Except Self

2. Subarray Sum Equals K

3. Random Pick with Weight

15/ Miscellaneous

1. Reverse Bits

2. Climbing Stairs

3. Number of 1 Bits

4. Reverse Integer

5. Integer to English Words

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Here are 77 LeetCode Problems I will solve to crack my TikTok interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my TikTok interview:

1/ Arrays & Hashing

1. Two Sum

2. Design HashMap

3. Insert Delete GetRandom O(1)

4. Spiral Matrix

5. Longest Consecutive Sequence

2/ Two Pointers

1. Longest Palindromic Substring

2. 3Sum

3. Sort Colors

4. Container With Most Water

5. Compare Version Numbers

6. Trapping Rain Water

3/ Stack

1. Valid Parentheses

2. Decode String

3. Basic Calculator II

4. Daily Temperatures

5. Asteroid Collision

6. Subarray With Elements Greater Than Varying Threshold

4/ Binary Search

1. Sqrt(x)

2. Longest Increasing Subsequence

3. Search in Rotated Sorted Array

4. Capacity To Ship Packages Within D Days

5. Maximum Value at a Given Index in a Bounded Array

6. Snapshot Array

7. Find Peak Element

5/ Sliding Window

1. Longest Substring Without Repeating Characters

2. Longest Substring with At Least K Repeating Characters

3. Count Complete Subarrays in an Array

4. Minimum Window Substring

5. Minimum Moves to Pick K Ones

6. Sliding Window Maximum

6/ Linked List

1. Reverse Linked List

2. Merge Two Sorted Lists

3. LRU Cache

4. Reorder List

5. Sort List

6. Reverse Nodes in k-Group

7/ Trees

1. Construct Binary Tree from Preorder and Inorder Traversal

2. Number of Good Leaf Nodes Pairs

3. Binary Tree Right Side View

4. Lowest Common Ancestor of a Binary Tree

5. Binary Tree Maximum Path Sum

6. Serialize and Deserialize Binary Tree

8/ Trie

1. Longest Common Prefix

2. Word Break

3. Design Add And Search Words Data Structure

4. Word Search II

9/ Backtracking

1. Word Search

2. Restore IP Addresses

3. Generate Parentheses

4. Combination Sum

5. N-Queens

6. Word Break II

10/ Heap (Priority Queue)

1. Kth Largest Element in an Array

2. Top K Frequent Elements

3. Reorganize String

4. Longest Happy String

5. Merge k Sorted Lists

6. Meeting Rooms III

11/ Graphs

1. Number of Islands

2. Course Schedule II

3. Course Schedule

4. Max Area of Island

5. Making A Large Island

6. Word Ladder

12/ Intervals

1. Insert Interval

2. Merge Intervals

3. Non-overlapping Intervals

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Coin Change

3. House Robber

4. Maximum Swap

14/ Prefix Sum

1. Subarray Sum Equals K

2. Count the Hidden Sequences

3. Find the Score of All Prefixes of an Array

15/ Miscellaneous

1. Longest Increasing Path in a Matrix

2. Bus Routes

3. Shortest Path in a Grid with Obstacles Elimination

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Here are 77 LeetCode Problems I will solve to crack my Uber interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my Uber interview:

1/ Arrays & Hashing

1. Two Sum

2. Valid Anagram

3. Insert Delete GetRandom O(1)

4. Spiral Matrix

5. Valid Sudoku

6. Group Anagrams

7. Block Placement Queries

2/ Two Pointers

1. Squares of a Sorted Array

2. Happy Number

3. Merge Strings Alternately

4. Valid Palindrome

5. Find the Distance Value Between Two Arrays

6. Rotating the Box

3/ Stack

1. Exclusive Time of Functions

2. Asteroid Collision

3. Min Stack

4. Maximum Subarray Min-Product

5. Largest Rectangle in Histogram

6. Basic Calculator

4/ Binary Search

1. My Calendar I

2. Random Pick with Weight

3. Time Based Key-Value Store

4. Search in Rotated Sorted Array

5. Minimum Time to Complete Trips

6. Escape the Spreading Fire

5/ Sliding Window

1. Longest Continuous Subarray With Absolute Diff Less Than or Equal to Limit

2. Maximize Win From Two Segments

3. Minimum Operations to Make Binary Array Elements Equal to One I

4. Count Subarrays With Fixed Bounds

5. Minimum Window Substring

6/ Linked List

1. Reverse Linked List

2. LRU Cache

3. Swap Nodes in Pairs

4. Remove Zero Sum Consecutive Nodes from Linked List

5. Copy List with Random Pointer

6. All O`one Data Structure

7/ Trees

1. Maximum Depth of Binary Tree

2. Construct Quad Tree

3. Kth Smallest Element in a BST

4. House Robber III

5. Delete Node in a BST

6. Serialize and Deserialize Binary Tree

8/ Trie

1. Word Break

2. Replace Words

3. Word Search II

9/ Backtracking

1. Word Search

2. Letter Combinations of a Phone Number

3. Subsets

4. Generate Parentheses

5. Sudoku Solver

6. Word Break II

10/ Heap (Priority Queue)

1. Top K Frequent Words

2. Top K Frequent Elements

3. Find K Pairs with Smallest Sums

4. Maximum Number of Eaten Apples

5. Merge k Sorted Lists

6. Meeting Rooms III

11/ Graphs

1. Number of Islands

2. Evaluate Division

3. Course Schedule II

4. Shortest Bridge

5. Course Schedule

6. Bus Routes

12/ Intervals

1. Insert Interval

2. Interval List Intersections

3. Count Integers in Intervals

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Decode Ways

3. Cherry Pickup

4. Text Justification

14/ Prefix Sum

1. Product of Array Except Self

2. Subarray Sums Divisible by K

3. Subarray Sum Equals K

15/ Miscellaneous

1. Shuffle an Array

2. Find the Closest Palindrome

3. Split Message Based on Limit

4. Making A Large Island

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Here are 77 LeetCode Problems I will solve to crack my Bloomberg interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my Bloomberg interview:

1/ Arrays & Hashing

1. Remove Letter To Equalize Frequency

2. Two Sum

3. Roman to Integer

4. Valid Anagram

5. Insert Delete GetRandom O(1)

6. Invalid Transactions

7. Design Underground System

8. Group Anagrams

2/ Two Pointers

1. Remove Duplicates from Sorted Array

2. Container With Most Water

3. 3Sum

4. Longest Palindromic Substring

5. Valid Triangle Number

6. Trapping Rain Water

3/ Stack

1. Valid Parentheses

2. Maximum Nesting Depth of the Parentheses

3. Decode String

4. Min Stack

5. Remove All Adjacent Duplicates in String II

6. Minimum Remove to Make Valid Parentheses

7. Design Browser History

8. Basic Calculator II

4/ Binary Search

1. Search Insert Position

2. Sqrt(x)

3. Search in Rotated Sorted Array

4. Search a 2D Matrix

5. Peak Index in a Mountain Array

6. Median of Two Sorted Arrays

5/ Sliding Window

1. Contains Duplicate II

2. Maximum Average Subarray I

3. Find X-Sum of All K-Long Subarrays I

4. Longest Substring Without Repeating Characters

5. Fruit Into Baskets

6. Minimum Size Subarray Sum

6/ Linked List

1. Merge Two Sorted Lists

2. Flatten a Multilevel Doubly Linked List

3. Add Two Numbers

4. LRU Cache

5. Reorder List

6. Rotate List

7/ Trees

1. Binary Tree Inorder Traversal

2. Validate Binary Search Tree

3. Flatten Binary Tree to Linked List

4. Binary Tree Level Order Traversal

5. Construct Binary Tree from Preorder and Inorder Traversal

6. Vertical Order Traversal of a Binary Tree

8/ Trie

1. Longest Common Prefix

2. Implement Magic Dictionary

3. Word Break

4. Implement Trie (Prefix Tree)

9/ Backtracking

1. Word Search

2. All Paths From Source to Target

3. Next Greater Numerically Balanced Number

4. Letter Combinations of a Phone Number

5. Permutations II

6. Word Break II

10/ Heap (Priority Queue)

1. Relative Ranks

2. Top K Frequent Elements

3. Top K Frequent Words

4. Merge k Sorted Lists

5. Find Median from Data Stream

6. IPO

11/ Graphs

1. Evaluate Division

2. Course Schedule II

3. Number of Islands

4. Rotting Oranges

5. Shortest Path in Binary Matrix

12/ Intervals

1. Merge Intervals

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Sort Integers by The Power Value

3. Maximum Subarray

14/ Prefix Sum

1. Subarray Sum Equals K

2. Product of Array Except Self

3. Continuous Subarray Sum

15/ Miscellaneous

1. Palindrome Number

2. Plus One

3. Reverse Integer

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Here are 75 LeetCode Problems I will solve to crack my Microsoft interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my Microsoft interview:

1/ Arrays & Hashing

1. Two Sum

2. Roman to Integer

3. Valid Anagram

4. Group Anagrams

5. Smallest String With Swaps

6. Spiral Matrix

2/ Two Pointers

1. Remove Duplicates from Sorted Array

2. Longest Palindromic Substring

3. Container With Most Water

4. 3Sum

5. Sort Colors

6. Trapping Rain Water

3/ Stack

1. Valid Parentheses

2. Final Prices With a Special Discount in a Shop

3. Next Greater Element I

4. Decode String

5. Asteroid Collision

6. Online Stock Span

4/ Binary Search

1. Search in Rotated Sorted Array

2. Find Peak Element

3. Find Minimum in Rotated Sorted Array

4. Find First and Last Position of Element in Sorted Array

5. Search a 2D Matrix

6. Median of Two Sorted Arrays

5/ Sliding Window

1. Longest Nice Substring

2. Longest Substring Without Repeating Characters

3. Longest Repeating Character Replacement

4. Permutation in String

5. Minimum Operations to Make Binary Array Elements Equal to One I

6. Sliding Window Maximum

6/ Linked List

1. Merge Two Sorted Lists

2. Add Two Numbers

3. Design Authentication Manager

4. LRU Cache

5. Remove Nth Node From End of List

6. Copy List with Random Pointer

7/ Trees

1. Symmetric Tree

2. Same Tree

3. Maximum Depth of Binary Tree

4. Recover Binary Search Tree

5. Lowest Common Ancestor of a Binary Tree

6. Serialize and Deserialize Binary Tree

8/ Trie

1. Longest Common Prefix

2. Design Add And Search Words Data Structure

3. Implement Trie (Prefix Tree)

9/ Backtracking

1. Letter Combinations of a Phone Number

2. Generate Parentheses

3. Word Search

4. Restore IP Addresses

5. Subsets

6. N-Queens

10/ Heap (Priority Queue)

1. Kth Largest Element in an Array

2. Top K Frequent Elements

3. Reorganize String

4. Cheapest Flights Within K Stops

5. Task Scheduler

6. Merge k Sorted Lists

11/ Graphs

1. Course Schedule

2. Course Schedule II

3. Number of Provinces

4. Is Graph Bipartite?

5. Number of Islands

6. Minimum Edge Reversals So Every Node Is Reachable

12/ Intervals

1. Merge Intervals

2. Insert Interval

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Climbing Stairs

3. Maximum Subarray

4. Longest Palindromic Subsequence

14/ Prefix Sum

1. Subarray Sum Equals K

2. Product of Array Except Self

3. Shifting Letters

15/ Miscellaneous

1. Palindrome Number

2. Reverse Integer

3. Next Permutation

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Here are 76 LeetCode Problems I will solve to crack my Meta interview.

And no, I won’t “grind 500 problems.”

I will focus on the right ones.

These are the exact problems I will practice right before my Meta interview:

1/ Arrays & Hashing

1. Two Sum

2. Contains Duplicate

3. Roman to Integer

4. Simple Bank System

5. Custom Sort String

6. Group Anagrams

2/ Two Pointers

1. Valid Palindrome II

2. Merge Sorted Array

3. Valid Palindrome

4. Longest Palindromic Substring

5. Container With Most Water

6. 3Sum

3/ Stack

1. Valid Parentheses

2. Remove All Adjacent Duplicates In String

3. Remove Outermost Parentheses

4. Minimum Remove to Make Valid Parentheses

5. Simplify Path

6. Basic Calculator II

4/ Binary Search

1. Kth Missing Positive Number

2. Binary Search

3. Search Insert Position

4. Random Pick with Weight

5. Find Peak Element

6. Find First and Last Position of Element in Sorted Array

5/ Sliding Window

1. Contains Duplicate II

2. Maximum Average Subarray I

3. Find the K-Beauty of a Number

4. Longest Substring Without Repeating Characters

5. Max Consecutive Ones III

6. Minimum Window Substring

6/ Linked List

1. Intersection of Two Linked Lists

2. Reverse Linked List

3. Remove Duplicates from Sorted List

4. Add Two Numbers

5. LRU Cache

6. Copy List with Random Pointer

7/ Trees

1. Diameter of Binary Tree

2. Range Sum of BST

3. Same Tree

4. Binary Tree Right Side View

5. Lowest Common Ancestor of a Binary Tree

6. Sum Root to Leaf Numbers

8/ Trie

1. Longest Common Prefix

2. Count Prefix and Suffix Pairs I

3. Word Break

4. Implement Trie (Prefix Tree)

5. Design Add And Search Words Data Structure

9/ Backtracking

1. Binary Tree Paths

2. Binary Watch

3. Sum of All Subset XOR Totals

4. Generate Parentheses

5. Subsets

6. Combination Sum

10/ Heap (Priority Queue)

1. Last Stone Weight

2. Kth Largest Element in a Stream

3. Relative Ranks

4. K Closest Points to Origin

5. Top K Frequent Elements

6. Merge k Sorted Lists

11/ Graphs

1. Find Center of Star Graph

2. Find the Town Judge

3. Find if Path Exists in Graph

4. Clone Graph

5. Course Schedule

6. Longest Increasing Path in a Matrix

12/ Intervals

1. Interval List Intersections

2. Merge Intervals

3. Insert Interval

13/ Greedy & Dynamic Programming

1. Best Time to Buy and Sell Stock

2. Maximum Subarray

3. Trapping Rain Water

14/ Prefix Sum

1. Subarray Sum Equals K

2. Continuous Subarray Sum

3. Product of Array Except Self

15/ Miscellaneous

1. Pow(x, n)

2. Making A Large Island

If you’re preparing for FAANG in 2026, don’t forget to save this post.

Also, here’s a platform which you can use to practice for your interviews:

🔗 Interview Roadmap Platform: Link

Best of luck!

Problem Overview

Difficulty: Easy
LeetCode Pattern: Graph

You are given a 2D integer array edges where each edges[i] = [ui, vi] indicates that there is an edge between the nodes ui and vi. Return the center of the given graph.

Example

Input:
· edges = [[1,2],[2,3],[4,2]]
Output: 
· 2
Reason:
· 2 is the center of this graph

Step 1: Clarify Requirements

• Can edges be empty?

  • No.

• Can there be multiple centers?

  • No.

• Is graph guaranteed to have a center?

  • Yes.

Step 2: Discuss Approaches

1/ Use a HashMap (Suboptimal ⚠️)

• Logic:

  • Count # of edges for each node

  • Store these in a HashMap

  • Return node with max degree

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(n)

2/ Check Two Edges (Optimal ✅)

• Logic:

  • We only need to check first 2 edges

  • Node common to both is the center

• Big O:

  • Time Complexity: O(1)

  • Space Complexity: O(1)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if no guaranteed center?

  • If no center, return -1.

• What if graph is directed?

  • Center = node with all incoming edges.

👨‍💻 Need Interview Practice?

• Book a 1:1 with me

• Book Here: Booking URL

Problem Overview

Difficulty: Medium
LeetCode Pattern: DFS

Given an m x n binary grid which represents a map of ‘1’s (land) and ‘0’s (water), return the maximum area of an island in grid. If there is no island, return 0.

Note: An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. Assume all four edges of the grid are all surrounded by water.

Input: grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]

Output:
· 4

Reason:
· This grid has three islands
· Area of first island = 4 → maximum
· Area of second island = 1
· Area of third island = 2

Step 1: Clarify Requirements

• Can the grid be empty?

  • Yes, it can be empty.

  • Return 0 in that case.

• Will it only contains 0’s and 1s?

  • Yes, you can assume that.

• Will 0’s and 1’s be integers or strings?

  • They will be given as strings.

Step 2: Discuss Approaches

1/ Use DFS (Optimal ✅)

• Logic:

  • Iterate through every cell in the grid

  • When a '1' (land) is found:

    • Run DFS starting here

    • Mark visited cells as '0'

    • Track area for this island

    • If current area is larger:

      • Update maxArea

  • At the end, return the maxArea

• Big O:

  • Time Complexity: O(m·n)

  • Space Complexity: O(m·n)

2/ Use BFS (Alternative ✅)

• Logic:

  • Iterate through the grid

  • When a '1' is found:

    • Push cell into a queue

    • While queue is not empty:

      • Pop cell, mark as '0'

      • Push all valid neighbors

      • Count cells to get area

    • If current area is larger:

      • Update maxArea

  • At the end, return the maxArea

• Big O:

  • Time Complexity: O(m·n)

  • Space Complexity: O(m·n)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the grid is empty?

  • Return 0.

  • No cells → no islands → no area.

• What if we allow diagonal connections?

  • Add 4 more directions in DFS.

  • Total neighbors = 8 instead of 4.

• What if the grid is very large?

  • DFS may cause stack overflow.

  • Use BFS or iterative DFS with stack.

Problem Overview

Difficulty: Easy
LeetCode Pattern: DFS

Given the root of a binary tree, return the length of the diameter of the tree.

Note:

• The diameter of a binary tree is the length of the longest path between any two nodes in a tree. This path may or may not pass through the root.

• The length of a path between two nodes is represented by the number of edges between them.

Input:
    1
   / \
  2   3
 / \
4   5

Output: 3

Reason: 3 is the length of the path [4,2,1,3] or [5,2,1,3].

Step 1: Clarify Requirements

• Can the tree be empty?

  • Yes, it can be empty.

  • Diameter = 0 in that case.

• What if tree has just root node?

  • Diameter = 0 in that case also.

• Do we need the path itself?

  • No, just the length of diameter.

Step 2: Discuss Approaches

1/ Check All Diameters (Brute Force ⚠️)

• Logic:

  • For every node in the tree:

    • Get left subtree height

    • Get right subtree height

    • Diameter = left + right

  • Keep track of max diameter seen

• Big O:

  • Time Complexity: O(n²)

  • Space Complexity: O(h)

2/ Use Post-Order DFS (Optimal ✅)

• Logic:

  • Use post-order DFS:

    • left → right → node

  • For each node:

    • Compute left subtree height

    • Compute right subtree height

    • max = max(curr, left + right)

  • Return height = 1 + max(left, right)

  • At the end, return maxDiameter

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(h)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if tree is very large?

  • Recursion may hit stack overflow.

  • Use iterative DFS instead.

• What if we need to return path?

  • Track nodes instead of just lengths.

  • During DFS, for each node:

    • Get left path

    • Get right path

    • curr_path = left + [node] + right

    • If curr_path size > max_path:

      • update max_path

  • Return max_path at the end.

Problem Overview

Difficulty: Medium
LeetCode Pattern: DFS

Given an m x n binary grid which represents a map of ‘1’s (land) and ‘0’s (water), return the number of islands.

Note: An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. Assume all four edges of the grid are all surrounded by water.

Example

Input: grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]

Output:
· 3

Step 1: Clarify Requirements

• Can the grid be empty?

  • Yes, it can be empty.

  • Return 0 in that case.

• Will it only contains 0’s and 1s?

  • Yes, you can assume that.

• Will 0’s and 1’s be integers or strings?

  • They will be given as strings.

Step 2: Discuss Approaches

1/ Use DFS (Optimal ✅)

• Logic:

  • Iterate through every cell in the grid

  • When a '1' (land) is found:

    • Increment island count

    • Run DFS from this point

  • During DFS:

    • Mark current cell as '0'

    • Recurse up, down, left, right

  • At the end, return island count

• Big O:

  • Time Complexity: O(m·n)

  • Space Complexity: O(m·n)

2/ Use BFS (Alternative ✅)

• Logic:

  • Iterate through grid

  • When a '1' is found:

    • Increment island count

    • Push cell into queue

  • While queue not empty:

    • Pop cell

    • Mark it as visited ('0')

    • Push all valid land neighbors

• Big O:

  • Time Complexity: O(m·n)

  • Space Complexity: O(m·n)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the grid is empty?

  • Return 0.

  • No cells → no islands.

• What if we allow diagonal connections?

  • Add 4 more directions in DFS.

  • Total neighbors = 8 instead of 4.

• What if the grid is very large?

  • DFS may cause stack overflow.

  • Use BFS or iterative DFS with stack.

Problem Overview

Difficulty: Easy
LeetCode Pattern: DFS

Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.

Note: A leaf is a node with no children.

Tree:
    1
   / \
  2   3
 /     \
4       5

Example 1:
· Input: targetSum = 9
· Output: true

Example 2:
· Input: targetSum = 2
· Output: false

Step 1: Clarify Requirements

• Can the tree be empty?

  • Yes, it can be empty.

  • Return false in that case.

• Can node values be negative?

  • Yes, they can be negative.

• Can targetSum be negative?

  • Yes, targetSum can be negative.

• Do we need to return the path?

  • No, only return true or false.

Step 2: Discuss Approaches

1/ Check All Paths (Suboptimal ⚠️)

• Logic:

  • Find all root-to-leaf paths

  • For each path:

    • Compute sum of node values

    • Check if sum equals targetSum

  • If any path matches → return true

• Big O:

  • Time Complexity: O(n²)

  • Space Complexity: O(h)

2/ Use DFS (Optimal ✅)

• Logic:

  • Use DFS starting from root

  • Pass remainingSum = targetSum

  • At each node:

    • Do remainingSum -= node.val

  • If at a leaf node:

    • Check if remainingSum == 0

    • If yes → return true

  • Recursively check left and right:

    • Pass updated remainingSum

  • If any path returns true:

    • return true

  • Otherwise:

    • return false

• Big O:

  • Time Complexity: O(n)

  • Space Complexity: O(h)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the tree is empty?

  • Return false.

  • No root-to-leaf path exists.

• What if the targetSum is 0?

  • Still need to check all paths.

  • Return true if path sum == 0.

• What if node values are negative?

  • Our solutions works fine.

  • DFS handles negatives naturally.

• Can we stop early?

  • Our solution does stop early.

  • It returns once it finds a valid path.

Problem Overview

Difficulty: Medium
LeetCode Pattern: BFS

You are given an m x n grid where each cell can have one of three values:

• 0 representing an empty cell,

• 1 representing a fresh orange, or

• 2 representing a rotten orange.

Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten.

Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.

Example

Input:
grid = 
[[2,1,1],
 [1,1,0],
 [0,1,1]]

Output:
· 4

Step 1: Clarify Requirements

• Can the grid be empty?

  • Yes, it can be empty.

  • Return 0 in that case.

• Can fresh oranges be unreachable?

  • Yes, that is possible.

  • Return -1 if that happens.

• Can many oranges be rotten initially?

  • Yes, that is possible.

  • Rotting starts from all those places.

Step 2: Discuss Approaches

1/ One-By-One (Brute Force ⚠️)

• Logic:

  • For each minute:

    • Scan the grid

    • Find fresh orange

    • If next to a rotten orange:

      • Rot this fresh orange

  • Repeat till no fresh oranges can rot

• Big O:

  • Time Complexity: O(m·n)²

  • Space Complexity: O(1)

2/ Multi-Source BFS (Optimal ✅)

• Logic:

  • Use a queue

  • Store all rotten oranges initially

  • Track minutes elapsed

  • While queue not empty:

    • Process all rotten oranges

    • For each rotten orange:

      • Rot adjacent fresh oranges

      • Add these to the queue

  • After BFS finishes:

    • check if fresh oranges remain

    • If yes, return -1

    • If no, return minutes elapsed

• Big O:

  • Time Complexity: O(m·n)

  • Space Complexity: O(m·n)

Step 3: Write Code (Optimal)

Python

Java

C++

Step 4: Answer Follow-Ups

• What if the grid is empty?

  • Return 0.

  • No oranges to rot.

• What if we allow diagonal spread?

  • Add 4 diagonal checks also.

  • BFS will still work correctly.