कोडिंग साक्षात्कार की तैयारी · पाठ

SEQUENCE में gaps खोजना

अनुपलब्ध मान और प्रत्येक gap की शुरुआत तथा अंत पहचानें

पाठ 3, कुल 4 में से13 चरण

SEQUENCE में gaps खोजना, CoddyKit पर कोडिंग साक्षात्कार की तैयारी का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह कोडिंग साक्षात्कार की तैयारी सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। कोडिंग साक्षात्कार की तैयारी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

अब रिक्तियाँ खोजें

अब तक हमने पंक्तियों को द्वीपों में समूहित किया है। इसका उलटा साक्षात्कार-प्रश्न है: कौन-से मान मौजूद नहीं हैं? साक्षात्कारकर्ता इसे इस तरह पूछ सकते हैं: "इस ID क्रम में रिक्तियाँ खोजिए", "कौन-सी चालान संख्याएँ छूट गईं", या "कौन-से दिनों में कोई गतिविधि नहीं हुई"।

रिक्तियाँ द्वीपों के बीच के खाली स्थान हैं। मुख्य बात यह समझना है कि आम तौर पर आपको हर एक गायब मान की सूची बनाने की आवश्यकता नहीं होती; आपको हर रिक्ति-परास का आरंभ और अंत बताना होता है, जो कहीं अधिक संक्षिप्त है और साक्षात्कारकर्ता इसी की अपेक्षा करते हैं।

रिक्तियों का नमूना डेटा-समुच्चय

seq(n) तालिका से मौजूद मान 1, 2, 3, 7, 8, 10 फिर से लें। बताई जाने वाली रिक्तियाँ हैं:

4 से 6 तक (पहले द्वीप के बाद, 7 से पहले)
9 से 9 तक (8 और 10 के बीच)

ध्यान दें कि हम रिक्ति को एक परास के रूप में बताते हैं: रिक्ति का आरंभ = मौजूद अंतिम मान + 1, रिक्ति का अंत = अगला मौजूद मान - 1। नीचे दी गई मुख्य तकनीक का लक्ष्य यही संक्षिप्त रूप है।

CREATE TABLE seq (n INT);
INSERT INTO seq VALUES (1),(2),(3),(7),(8),(10);

रिक्तियाँ खोजने की LEAD विधि

रिक्तियाँ खोजने का सबसे साफ़ तरीका LEAD का उपयोग करके हर पंक्ति की तुलना अगली पंक्ति से करना है। यदि अगला मान वर्तमान मान से 1 से अधिक बड़ा है, तो उनके बीच एक रिक्ति है।

ऐसी हर पंक्ति के लिए रिक्ति n + 1 से शुरू होती है और next_n - 1 पर समाप्त होती है। पहले मूल LEAD परिणाम देखें:

SELECT
  n,
  LEAD(n) OVER (ORDER BY n) AS next_n
FROM seq
ORDER BY n;

रिक्ति-परास दिखाना

LEAD परिणाम को एक CTE में रखें और केवल उन पंक्तियों को रखें जहाँ अगले मान तक की छलाँग 1 से अधिक हो। ऐसी पंक्तियाँ रिक्तियों को दर्शाती हैं:

इससे ठीक 4-6 और 9-9 वाली रिक्तियाँ मिलती हैं। next_n - n - 1 अभिव्यक्ति हर रिक्ति में गायब मानों की संख्या भी देती है, जो अक्सर आगे पूछा जाने वाला प्रश्न है।

WITH stepped AS (
  SELECT n, LEAD(n) OVER (ORDER BY n) AS next_n
  FROM seq
)
SELECT
  n + 1            AS gap_start,
  next_n - 1       AS gap_end,
  next_n - n - 1   AS missing_count
FROM stepped
WHERE next_n - n > 1
ORDER BY gap_start;

सममित LAG विधि

इसके बजाय LAG से पीछे देखकर भी वही रिक्तियाँ खोजी जा सकती हैं। वर्तमान पंक्ति से पहले तब रिक्ति होती है जब पिछला मान उससे 1 से अधिक कम हो।

दोनों विधियाँ पूरी तरह समान हैं; प्रश्न के लिए जो अधिक स्वाभाविक लगे, उसे चुनें। कुछ साक्षात्कारकर्ता LEAD को पसंद करते हैं, क्योंकि इसमें रिक्ति को उससे पहले आने वाली पंक्ति के सापेक्ष बताया जाता है, जैसा लोग सामान्य बातचीत में कहते हैं।

WITH stepped AS (
  SELECT n, LAG(n) OVER (ORDER BY n) AS prev_n
  FROM seq
)
SELECT prev_n + 1 AS gap_start,
       n - 1       AS gap_end
FROM stepped
WHERE n - prev_n > 1
ORDER BY gap_start;

हर गायब मान की सूची बनाना

कभी-कभी साक्षात्कारकर्ता केवल परास नहीं, बल्कि गायब संख्याओं की पूरी सूची चाहते हैं। भरोसेमंद तरीका है अपेक्षित पूरी श्रेणी बनाना और जो मान मौजूद हैं, उनके विरुद्ध एंटी-जॉइन करना। Postgres में generate_series पूरी सीमा बनाता है:

अपेक्षित परास में मौजूद हर वह पूर्णांक जो seq में नहीं है, एक गायब मान है। यदि इच्छित न्यूनतम और अधिकतम ज्ञात हों, तो यह दोनों किनारों की रिक्तियों को भी संभालता है।

SELECT g.n AS missing_value
FROM generate_series(
       (SELECT MIN(n) FROM seq),
       (SELECT MAX(n) FROM seq)
     ) AS g(n)
LEFT JOIN seq s ON s.n = g.n
WHERE s.n IS NULL
ORDER BY g.n;

अलग-अलग डेटाबेस-भाषाओं में श्रेणी बनाना

हर इंजन में generate_series उपलब्ध नहीं होता। इसके विकल्प जानें:

पोस्टग्रेज़: generate_series(1, 100)।
एसक्यूएल सर्वर: एक पुनरावर्ती CTE या संख्या/गिनती तालिका।
MySQL 8: अधिकतम मान तक गिनती करने वाला पुनरावर्ती CTE।

पुनरावर्ती CTE पोर्टेबल वैकल्पिक उपाय है। यह वही अपेक्षित श्रेणी बनाता है, जिसके विरुद्ध एंटी-जॉइन किया जा सकता है।

WITH RECURSIVE nums AS (
  SELECT (SELECT MIN(n) FROM seq) AS n
  UNION ALL
  SELECT n + 1 FROM nums
  WHERE n + 1 <= (SELECT MAX(n) FROM seq)
)
SELECT nums.n AS missing_value
FROM nums
LEFT JOIN seq s ON s.n = nums.n
WHERE s.n IS NULL;

कैलेंडर तारीखों में रिक्तियाँ

गायब तारीखों के लिए दैनिक चरण वाला पूरा कैलेंडर बनाएँ और एंटी-जॉइन करें। यह मानक "किन दिनों में कोई ऑर्डर नहीं था" प्रश्न है:

वास्तविक तारीखों पर LEAD लागू करके इसे परास वाली तकनीक के साथ मिलाएँ, ताकि अलग-अलग दिनों के बजाय गायब तारीखों के परास दिखाए जा सकें; सीमाओं के लिए + INTERVAL '1 day' का उपयोग करें।

SELECT d::date AS missing_day
FROM generate_series(
       DATE '2026-01-01', DATE '2026-01-31',
       INTERVAL '1 day') AS d
LEFT JOIN daily_logins l ON l.login_date = d::date
WHERE l.login_date IS NULL
ORDER BY missing_day;

डेटा की सीमा के बाहर की रिक्तियाँ

एक सूक्ष्म समस्या यह है कि LEAD/LAG केवल मौजूद मानों के बीच की रिक्तियाँ खोजते हैं। यदि न्यूनतम मौजूद मान से पहले या अधिकतम मौजूद मान के बाद कोई संख्या गायब हो, तो विंडो वाली विधि उसे नहीं देख सकती, क्योंकि वहाँ पड़ोसी पंक्ति होती ही नहीं।

यदि साक्षात्कारकर्ता अपेक्षित पूरी सीमा परिभाषित करता है (मान लीजिए ID 1 से 100 तक) और आपका डेटा 5 से शुरू होता है, तो आपको डेटा के अपने न्यूनतम और अधिकतम के बजाय घोषित सीमा से सीमित generate_series एंटी-जॉइन का उपयोग करना होगा। हमेशा स्पष्ट करें कि अपेक्षित सीमाएँ पहले से तय हैं या नहीं।

SELECT g.n AS missing_value
FROM generate_series(1, 100) AS g(n)
LEFT JOIN seq s ON s.n = g.n
WHERE s.n IS NULL;

हर समूह के लिए रिक्तियाँ खोजना

प्रत्येक उपयोगकर्ता की रिक्तियों के लिए, LEAD/LAG को समूह वाले स्तंभ के आधार पर विभाजित करें, ताकि दो अलग-अलग उपयोगकर्ताओं की धाराओं के बीच कभी रिक्ति न बताई जाए:

हर उपयोगकर्ता के गायब परासों की गणना स्वतंत्र रूप से की जाती है। द्वीपों की तरह, विभाजन करना भूल जाने पर उपयोगकर्ता चुपचाप मिल जाते हैं और असंबंधित पंक्तियों के बीच काल्पनिक रिक्तियाँ बनती हैं।

WITH stepped AS (
  SELECT user_id, n,
    LEAD(n) OVER (PARTITION BY user_id ORDER BY n) AS next_n
  FROM seq_per_user
)
SELECT user_id, n + 1 AS gap_start, next_n - 1 AS gap_end
FROM stepped
WHERE next_n - n > 1
ORDER BY user_id, gap_start;

रिक्तियों की सही विधि चुनना

साक्षात्कार के लिए निर्णय-मार्गदर्शिका:

संक्षिप्त परास चाहिए और केवल अंदरूनी रिक्तियाँ खोजनी हों? LEAD/LAG का उपयोग करें और उन पंक्तियों को रखें जहाँ चरण 1 से अधिक हो।
हर एक गायब मान चाहिए या डेटा की सीमाओं के बाहर की रिक्तियाँ खोजनी हों? घोषित पूरी सीमा के विरुद्ध generate_series एंटी-जॉइन का उपयोग करें।

दोनों विकल्प और उनके उपयोग का समय बताना आपकी गहरी समझ दर्शाता है। LEAD वाली विधि कम संसाधन लेती है; श्रेणी वाली विधि अधिक पूर्ण परिणाम देती है।

त्वरित जाँच

सीमा से जुड़ी समस्या को अच्छी तरह समझ लें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: रिक्तियाँ खोजना

रिक्तियों की पहचान अब पक्की करें:

रिक्तियों को परास के रूप में बताएँ: रिक्ति का आरंभ = मान + 1, रिक्ति का अंत = अगला मान - 1।
LEAD (या सममित LAG) को उन पंक्तियों तक सीमित करने पर जहाँ चरण 1 से अधिक है, अंदरूनी रिक्तियाँ कम लागत में मिल जाती हैं।
generate_series एंटी-जॉइन हर गायब मान की सूची बनाता है और घोषित सीमा के आधार पर किनारों की रिक्तियाँ भी पकड़ता है।
जहाँ generate_series उपलब्ध नहीं है, वहाँ पुनरावर्ती CTE श्रेणी बनाते हैं।
प्रत्येक उपयोगकर्ता की रिक्तियों के लिए समूह वाले स्तंभ के आधार पर विभाजन करें।
अपेक्षित सीमाओं को हमेशा स्पष्ट करें।

अंत में हम सबसे समृद्ध रूप पर आते हैं: तारीख और स्थिति में बदलाव के आधार पर परिभाषित द्वीप।

शुरुआत निःशुल्क

एआई शिक्षक के साथ कोडिंग साक्षात्कार की तैयारी सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 90
पाठ: 360

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “SEQUENCE में gaps खोजना” पाठ निःशुल्क है?

हाँ—“SEQUENCE में gaps खोजना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और कोडिंग साक्षात्कार की तैयारी पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। कोडिंग साक्षात्कार की तैयारी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“SEQUENCE में gaps खोजना” में मैं क्या सीखूँगा?

अनुपलब्ध मान और प्रत्येक gap की शुरुआत तथा अंत पहचानें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ कोडिंग साक्षात्कार की तैयारी का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या कोडिंग साक्षात्कार की तैयारी शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर कोडिंग साक्षात्कार की तैयारी शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“SEQUENCE में gaps खोजना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस कोडिंग साक्षात्कार की तैयारी पाठ में कोड लिख और चला सकता हूँ?

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

इस पाठ्यक्रम के सभी पाठ

← कोडिंग साक्षात्कार की तैयारी पर वापस जाएँ