Problems Index (START HERE)

Total: 156 Clean Problems organized by Difficulty Level

Quick Navigation

• Beginner Level: 28 Problems - 05-phase1-beginner.md

• Intermediate Level: 66 Problems - 06-phase2-intermediate.md

• Advanced Level: 52 Problems - 07-phase3-advanced.md

• Expert Level: 10 Problems - 08-phase4-expert.md

---

BEGINNER LEVEL

38 Problems - Foundation & Fundamentals

Topics: Variables, Operators, Basic Control Flow, Simple Loops, Functions, Basic I/O

#	Problem	Concepts
1	Simple Calculator	Variables, Arithmetic, Switch Statement
2	Grade Calculator	If-Else, Comparison Operators
3	Even/Odd Checker	Modulo, Loops, Boolean Logic
4	Swap Numbers (3 Ways)	Variable Manipulation, XOR
5	Temperature Converter	Methods, Parameters, Formatting
6	Number Properties Analyzer	Math Operations, Boolean Methods
7	Simple Interest Calculator	Formula Application, Validation
8	Time Format Converter	String Parsing, Formatting
9	Bill Calculator with Discount	Arithmetic, Conditional Logic
10	BMI Calculator	Formula, Classification
11	Multiplication Table Generator	For Loop, String Interpolation
12	Number Guessing Game	While Loop, Random Numbers
13	Sum and Average Calculator	Arrays, Loops, Aggregation
14	Prime Number Checker	Loops, Optimization
15	Factorial Calculator	Loops, Accumulation
16	Fibonacci Series Generator	Loop Patterns, Sequence Logic
17	Digit Sum Calculator	While Loop, Integer Math
18	Reverse a Number	Loop, Math Operations
19	Armstrong Number Checker	Loops, Power Function
20	Perfect Number Validator	Nested Loops, Divisor Logic
21	Right-Angled Triangle	Nested Loops, Pattern Logic
22	Pyramid Pattern	Loop Control, Spacing
23	Diamond Pattern	Complex Nesting, Symmetry
24	Number Pyramid	Variable Patterns, Formatting
25	Floyd's Triangle	Sequence Generation
26	Palindrome Number Checker	While Loop, Number Reversal
27	Sum of Digits Until Single	Loops, Recursion
28	Leap Year Validator	Date Constraints, Logic
29	Vowel Counter	String Iteration, Conditionals
30	Character Frequency Counter	String Operations, Counting
31	Simple String Reversal	String Operations, Loops
32	Anagram Checker (Basic)	String Manipulation
33	Array Sum and Product	Array Operations, Aggregation
34	Find Element in Array	Linear Search
35	Duplicate Finder (Simple)	Nested Loops
36	Largest and Second Largest	Array Comparison
37	Remove Duplicates (Nested Approach)	Array Manipulation
38	Bubble Sort (Introduction)	Sorting Fundamentals

See source: [05-phase1-beginner.md - Problems 1-38]

---

INTERMEDIATE LEVEL

89 Problems - Collections, OOP, Core Patterns

Topics: Arrays (advanced), Lists, Dictionaries, Basic OOP, Classes, Encapsulation, Collections, Design Patterns, LINQ basics, Strings

#	Problem	Concepts
12	Number Guessing Game	Integer Handling
35	Number Base Converter	Conversion Logic
39	Merge Two Sorted Arrays	Array Merging, Two Pointers
40	Rotate Array	Array Manipulation
41	Missing Number Finder	Array Logic
42	Simple List Operations	List Basics
43	Dictionary Word Count	Dictionary<K,V>
44	Stack Implementation	Stack Data Structure
45	Queue Implementation	Queue Data Structure
46	Class and Object Basics	OOP Fundamentals
47	Constructor and Initialization	Object Creation
48	Properties and Getters/Setters	Encapsulation
49	Inheritance Basics	Class Hierarchy
50	Abstract Classes (Introduction)	Abstract Members
51	Interface Implementation (Basic)	Interface Contracts
52	ToString and Equals Override	Object Methods
53	Polymorphism (Method Overriding)	Virtual Methods
54	Sealed Classes and Methods	Access Control
55	Static Members	Class-level Data
56	Extension Methods (Basic)	Adding Methods
57	Enum Declaration and Usage	Enumeration Types
58	Nullable Types	Null Handling
59	Exception Handling (Basic)	Try-Catch-Finally
60	Custom Exception Class	Exception Inheritance
61	Reverse Array In-Place	Two-Pointer Technique
62	Find Min/Max in Array	Linear Search
63	Check If Sorted	Validation
64	Rotate Array Efficiently	Array Manipulation
65	Two Pointer Sum	Efficient Search
66	Merge Two Sorted Arrays	Array Operations
67	Remove Duplicates (List)	List Operations
68	Intersection of Two Arrays	Set Operations
69	Union of Two Arrays	Set Operations
70	Longest Common Subarray	Comparison
71	Move Zeros to End	Array Rearrangement
72	Segregate Positive/Negative	Array Partitioning
73	Factorial Using Recursion	Recursion Basics
74	Fibonacci Using Recursion	Recursive Patterns
75	Power Calculation (Binary)	Efficient Algorithms
76	String Reversal (Recursion)	String Recursion
77	Palindrome Check (Recursion)	Recursive Validation
78	Binary Search	Efficient Search
79	Linear Search Analysis	Search Comparison
80	Bubble Sort	Basic Sorting
81	Selection Sort	Sorting Algorithm
82	Insertion Sort	Adaptive Sorting
83	Merge Sort	Divide & Conquer
84	Quick Sort	Partitioning Sort
85	Character Frequency (Dictionary)	Dictionary Usage
86	Most Frequent Element	Dictionary Operations
87	Pair with Given Sum	Hash-based Search
88	Group Words by Anagram	Dictionary Grouping
89	Longest Substring (Basic)	String Operations
90	String Contains All Characters	Pattern Matching
91	Simple Data Class	Class Design
92	Composition Pattern	Object Relationships
93	Delegation Pattern	Method Forwarding
94	Repository Pattern (Basic)	Data Access
95	List Advanced Operations	LINQ Introduction
96	Dictionary Iteration	Collection Iteration
97	Stack-based Problem Solving	Stack Usage
98	Queue for Sequence Processing	Queue Usage
99	Basic LINQ Queries	Query Syntax
100	LINQ Method Syntax	Fluent API

See source: [phase3-expanded.md, phase4-complete-celebration.md]

---

ADVANCED LEVEL

109 Problems - Advanced OOP, Generics, LINQ, Design Patterns

Topics: Generics, Advanced LINQ, Delegates/Events, Design Patterns, Advanced Data Structures, Abstract Design, IEnumerable, Advanced Strings

#	Problem	Concepts
101	LINQ Filtering & Sorting	Where, OrderBy, ThenBy
102	LINQ Projections	Select, SelectMany
103	LINQ Grouping	GroupBy, Aggregation
104	LINQ Joins	Inner, Outer, Cross Joins
105	LINQ Advanced Aggregations	Sum, Average, Min, Max
106	LINQ Custom Operators	Extension Methods on IEnumerable
107	Generic Class Definition	Type Parameters
108	Generic Method Implementation	Constrained Generics
109	Generic Repository	Reusable Generic Pattern
110	Delegate Basics	Function Pointers
111	Lambda Expressions	Anonymous Functions
112	Func and Action Delegates	Built-in Delegates
113	Events & Subscribers	Event-Driven Pattern
114	Observer Pattern	IObserver/IObservable
115	Singleton Pattern	Single Instance Design
116	Factory Pattern	Object Creation
117	Decorator Pattern	Behavior Extension
118	Adapter Pattern	Interface Translation
119	Strategy Pattern	Switchable Algorithms
120	Template Method Pattern	Inheritance-based Behavior
121	Chain of Responsibility	Sequential Processing
122	Command Pattern	Operation Encapsulation
123	IEnumerable Custom Collection	Enumerable Pattern
124	IEnumerator Implementation	Iterator Pattern
125	Yield Return Usage	Lazy Evaluation
126	Clone and Copy Constructor	Object Duplication
127	IComparable Implementation	Sorting Interface
128	IComparer Usage	Custom Comparison
129	IEquatable Implementation	Equality Definition
130	IDisposable Pattern	Resource Management
131	Using Statement	Automatic Disposal
132	Binary Search Tree (Basic)	Tree Data Structure
133	Linked List Implementation	Link-based Storage
134	Hash Table Implementation	Hash-based Storage
135	Trie Data Structure	Prefix-based Search
136	Graph Representation	Graph Basics
137	DFS (Depth-First Search)	Graph Traversal
138	BFS (Breadth-First Search)	Graph Traversal
139	Shortest Path (Dijkstra)	Pathfinding Algorithm
140	Topological Sort	DAG Sorting
141	Expression Parser	String Evaluation
142	Bracket Validation (Stack)	Parentheses Matching
143	Greatest Common Divisor	Mathematical Algorithm
144	Least Common Multiple	Mathematical Algorithm
145	Permutations Generation	Combinatorial Algorithm
146	Combinations Generation	Combinatorial Algorithm
147	Power Set Generation	Set Algorithm
148	Knapsack Problem (Dynamic)	Optimization
149	Longest Common Subsequence	Dynamic Programming
150	Edit Distance (Levenshtein)	String Similarity

...and ** 50+ more Advanced Problems** in:

• Pattern Matching

• Advanced Recursion

• Graph Algorithms

• Complex Data Structure Operations

• Design Pattern Mastery

See source: [phase4-section41-generics.md, phase4-section42-linq-complete.md, phase4-section43-complete.md, phase3-complete-expanded.md]

---

EXPERT LEVEL

32 Problems - Concurrency, System Design, Complex Algorithms

Topics: Threading, Tasks, Async/Await, Parallel Processing, Complex Algorithms, System Design, Advanced Concurrency

#	Problem	Concepts
151-162	String Algorithms	Interview-level string problems (12)
163-175	Array Algorithms	Interview-level array problems (13)
176	LRU Cache Implementation	Cache Design
177	Thread Synchronization	Mutex, Lock, Monitor
178	Thread Pool	Managed Threading
179	Task Parallel Library (TPL)	Task Creation
180	async/await Basics	Asynchronous Patterns
181	Async Exception Handling	Error Management in Async
182	Async I/O Operations	Non-blocking I/O
183	Concurrent Collections	Thread-Safe Data
184	Producer-Consumer Problem	Synchronization
185	Deadlock Demonstration	Concurrency Issues
186	Race Condition Handling	Synchronization
187	Semaphore & Mutex	Advanced Locking
188	ReaderWriterLock	Read-Write Synchronization
189	Async Stream Processing	Asynchronous Enumeration
190	Parallel LINQ (PLINQ)	Parallel Queries
191	Task Cancellation	Cancelation Tokens
192	Expression Evaluator	Complex Parsing
193	Custom Async Enumerator	Async Iteration
194	Reactive Extensions (Rx)	Event Stream Processing

See source: [phase5-section51-threading.md, phase5-section52-tasks.md, phase5-section53-async-await.md, interview-track-A-strings.md, interview-track-B-arrays.md]

---

INTERVIEW PREPARATION TRACK

String Algorithms (Problems 151-162): 12 Problems

• Reverse String (3 Methods)

• Check Anagrams

• First Non-Repeating Character

• Longest Substring Without Repeating Characters

• String Compression (aaabb → a3b2)

• Longest Palindromic Substring

• Valid Parentheses

• String Permutations

• String Rotation Check

• Longest Common Prefix

• Implement atoi (String to Integer)

• Regex Email Validator

See: [interview-track-A-strings.md]

Array Algorithms (Problems 163-175): 13 Problems

• Maximum Subarray Sum (Kadane's)

• Majority Element

• Contains Duplicate (advanced versions)

• Single Number (XOR technique)

• Median of Two Sorted Arrays

• Rotate Matrix (90 degrees)

• Spiral Matrix Traversal

• Word Search (Backtracking)

• Trapping Rain Water

• Best Time to Buy/Sell Stock

• 3Sum Problem (variations)

• Merge Intervals

• Insert Interval

See: [interview-track-B-arrays.md]

---

HOW TO USE THIS INDEX

1. Pick Your Starting Point

• Complete Beginner: Start with Beginner Level (Problems 1-38)

• Some Experience: Start with Intermediate Level

• Advanced Skills: Start with Advanced or Expert Level

2. Work Through Progressively

• Move from one difficulty level to the next

• Don't skip levels - each level builds on previous

• Complete problems in order within each level

3. Reference Source Files

• This index maps problems to source files

• Each level has detailed problems in dedicated phase files:

  • 05-phase1-beginner.md - 28 beginner problems

  • 06-phase2-intermediate.md - 66 intermediate problems

  • 07-phase3-advanced.md - 52 advanced problems

  • 08-phase4-expert.md - 10 expert problems

4. Interview Preparation

• After completing phases, use Interview Tracks

• String Algorithms: Common interview patterns

• Array Algorithms: High-frequency interview problems

---

PROBLEM DISTRIBUTION

Beginner     [████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 28   (18%)
Intermediate [███████████░░░░░░░░░░░░░░░░░░░░░░░░░] 66   (41%)
Advanced     [██████████░░░░░░░░░░░░░░░░░░░░░░░░░░] 52   (32%)
Expert       [██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 10   (6%)
                                                   ----
                         TOTAL                156 problems

---

NEXT STEPS

1. Choose your level using the Quick Navigation above

2. Open the corresponding phase file

3. Work through problems in order

4. Track your progress as you complete each problem

5. Move to next phase when complete

6. Use interview tracks for final preparation

---

Last updated: March 7, 2026 Total: 156 clean problems + 25 interview problems