Coding-interview समस्याओं को हल करने की एक अच्छी रणनीति क्या है?

Question

Accepted Answer

एक भरोसेमंद रणनीति है **समझें, योजना बनाएं, फिर code लिखें** — कभी सीधे typing पर न कूदें। एक संरचित दृष्टिकोण edge cases को जल्दी सामने लाता है और आपकी सोच को स्पष्ट रूप से व्यक्त करता है।

## एक step-by-step framework

```text
1. CLARIFY  -> restate the problem, ask about inputs, ranges, edge cases
2. EXAMPLES -> work a small example by hand; note edge cases (empty, 1, dups)
3. BRUTE FORCE -> state the obvious solution and its complexity
4. OPTIMIZE -> spot the bottleneck; pick a pattern (hash, two-pointer, DP...)
5. CODE     -> write clean, modular code while talking through it
6. TEST     -> trace examples, check edges, fix bugs
7. ANALYZE  -> state final time and space complexity
```

## Pattern recognition

| संकेत | संभावित technique |
|--------|-----------------|
| sorted array / pair | two pointers / binary search |
| "subarray / substring" | sliding window / prefix sum |
| "count / seen before" | hash map |
| "all combinations" | backtracking |
| overlapping subproblems | dynamic programming |
| graph / grid reachability | BFS / DFS |

## उदाहरण मानसिकता

```python
# Always START from the brute force, THEN optimize.
# Brute force two-sum is O(n^2); a hash map makes it O(n).
# State this trade-off out loud before coding.
```

## सावधानियाँ

चुपचाप code न लिखें, edge cases को नज़रअंदाज़ न करें, और समय से पहले optimize न करें। पहले कुछ सही बनाएँ, फिर उसमें सुधार करें।

## यह क्यों महत्वपूर्ण है

एक दोहराने योग्य प्रक्रिया आपको शांत रखती है और उस घबराहट-भरी coding को रोकती है जो बग वाले solutions पैदा करती है।

हर step को बोलकर समझाना interviewer को आपके तर्क का अनुसरण करने और संकेत देने देता है — वे यह आँकते हैं कि आप *कैसे* सोचते हैं, न कि केवल अंतिम उत्तर।

वही समझने-योजना-बनाने-परखने का अनुशासन आपको वास्तविक, अस्पष्ट समस्याओं पर एक बेहतर engineer बनाता है।

संकेत	संभावित technique
sorted array / pair	two pointers / binary search
"subarray / substring"	sliding window / prefix sum
"count / seen before"	hash map
"all combinations"	backtracking
overlapping subproblems	dynamic programming
graph / grid reachability	BFS / DFS