Skip to main content
Welcome to Questions100! This guide will help you navigate the collection efficiently and start solving problems right away.

​
Understanding the Collection

Questions100 contains 100 carefully curated LeetCode problems with comprehensive documentation for each:

Complete Solutions

Python implementations with O(n) complexity analysis

Real Examples

3-4 test cases per problem with detailed explanations

Interview Focus

Frequency data showing how often problems appear in interviews

Applications

Real-world and cybersecurity use cases for each algorithm

​
Quick Navigation

​
By Difficulty

1

Easy (21 problems)

Perfect for building fundamentals. Start here if you’re new to algorithms.Recommended First Problems:
  • #017 - Two Sum (76.4% frequency) - Hash Table basics
  • #020 - Valid Parentheses (74.9% frequency) - Stack fundamentals
  • #018 - Best Time to Buy and Sell Stock (76.4% frequency) - Dynamic Programming intro
2

Medium (63 problems)

Core interview problems. This is where most interview questions come from.Must-Know Problems:
  • #001 - Minimum Remove to Make Valid Parentheses (100% frequency)
  • #016 - Merge Intervals (77.9% frequency)
  • #039 - LRU Cache (62.4% frequency)
3

Hard (16 problems)

Advanced problems for senior roles and competitive preparation.Top Hard Problems:
  • #037 - Minimum Window Substring
  • #019 - Merge k Sorted Lists
  • #100 - Median of Two Sorted Arrays

​
By Category

The collection is organized into key algorithmic categories:
Problems: Two Sum (#017), Merge Intervals (#016), Subarray Sum Equals K (#026), 3Sum (#065), Top K Frequent Elements (#015)When to use: When you need fast lookups, frequency counting, or set operations.
Problems: Valid Palindrome (#029), Valid Palindrome II (#004), Merge Sorted Array (#033), Container With Most Water (#073)When to use: Working with sorted arrays, finding pairs, or optimizing from O(n²) to O(n).
Problems: Valid Parentheses (#020), Minimum Remove to Make Valid Parentheses (#001), Basic Calculator II (#008), Simplify Path (#035)When to use: Parsing expressions, matching pairs, or tracking nested structures.
Problems: Diameter of Binary Tree (#014), Binary Tree Right Side View (#007), Lowest Common Ancestor (#009), Range Sum of BST (#027)When to use: Hierarchical data, tree traversals, or ancestor/descendant relationships.
Problems: Clone Graph (#025), Course Schedule (#063), Shortest Path in Binary Matrix (#031), Making A Large Island (#036)When to use: Connectivity problems, shortest paths, or exploring all possibilities.
Problems: Best Time to Buy and Sell Stock (#018, #099), Maximum Subarray (#087), Word Break (#075), Longest Palindromic Substring (#096)When to use: Optimization problems with overlapping subproblems.
Problems: Longest Substring Without Repeating Characters (#080), Max Consecutive Ones III (#040), Minimum Window Substring (#037)When to use: Finding subarrays or substrings with specific properties.

​
How to Use Each Problem Page

Every problem in Questions100 follows a consistent structure:

​
Problem Structure

# NNN. Problem Title

Metadata:
├── Difficulty (Easy/Medium/Hard)
├── Interview Frequency (%)
├── Acceptance Rate
└── LeetCode Link

Content:
├── Problem Description with Constraints
├── 3-4 Real Examples with Explanations
├── Optimal Solution with Python Code
├── Time & Space Complexity Analysis
├── Categories & Tags
└── Real-World Applications

​
Example: Two Sum (#017)

def twoSum(nums: List[int], target: int) -> List[int]:
    """
    Find two numbers that add up to target using hash map.
    
    Time: O(n), Space: O(n)
    """
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []
Time Complexity: O(n) - single pass through array
Space Complexity: O(n) - hash map storage

​
Top 10 Problems to Start With

Based on interview frequency and foundational importance:

1. Two Sum

Easy • 76.4% frequency
Hash Table fundamentals

2. Valid Parentheses

Easy • 74.9% frequency
Stack basics

3. Merge Intervals

Medium • 77.9% frequency
Sorting and greedy algorithms

4. LRU Cache

Medium • 62.4% frequency
Design with hash map + linked list

5. Best Time to Buy/Sell

Easy • 76.4% frequency
Dynamic programming intro

6. Min Remove Parentheses

Medium • 100% frequency
Stack + string manipulation

7. Binary Tree Vertical

Medium • 93.4% frequency
BFS + hash map for trees

8. Kth Largest Element

Medium • 86.9% frequency
Heap/quickselect

9. Valid Palindrome II

Easy • 92.7% frequency
Two pointers + greedy

10. Basic Calculator II

Medium • 84.0% frequency
Stack for expression parsing

​
Effective Practice Strategy

1

Read the Problem Thoroughly

  • Understand constraints (they often hint at the approach)
  • Check input/output ranges
  • Note special cases mentioned
2

Try to Solve (20-30 minutes)

  • Start with brute force approach
  • Identify bottlenecks
  • Think about data structures that could help
  • Don’t look at the solution immediately!
3

Study the Optimal Solution

  • Understand WHY it works, not just HOW
  • Compare complexity with your approach
  • Notice patterns and techniques
4

Implement from Scratch

  • Close the solution
  • Write code without looking
  • Test with the provided examples
  • Add edge cases
5

Review and Connect

  • Read real-world applications
  • See how this pattern appears in other problems
  • Practice explaining your approach out loud

​
Collection Statistics

Total Problems: 100
Documentation Size: ~800 KB, ~19,000 lines
Code Examples: 100+ working Python solutions
Test Cases: 400+ example inputs/outputs
Real-World Applications: 500+ specific named applications
Security Use Cases: 600+ cybersecurity applications

​
Next Steps

Study Plans

Follow structured weekly plans for 1-8 week preparation timelines

Browse by Category

Explore problems organized by algorithmic pattern

Top Interview Problems

Focus on the most frequently asked problems

Interview Tips

Learn how to communicate your approach during interviews
Pro Tip: Start with one category at a time. Master 5-7 problems in Arrays & Hashing before moving to the next pattern. This builds pattern recognition faster than jumping between categories.

Build docs developers (and LLMs) love

Get started for freeTalk to us