Whether you're solving a Python, SQL, Java, or DSA problem, don't immediately start writing code. First understand the problem and break it into smaller pieces.
๐ 1. Understand the Problem
Read the problem carefully and identify:
What is the input?
What is the expected output?
What exactly are you being asked to calculate?
Are there any constraints?
Are there special cases?
๐ Don't start coding until you can explain the problem in your own words.
๐ 2. Work Through an Example
Take a small example and solve it manually.
For example:
Find the largest number in.[4,8,2,10,6]
Manually:
Start โ 4
Compare 8 โ largest = 8
Compare 2 โ largest = 8
Compare 10 โ largest = 10
Compare 6 โ largest = 10
Now the logic becomes much clearer.
๐ 3. Identify the Pattern
Ask yourself:
Have I solved a similar problem before?
Look for common patterns:
Searching, Sorting, Counting, Hashing, Two pointers, Sliding window, Recursion, Dynamic programming, Greedy approach, Stack / Queue, JOIN / aggregation for SQL
Recognizing the pattern can dramatically reduce the time needed to solve the problem.
๐ 4. Start With a Brute-Force Solution
Don't worry about optimization immediately.
First ask:
What is the simplest way I can solve this?
A working solution is better than an optimized solution that you cannot explain.
๐ 5. Write the Logic in Plain English
Before coding, write something like:
1. Take the first number as the largest.
2. Compare it with every other number.
3. If a larger number is found, update largest.
4. Return largest.
Then convert those steps into code.
๐ 6. Choose the Right Data Structure
Ask:
What data structure will make this problem easier?
Common choices:
List/Array โ Ordered collection
Set โ Unique values / fast membership
Dictionary/Hash Map โ Key-value lookup / counting
Stack โ Last-in-first-out problems
Queue โ First-in-first-out problems
Heap โ Min/max priority problems
Tree โ Hierarchical data
Graph โ Relationships/connections
Choosing the right data structure often makes the biggest difference.
๐ 7. Consider Edge Cases
Don't test only the normal case.
Think about:
Empty input, One element, Duplicate values, Negative numbers, Very large input, Already sorted input, Missing values, All values being the same
๐ 8. Analyze Time and Space Complexity
Once your solution works, ask:
How fast is it?
and
How much memory does it use?
For example:
O(1) โ Constant
O(log n) โ Very efficient
O(n) โ Linear
O(n log n) โ Common for efficient sorting
O(nยฒ) โ Can become slow for large inputs
You don't always need the most optimized solution, but you should understand the trade-off.
๐ 9. Test Your Solution
Use multiple test cases:
Normal case, Edge case, Small input, Large input, Duplicate values, Empty input
Don't assume your first solution is correct.
๐ 10. Optimize Only After It Works
Once you have a working solution, ask:
Can I reduce the time complexity?
Can I reduce memory usage?
Can I avoid unnecessary loops?
Can I use a better data structure?
This is where you move from a working solution to an efficient solution.
๐ง The 10-Step Coding Problem Framework
Understand โ Example โ Identify Pattern โ Brute Force โ Write Logic โ Choose Data Structure โ Handle Edge Cases โ Code โ Test โ Optimize
A strong programmer understands the problem faster, breaks it down correctly, and then writes simpler code to solve it.
๐ฌ Double Tap โค๏ธ For More