SQL साक्षात्कार की तैयारी · पाठ

प्रति उपयोगकर्ता सबसे लंबा लगातार क्रम

प्रत्येक समूह के भीतर लगातार चलने वाले क्रम की अधिकतम लंबाई निकालना

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

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

प्रश्न

लगातार दिनों का पता लगाने के बाद अक्सर यह अगला प्रश्न पूछा जाता है: "प्रत्येक उपयोगकर्ता के लिए लगातार सक्रिय दिनों का उनका सबसे लंबा क्रम कौन-सा है?" उत्पाद और वृद्धि दल सहभागिता मापने के लिए यह प्रश्न लगातार पूछते हैं।

आप पहले से जानते हैं कि प्रत्येक क्रम की पहचान कैसे करनी है। नया चरण है प्रत्येक उपयोगकर्ता के लिए क्रम की अधिकतम लंबाई ढूँढ़ना और अक्सर उस सबसे अच्छे क्रम की तारीखें भी लौटाना। यह पाठ सीधे अंतराल और खंडों के प्रारूप पर आधारित है।

खंड-निर्माता को याद करें

पिछले पाठ में प्रत्येक क्रम का समूहीकरण login_date - ROW_NUMBER() को खंड के आधार के रूप में उपयोग करता था। प्रत्येक उपयोगकर्ता के कई खंड हो सकते हैं; पहले हम प्रत्येक खंड के लिए एक पंक्ति निकालेंगे, फिर उसे घटाकर प्रत्येक उपयोगकर्ता के लिए एक पंक्ति करेंगे।

इस दो-स्तरीय योजना को याद रखें: पहले खंड बनाएँ, फिर उन खंडों का समेकन करें।

WITH numbered AS (
  SELECT user_id, login_date,
    ROW_NUMBER() OVER (
      PARTITION BY user_id ORDER BY login_date
    ) AS rn
  FROM logins
)
SELECT user_id, login_date - rn AS grp
FROM numbered;

प्रत्येक खंड के लिए एक पंक्ति

प्रत्येक खंड को उसकी लंबाई और तारीख-सीमा वाली एक सारांश पंक्ति में समेटें। उपयोगकर्ता और आधार के अनुसार समूह बनाकर मापदंड निकालें।

हम इस CTE का नाम islands रखते हैं, ताकि अगला स्तर इससे साफ़-सुथरे ढंग से पढ़ सके।

WITH numbered AS (
  SELECT user_id, login_date,
    ROW_NUMBER() OVER (
      PARTITION BY user_id ORDER BY login_date
    ) AS rn
  FROM logins
),
islands AS (
  SELECT user_id,
    MIN(login_date) AS streak_start,
    MAX(login_date) AS streak_end,
    COUNT(*)        AS streak_len
  FROM numbered
  GROUP BY user_id, login_date - rn
)
SELECT * FROM islands;

सरल उत्तर: MAX लंबाई

यदि साक्षात्कारकर्ता को केवल लंबाई चाहिए, तो अंतिम चरण एक-पंक्ति समाधान है: उपयोगकर्ता के अनुसार खंडों का समूह बनाएँ और अधिकतम लंबाई लें।

जब आरंभ और अंत की तारीखें आवश्यक न हों, तब यही सबसे साफ़ उत्तर है।

-- ...numbered and islands CTEs as before...
SELECT
  user_id,
  MAX(streak_len) AS longest_streak
FROM islands
GROUP BY user_id
ORDER BY user_id;

तारीखें भी लौटाना

अक्सर साक्षात्कारकर्ता आगे जोड़ता है: "और यह भी दिखाइए कि वह लगातार क्रम कब हुआ था।" साधारण MAX यह नहीं बता सकता कि कौन-सा खंड विजेता रहा। आपको प्रत्येक उपयोगकर्ता के खंडों को क्रम देना होगा और क्रम 1 को रखना होगा।

लंबाई के घटते क्रम में ROW_NUMBER का उपयोग करें, ताकि प्रत्येक उपयोगकर्ता के सबसे अच्छे क्रम को क्रम 1 मिले। बराबरी की स्थिति में परिणाम निश्चित रखने के लिए एक अतिरिक्त निर्णायक मान जोड़ें।

ROW_NUMBER() OVER (
  PARTITION BY user_id
  ORDER BY streak_len DESC, streak_start ASC
) AS rnk

क्रम देना और छाँटना

क्रम देने की प्रक्रिया को CTE में लपेटें, फिर rnk = 1 तक छाँटें। आप WHERE में सीधे विंडो फ़ंक्शन पर शर्त नहीं लगा सकते, इसलिए अतिरिक्त स्तर आवश्यक है।

WITH numbered AS (
  SELECT user_id, login_date,
    ROW_NUMBER() OVER (
      PARTITION BY user_id ORDER BY login_date
    ) AS rn
  FROM logins
),
islands AS (
  SELECT user_id,
    MIN(login_date) AS streak_start,
    MAX(login_date) AS streak_end,
    COUNT(*)        AS streak_len
  FROM numbered
  GROUP BY user_id, login_date - rn
),
ranked AS (
  SELECT *,
    ROW_NUMBER() OVER (
      PARTITION BY user_id
      ORDER BY streak_len DESC, streak_start
    ) AS rnk
  FROM islands
)
SELECT user_id, streak_start, streak_end, streak_len
FROM ranked
WHERE rnk = 1;

बराबरी की स्थिति में RANK बनाम ROW_NUMBER

अगर किसी उपयोगकर्ता के दो लगातार क्रम समान अधिकतम लंबाई के हों और साक्षात्कारकर्ता दोनों लौटाने को कहे, तो ROW_NUMBER की जगह RANK लगाएँ और rnk = 1 रखें।

ROW_NUMBER — प्रत्येक उपयोगकर्ता के लिए ठीक एक विजेता (अतिरिक्त निर्णायक मान न देने पर बराबरी में मनमाना)।
RANK — बराबर सबसे लंबे सभी क्रमों को क्रम 1 मिलता है और सभी रखे जाते हैं।

स्पष्ट करें कि साक्षात्कारकर्ता कौन-सा व्यवहार चाहता है; इससे सीमांत स्थितियों पर आपका ध्यान दिखाई देता है।

RANK() OVER (
  PARTITION BY user_id
  ORDER BY streak_len DESC
) AS rnk  -- keep all rnk = 1

उदाहरण सहित समाधान

मान लें कि उपयोगकर्ता 7 ने 1–4 जनवरी, फिर 10–11 जनवरी, और फिर 20–23 जनवरी को प्रवेश किया। तीन खंडों की लंबाइयाँ 4, 2 और 4 हैं। सबसे बड़ी लंबाई 4 है और इसमें बराबरी है।

ROW_NUMBER + निर्णायक मान streak_start के साथ: केवल 1–4 जनवरी वाला क्रम लौटता है।
RANK के साथ: 1–4 जनवरी और 20–23 जनवरी, दोनों क्रम लौटते हैं।

इसे ज़ोर से बताने से साबित होता है कि आपने दोहराव पर विचार किया है।

लॉगिन न करने वाले उपयोगकर्ताओं को संभालना

साक्षात्कारकर्ता पूछ सकते हैं: "उन उपयोगकर्ताओं का क्या, जिन्होंने कभी लॉगिन नहीं किया?" ऐसे उपयोगकर्ताओं की logins में कोई पंक्ति नहीं होती, इसलिए वे परिणाम से गायब हो जाते हैं। यदि उन्हें 0 के लगातार दिनों के क्रम के साथ दिखाना आवश्यक हो, तो पूरी users तालिका को LEFT JOIN करें और COALESCE का उपयोग करें।

SELECT u.user_id,
  COALESCE(MAX(i.streak_len), 0) AS longest_streak
FROM users u
LEFT JOIN islands i ON i.user_id = u.user_id
GROUP BY u.user_id;

प्रदर्शन संबंधी टिप्पणियाँ

यह तरीका डेटा पर क्रमबद्ध एकल पास और उसके बाद समूहीकरण करता है। इसे तेज़ रखने के लिए:

(user_id, login_date) पर अनुक्रमणिका सुनिश्चित करें, ताकि विंडो का ORDER BY क्रमबद्धता से बच सके।
यदि स्रोत में प्रति दिन कई घटनाएँ हों, तो पहले ही दोहराव हटा दें।
ORDER BY में login_date को फ़ंक्शन में लपेटने से बचें, क्योंकि इससे अनुक्रमणिका का उपयोग रुक सकता है।

बहुत बड़ी तालिकाओं के लिए यह किसी भी स्व-संयोजन तरीके से स्पष्ट रूप से बेहतर प्रदर्शन करता है।

संपूर्ण साक्षात्कार उत्तर

यहाँ वह पूरी, सुव्यवस्थित क्वेरी है जो प्रत्येक उपयोगकर्ता का उसकी तिथियों सहित सबसे लंबा लगातार दिनों का क्रम लौटाती है — श्वेतपट पर लिखने योग्य संस्करण।

WITH numbered AS (
  SELECT user_id, login_date,
    ROW_NUMBER() OVER (
      PARTITION BY user_id ORDER BY login_date
    ) AS rn
  FROM logins
),
islands AS (
  SELECT user_id,
    MIN(login_date) AS streak_start,
    MAX(login_date) AS streak_end,
    COUNT(*)        AS streak_len
  FROM numbered
  GROUP BY user_id, login_date - rn
),
ranked AS (
  SELECT *,
    ROW_NUMBER() OVER (
      PARTITION BY user_id
      ORDER BY streak_len DESC, streak_start
    ) AS rnk
  FROM islands
)
SELECT user_id, streak_start, streak_end, streak_len
FROM ranked
WHERE rnk = 1
ORDER BY user_id;

त्वरित जाँच

आवश्यकता के लिए सही साधन चुनें।

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

पुनरावलोकन

प्रति उपयोगकर्ता सबसे लंबा लगातार दिनों का क्रम निकालने के लिए:

login_date - ROW_NUMBER() आधार का उपयोग करके खंड बनाएँ।
प्रत्येक खंड को लंबाई और तिथि-सीमा तक संक्षिप्त करें।
केवल लंबाई के लिए, उपयोगकर्ता के अनुसार समूहीकृत MAX(streak_len) का उपयोग करें।
तिथियाँ भी चाहिए हों, तो प्रत्येक उपयोगकर्ता के खंडों की रैंक निकालें और रैंक 1 रखें — बराबरी शामिल करने के लिए RANK, एक विजेता के लिए ROW_NUMBER।
0 लगातार-दिन वाले उपयोगकर्ताओं को दिखाने के लिए उपयोगकर्ताओं की तालिका को LEFT JOIN करें।

अगला विषय: किसी शर्त को पूरा करने वाली N लगातार पंक्तियों का पता लगाना।

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

एआई शिक्षक के साथ SQL सीखें — निःशुल्क

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

पाठ्यक्रम: 30
पाठ: 120

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

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

क्या “प्रति उपयोगकर्ता सबसे लंबा लगातार क्रम” पाठ निःशुल्क है?

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

“प्रति उपयोगकर्ता सबसे लंबा लगातार क्रम” में मैं क्या सीखूँगा?

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

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

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

“प्रति उपयोगकर्ता सबसे लंबा लगातार क्रम” पाठ पूरा करने में कितना समय लगता है?

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

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

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

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

← SQL साक्षात्कार की तैयारी पर वापस जाएँ