सॉफ़्टवेयर इंजीनियर इंटरव्यू के सवाल और जवाब (2026): कोडिंग, बुनियादी बातें, डिज़ाइन और व्यवहार

ज़्यादातर कंपनियों में सॉफ़्टवेयर इंजीनियर के इंटरव्यू का ढाँचा एक जैसा होता है: रिक्रूटर कॉल, एक या दो कोडिंग राउंड, मिड-लेवल और सीनियर भूमिकाओं के लिए एक सिस्टम डिज़ाइन राउंड, और एक व्यवहार संबंधी राउंड। नीचे राउंड के हिसाब से समूहित 20 सॉफ़्टवेयर इंजीनियर इंटरव्यू के सवाल और जवाब दिए गए हैं। प्रकाशित करने से पहले हर कोड नमूने को हज़ारों रैंडम इनपुट पर एक brute-force वर्ज़न से परखा गया था।

हर राउंड में क्या परखा जाता है

नए ग्रैजुएट के इंटरव्यू ज़्यादातर कोडिंग और व्यवहार संबंधी होते हैं। सीनियर इंटरव्यू में सिस्टम डिज़ाइन ज़्यादा होता है, और पिछले प्रोजेक्ट्स पर गहरे जवाब की उम्मीद की जाती है। रिक्रूटर कॉल के लिए, हमारे फ़ोन स्क्रीन इंटरव्यू के सवाल देखें।

कोडिंग के सवाल

हर कोडिंग राउंड में टाइप करने से पहले अपना तरीका बताएँ, टाइम और स्पेस कॉम्प्लेक्सिटी कहें, और अंत में एक छोटे उदाहरण से टेस्ट करें। कॉम्प्लेक्सिटी वाला हिस्सा हमारी Big O चीट शीट में समझाया गया है।

1. Two sum: लक्ष्य के बराबर योग वाली दो संख्याओं के इंडेक्स लौटाएँ

हर संख्या का इंडेक्स एक हैश मैप में रखें। हर नई संख्या के लिए जाँचें कि उसका पूरक (complement) पहले से मैप में है या नहीं।

def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

print(two_sum([2, 7, 11, 15], 9))  # [0, 1]

टाइम O(n) और स्पेस O(n)। brute-force वर्ज़न हर जोड़े को O(n²) में जाँचता है, और इंटरव्यूअर आम तौर पर चाहते हैं कि आप पहले उसका ज़िक्र करें और फिर सुधारें।

2. Valid parentheses: जाँचें कि हर ब्रैकेट सही क्रम में बंद हुआ है

शुरुआती ब्रैकेट को स्टैक में डालें। बंद करने वाले ब्रैकेट पर स्टैक का सबसे ऊपर वाला तत्व उसका मिलता-जुलता शुरुआती ब्रैकेट होना चाहिए।

def is_valid(s):
    pairs = {")": "(", "]": "[", "}": "{"}
    stack = []
    for ch in s:
        if ch in pairs:
            if not stack or stack.pop() != pairs[ch]:
                return False
        else:
            stack.append(ch)
    return not stack

print(is_valid("([]{})"), is_valid("(]"))  # True False

टाइम O(n) और स्पेस O(n)। आखिरी लाइन ज़रूरी है: "((" जैसी स्ट्रिंग में स्टैक में तत्व बचे रहते हैं, और वह वैध नहीं है।

3. ओवरलैप होने वाले इंटरवल मर्ज करें

शुरू होने के समय के हिसाब से सॉर्ट करें, फिर या तो आखिरी मर्ज किए गए इंटरवल को बढ़ाएँ या नया इंटरवल शुरू करें।

def merge_intervals(intervals):
    merged = []
    for start, end in sorted(intervals):
        if merged and start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])
    return merged

print(merge_intervals([[1, 3], [2, 6], [8, 10], [15, 18]]))
# [[1, 6], [8, 10], [15, 18]]

सॉर्ट की वजह से टाइम O(n log n) है। पूछें कि [1, 2] और [2, 3] जैसे एक-दूसरे को छूने वाले इंटरवल मर्ज होने चाहिए या नहीं। यह वर्ज़न उन्हें मर्ज करता है।

4. लिंक्ड लिस्ट को उलटें

लिस्ट को एक बार पार करें और हर नोड को उसके पिछले नोड की ओर मोड़ दें।

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

def reverse_list(head):
    prev = None
    while head:
        head.next, prev, head = prev, head, head.next
    return prev

टाइम O(n) और अतिरिक्त स्पेस O(1)। अगर इंटरव्यूअर को एक साथ कई असाइनमेंट वाली लाइन ज़्यादा चालाकी भरी लगे, तो उसे temporary variable के साथ तीन लाइनों में लिखें। साफ़ होना छोटे होने से बेहतर है।

5. सबसे ज़्यादा बार आने वाले k तत्व लौटाएँ

हैश मैप से गिनती करें, फिर heap की मदद से सबसे बड़ी k गिनतियाँ लें।

from collections import Counter
import heapq

def top_k_frequent(nums, k):
    counts = Counter(nums)
    return [x for x, _ in heapq.nlargest(k, counts.items(), key=lambda p: p[1])]

print(top_k_frequent([1, 1, 1, 2, 2, 3], 2))  # [1, 2]

टाइम O(n log k)। एक फ़ॉलो-अप सवाल है: आवृत्ति के हिसाब से bucket sort, जिससे टाइम O(n) हो जाता है।

6. O(1) get और put वाला LRU cache डिज़ाइन करें

आपको तेज़ लुकअप चाहिए और हाल के उपयोग के हिसाब से तेज़ री-ऑर्डरिंग भी। हैश मैप और doubly linked list मिलकर दोनों काम करते हैं। Python में OrderedDict ठीक यही संयोजन है।

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.data = OrderedDict()

    def get(self, key):
        if key not in self.data:
            return -1
        self.data.move_to_end(key)
        return self.data[key]

    def put(self, key, value):
        if key in self.data:
            self.data.move_to_end(key)
        self.data[key] = value
        if len(self.data) > self.capacity:
            self.data.popitem(last=False)

कुछ इंटरव्यूअर आपसे linked list खुद बनाने को कहेंगे। पहले संरचना समझाएँ: मैप लिस्ट के नोड्स की ओर इशारा करता है, सबसे हाल का नोड एक सिरे पर रहता है, और दूसरे सिरे से हटाया (evict) जाता है।

7. दीवारों वाले ग्रिड में सबसे छोटा रास्ता

जब हर कदम की लागत एक जैसी हो, तब ब्रेड्थ-फ़र्स्ट सर्च सबसे छोटा रास्ता खोजता है।

from collections import deque

def shortest_path(grid):
    rows, cols = len(grid), len(grid[0])
    if grid[0][0] or grid[rows - 1][cols - 1]:
        return -1
    queue = deque([(0, 0, 0)])
    seen = {(0, 0)}
    while queue:
        r, c, steps = queue.popleft()
        if (r, c) == (rows - 1, cols - 1):
            return steps
        for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < rows and 0 <= nc < cols and not grid[nr][nc] and (nr, nc) not in seen:
                seen.add((nr, nc))
                queue.append((nr, nc, steps + 1))
    return -1

print(shortest_path([[0, 0, 0], [1, 1, 0], [0, 0, 0]]))  # 4

टाइम और स्पेस O(rows × cols)। सेल को queue में डालते समय ही देखा हुआ (seen) चिह्नित करें, निकालते समय नहीं, वरना वही सेल कई बार queue में चला जाएगा।

8. पहला खराब वर्ज़न खोजें

वर्ज़न 1 से n तक किसी बिंदु तक ठीक रहते हैं और उसके बाद खराब। बाइनरी सर्च O(log n) जाँचों में पहला खराब वर्ज़न खोज लेती है।

def first_bad_version(n, is_bad):
    lo, hi = 1, n
    while lo < hi:
        mid = (lo + hi) // 2
        if is_bad(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

यह पैटर्न हर उस हाँ या ना वाले सवाल पर लागू होता है जो एक बार बदलता है, और यह अक्सर आता है। इन पैटर्न को कवर करने वाली समस्याओं की सूची के लिए Blind 75 देखें।

CS की बुनियादी बातों के सवाल

9. process और thread में क्या अंतर है?

process एक चल रहा प्रोग्राम है जिसकी अपनी मेमोरी स्पेस होती है। Thread एक process के अंदर चलते हैं और उसकी मेमोरी साझा करते हैं। Thread बनाने और उनके बीच स्विच करने में सस्ते होते हैं और सीधे डेटा साझा कर सकते हैं, लेकिन यही साझाकरण locks की ज़रूरत और race conditions की वजह बनता है। Process एक-दूसरे से अलग होते हैं, इसलिए एक का क्रैश बाकी को बंद नहीं करता।

10. TCP और UDP में क्या अंतर है?

TCP कनेक्शन स्थापित करता है और retransmission व flow control के साथ क्रम में और भरोसेमंद डिलीवरी की गारंटी देता है। UDP स्वतंत्र पैकेट भेजता है, जिनकी डिलीवरी या क्रम की कोई गारंटी नहीं होती, और ओवरहेड कम होता है। वेब पेज, API और फ़ाइल ट्रांसफ़र के लिए TCP इस्तेमाल करें। लाइव वॉइस, वीडियो और गेम के लिए UDP ठीक है, जहाँ देर से पहुँचा पैकेट वैसे भी बेकार होता है। हमारे कंप्यूटर नेटवर्किंग इंटरव्यू के सवाल इस विषय पर और गहराई से जाते हैं।

11. ब्राउज़र में URL लिखकर Enter दबाने पर क्या होता है?

ब्राउज़र DNS के ज़रिए डोमेन को IP एड्रेस में बदलता है, एक TCP कनेक्शन खोलता है, और HTTPS के लिए TLS handshake करता है। वह HTTP request भेजता है, और सर्वर, जो अक्सर load balancer के पीछे होता है, response लौटाता है। ब्राउज़र HTML को पार्स करता है, उसमें दिए गए CSS, JavaScript और इमेज माँगता है, और पेज रेंडर करता है। इंटरव्यूअर जो भी हिस्सा चुने, उसमें गहराई से जाएँ।

12. हैश टेबल कैसे काम करती है, और उसकी टाइम कॉम्प्लेक्सिटी क्या है?

हैश फ़ंक्शन हर key को एक array के bucket से मैप करता है। लुकअप, इन्सर्ट और डिलीट औसतन O(1) होते हैं। जब दो keys एक ही bucket में आती हैं, तो टेबल chaining से या किसी दूसरे स्लॉट को probe करके टकराव (collision) को संभालती है, और ज़्यादा भर जाने पर आकार बदलती है (resize)। अगर बहुत सारी keys टकराती हैं, तो सबसे खराब स्थिति O(n) है।

13. NoSQL के बजाय SQL डेटाबेस कब चुनेंगे?

जब डेटा रिलेशनल हो, आपको joins और transactions चाहिए, और schema काफ़ी स्थिर हो, जैसे ऑर्डर, पेमेंट, यूज़र अकाउंट, तब SQL चुनें। जब एक्सेस पैटर्न सरल हो, डेटा का आकार अलग-अलग हो, या कई मशीनों पर write को स्केल करना हो, तब document या key-value स्टोर चुनें। कई सिस्टम दोनों इस्तेमाल करते हैं। इंटरव्यूअर जो जवाब चाहते हैं, वह ट्रेड-ऑफ़ है, विजेता नहीं। हमारे REST API इंटरव्यू के सवाल उस API लेयर को कवर करते हैं जो आम तौर पर ऊपर होती है।

सिस्टम डिज़ाइन के सवाल

14. URL शॉर्टनर डिज़ाइन करें

पहले ज़रूरतें स्पष्ट करें: एक दिन में कितने नए लिंक बनते हैं, कितनी रीड होती हैं, लिंक की समय-सीमा खत्म होती है या नहीं, कस्टम alias की अनुमति है या नहीं। फिर API (बनाना और redirect करना) समझाएँ, छोटे कोड कैसे बनते हैं (base 62 में encode किया गया counter, या uniqueness जाँच के साथ random कोड), स्टोरेज (कोड से URL तक key-value स्टोर), और लोकप्रिय लिंक के लिए cache, क्योंकि रीड की संख्या राइट से कहीं ज़्यादा होती है। समय हो तो analytics और abuse रोकने के तरीकों पर खत्म करें। पूरा डिज़ाइन हम अपनी सिस्टम डिज़ाइन गाइड में समझाते हैं।

15. रेट लिमिटर डिज़ाइन करें

शुरुआत इस बात से करें कि यह कहाँ चलता है (API gateway पर, हर यूज़र या हर API key के हिसाब से) और जब कोई क्लाइंट सीमा से आगे जाता है तो क्या होता है (retry समय के साथ HTTP 429)। आम विकल्प token bucket है: हर क्लाइंट के पास एक bucket होता है जो तय दर से भरता है और जिसमें tokens की अधिकतम संख्या रहती है, और हर request एक token इस्तेमाल करती है। यह औसत दर लागू करते हुए छोटे बर्स्ट की अनुमति देता है। कई सर्वर हों तो काउंटर को Redis जैसे साझा स्टोर में रखें, ताकि हर सर्वर एक ही संख्या देखे। और अभ्यास के लिए हमारे सिस्टम डिज़ाइन इंटरव्यू के सवाल देखें।

व्यवहार संबंधी सवाल

हर कहानी के लिए साफ़ ढाँचा रखें: स्थिति, आपने क्या किया, और नतीजा, जहाँ आपके पास आँकड़े हों वहाँ आँकड़ों के साथ।

16. अपने बारे में बताइए

अपने करियर का दो मिनट का संस्करण दें, जो इस बात पर खत्म हो कि आप यह भूमिका क्यों चाहते हैं। ठोस नतीजों वाले एक या दो प्रोजेक्ट का ज़िक्र करें। अपने बारे में बताइए पर हमारी गाइड में उदाहरण हैं।

17. किसी कठिन बग के बारे में बताइए जिसे आपने ठीक किया

नमूना जवाब: "हमारी checkout सर्विस दिन में कुछ बार बिना किसी पैटर्न के timeout होने लगी। मैंने लॉग में request IDs जोड़ीं और पाया कि हर timeout एक ही database query से आ रहा था, जो तभी चलती थी जब कार्ट में 50 से ज़्यादा आइटम होते थे। उस query में join वाले column पर index नहीं था। मैंने index जोड़ा, धीमी query का समय लगभग 4 सेकंड से घटकर 50 मिलीसेकंड से कम हो गया, और उस query की latency पर एक alert भी जोड़ा ताकि अगली बार यह जल्दी पकड़ में आए।"

18. किसी साथी के साथ मतभेद के बारे में बताइए

नमूना जवाब: "एक साथी चाहता था कि हम अपनी notification सर्विस को एक नए framework में फिर से लिखें, जबकि मुझे लॉन्च से पहले इसका जोखिम बहुत ज़्यादा लगा। मीटिंग में बहस करने के बजाय मैंने सुझाव दिया कि हम दोनों लागत और जोखिम लिखकर रखें। हम इस बात पर सहमत हुए कि लॉन्च से पहले मौजूदा कोड की दो सबसे खराब समस्याएँ ठीक की जाएँ और फिर से लिखने का काम अगली तिमाही के लिए रखा जाए। लॉन्च समय पर हो गया, और दो महीने बाद हमने एक ठीक टेस्ट प्लान के साथ फिर से लिखने का काम किया।"

19. किसी ऐसे प्रोजेक्ट के बारे में बताइए जो असफल रहा

कोई असली असफलता चुनें जिसका एक हिस्सा आपकी ज़िम्मेदारी था। बताएँ कि क्या गलत हुआ, आप अलग तरीके से क्या करते, और बाद में आपने क्या बदला। इंटरव्यूअर ईमानदारी और सीखने की क्षमता परख रहे होते हैं, कोई बेदाग रिकॉर्ड नहीं।

20. आप यहाँ काम क्यों करना चाहते हैं?

कंपनी के प्रोडक्ट या इंजीनियरिंग काम की किसी खास बात को अपने अनुभव से जोड़ें। "मैं दो साल से आपका API इस्तेमाल कर रहा हूँ और मैं प्लेटफ़ॉर्म की तरफ़ काम करना चाहूँगा" कहना "आप एक बेहतरीन कंपनी हैं" से कहीं बेहतर है।

इंटरव्यूअर से पूछने लायक सवाल

• इस टीम में किसी के लिए एक आम हफ़्ता कैसा दिखता है?
• काम की योजना कैसे बनती है, और प्राथमिकताएँ कौन तय करता है?
• यहाँ कोड रिव्यू और डिप्लॉयमेंट कैसे होता है?
• पहले छह महीने में सफलता कैसी दिखेगी?
• टीम जिस सबसे कठिन तकनीकी समस्या पर काम कर रही है, वह कौन सी है?

और जानकारी के लिए इंटरव्यू के अंत में पूछने लायक सवाल देखें।

तैयारी कैसे करें

1. एक भाषा चुनें और हर अभ्यास समस्या में उसी का इस्तेमाल करें। Python सबसे आम विकल्प है, क्योंकि उसका कोड छोटा होता है। भाषा की पूरी जानकारी के लिए हमारे Python इंटरव्यू के सवाल देखें।
2. गिनती के बजाय पैटर्न के हिसाब से अभ्यास करें: हैश मैप, दो पॉइंटर, sliding window, बाइनरी सर्च, BFS और DFS, heaps, और dynamic programming।
3. टाइमर लगाकर समस्याएँ ज़ोर से बोलकर हल करें। सही लेकिन चुपचाप किया गया हल, साफ़ बोलकर समझाए गए हल से कम अंक पाता है।
4. उसी एडिटर में अभ्यास करें जिसका आप इंटरव्यू में इस्तेमाल करेंगे। कई कंपनियाँ CoderPad इस्तेमाल करती हैं, जिसका एक मुफ़्त सैंडबॉक्स है।
5. अपने काम की पाँच कहानियाँ तैयार रखें, जिन्हें ज़्यादातर व्यवहार संबंधी सवालों के हिसाब से ढाला जा सके।
6. मिड-लेवल और सीनियर भूमिकाओं के लिए, किसी ऐसे व्यक्ति के साथ कम से कम कुछ पूरे सिस्टम डिज़ाइन अभ्यास सत्र करें जो फ़ॉलो-अप सवाल पूछे।