मान लीजिए हम एक डेटा स्ट्रक्चर विकसित करना चाहते हैं जिसे इंटीजर्स की सूची के साथ बनाया जा सके, और एक फ़ंक्शन हो जो इंडेक्स i से इंडेक्स j-1 तक के एलिमेंट्स का योग कुशल तरीके से ढूंढ सके। दो फ़ंक्शन हैं: कंस्ट्रक्टर जो इंटीजर ऐरे के साथ नया इंस्टेंस बनाता है get_sum(i, j) ऐरे एलिमेंट्स के शुरूआती

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

मान लीजिए हमारे पास एक बाइनरी स्ट्रिंग s है। अब एक ऑपरेशन पर विचार करें जहां हम एक बिट चुनते हैं और उसके मान को 0 से 1 या इसके विपरीत फ्लिप करते हैं। हमें उस न्यूनतम ऑपरेशन की संख्या ढूंढनी है जिससे एक ऐसी स्ट्रिंग मिले जिसमें तीन समान लगातार बिट्स न हों। उदाहरण के लिए, यदि इनपुट है s = 10011100, त

मान लीजिए हमारे पास दो अंग्रेजी स्ट्रिंग्स s और t हैं, वे लोअरकेस और/या अपरकेस में हो सकती हैं। हमें जांचना होगा कि क्या एक दूसरे का रोटेशन है या नहीं। उदाहरण के लिए, यदि इनपुट है s = koLKAta और t = KAtakoL, तो आउटपुट True होगा। समाधान दृष्टिकोण यदि s का आकार t के आकार के बराबर नहीं है, तो False ल

मान लीजिए हम एक इटरेटर क्लास परिभाषित करना चाहते हैं जो रन-लेंथ एन्कोडेड लोअरकेस स्ट्रिंग s से निर्मित होता है। इस इटरेटर के लिए दो फ़ंक्शन हैं: next() - इटरेटर में अगला एलिमेंट ढूंढता है hasnext() - जांचता है कि अगला एलिमेंट मौजूद है या नहीं उदाहरण के लिए, यदि इनपुट s = 2b1a है, तो इस s के साथ ए

मान लीजिए हमारे पास एक संख्या n है, जहां n लोग सीट खोज रहे हैं। हमारे पास बिट्स की एक सूची भी है जहां 1 पहले से भरी हुई सीट को दर्शाता है और 0 खाली सीट को। कोई भी दो लोग एक-दूसरे के बगल में नहीं बैठ सकते, इसलिए हमें जांचना होगा कि क्या सभी n लोगों को सीट मिल सकती है या नहीं। उदाहरण के लिए, यदि इनपु

मान लीजिए हम निम्नलिखित विधियों के साथ एक सेट डेटा संरचना लागू करना चाहते हैं: सेट का नया इंस्टेंस बनाने के लिए कंस्ट्रक्टर add(val) पूर्णांक val को सेट में डालने के लिए exists(val) जांचने के लिए कि val सेट में है या नहीं remove(val) सेट से val को हटाने के लिए इसलिए, यदि हम एक सेट s बनाते हैं, फिर

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, जहां n तत्व मौजूद हैं। हमें जांचना है कि क्या हम पहली n प्राकृतिक संख्याओं के साथ एक सूची बना सकते हैं या तो बढ़ते या घटते क्रम में, जैसे [1, 2, ..., n] या [n, n - 1, ..., 1] nums को दाएं किसी भी संख्या में बार शिफ्ट करके। इसलिए, यदि इनपुट है num

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है। यदि nums में सबसे अधिक बारंबार संख्या की आवृत्ति k है। हमें सबसे छोटे सबलिस्ट की लंबाई ढूंढनी है जैसे कि उसके सबसे अधिक बारंबार आइटम की आवृत्ति भी k हो। इसलिए, यदि इनपुट है nums = [10, 20, 30, 40, 30, 10], तो आउटपुट होगा 3, क्योंकि यहां सबसे अधिक

मान लीजिए हमारे पास चार संभावित वर्णों 1, 2, 3 और ? के साथ एक स्ट्रिंग s है। हम ? के स्थान पर 1, 2 और 3 में से कोई एक रख सकते हैं। हमें सबसे छोटी संभव संख्या ढूंढनी है जिसे हम बना सकते हैं जैसे कि कोई दो आसन्न अंक समान न हों। इसलिए, यदि इनपुट है s = 2??3?, तो आउटपुट होगा 21231। इसे हल करने के लिए, ह

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है। अब किसी भी इंडेक्स जोड़े (i, j) पर विचार करें जहां i < j और 1। फिर सबसे छोटा जोड़ी योग ढूंढें। इसलिए, यदि इनपुट है nums = [3, 4, 2, 2, 4], तो आउटपुट होगा 5, हम मान 3 और 2 चुन सकते हैं इसलिए कुल योग 5 है। हम 2 और 2 नहीं चुन सकते क्योंकि वे आसन्न

मान लीजिए हमारे पास nums में संख्याओं की एक सूची है। हमें सूची को आरोही क्रम में प्रत्येक संख्या के बाइनरी प्रतिनिधित्व में मौजूद 1 की संख्या के आधार पर सॉर्ट करना है। यदि दो संख्याओं में 1 की संख्या समान है, तो उन्हें उनके मानों के आधार पर व्यवस्थित करें। इसलिए, यदि इनपुट है nums = [4, 1, 12, 7, 6]

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है, जहां तत्व आरोही क्रम में सॉर्ट हैं, हमें तत्वों का वर्ग करना है और परिणाम को क्रमबद्ध क्रम में लौटाना है। इसलिए, यदि इनपुट है nums = [-8, -3, 0, 5, 6], तो आउटपुट होगा [0, 9, 25, 36, 64]। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे: n := nums

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है। हमें जांचना है कि क्या सूची सख्ती से बढ़ते हुए फिर सख्ती से घटते हुए और फिर सख्ती से बढ़ते हुए और इसी तरह वैकल्पिक रूप से चलती है। और यदि सूची केवल सख्ती से बढ़ रही है, तो यह भी मान्य होगी। इसलिए, यदि इनपुट है nums = [2, 4, 8, 7, 5, 1, 5, 7, 2, 1

मान लीजिए हमारे पास दो स्ट्रिंग्स s और t हैं। हम t बनाना चाहते हैं, लेकिन कीबोर्ड में कुछ समस्याएं हैं जहां कुछ वर्ण अटके हुए हैं इसलिए वे 1 या अधिक बार लिखे जा सकते हैं। हमें जांचना है कि क्या टाइप की गई s का मतलब t लिखना था या नहीं। इसलिए, यदि इनपुट है s = appppleee, t = apple, तो आउटपुट होगा True

मान लीजिए हमारे पास एक संख्या n है, हमें पहले n धनात्मक विषम पूर्णांकों का योग ढूंढना है। इसलिए, यदि इनपुट है n = 10, तो आउटपुट होगा 100, क्योंकि पहले 10 विषम पूर्णांक [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] हैं और उनका योग 100 है। इसे हल करने के लिए, हम इन चरणों का पालन करेंगे: एक अच्छा अवलोकन है, पहल

मान लीजिए हम एक डेटा संरचना बनाना चाहते हैं जिसमें दो विधियाँ हों: add(val) यह मान val को डेटा संरचना में जोड़ता है find(val) यह जांचता है कि क्या दो तत्व हैं जिनका योग val है या नहीं हमें इसे इस तरह डिज़ाइन करना है कि हम ऑन-द-फ्लाई परिणाम प्राप्त कर सकें। हम हर बार क्वेरी आने पर संख्याओं की खोज न

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है और एक लक्ष्य मान भी है, हमें nums में संख्याओं के सबसे बड़े जोड़े का योग ढूंढना है जिसका योग अधिकतम (target - 1) है। इसलिए, यदि इनपुट है nums = [8, 3, 4, 9, 2], target = 8, तो आउटपुट होगा 7, क्योंकि 8 से कम सबसे बड़े जोड़े का योग 4 + 3 = 7 है। इसे

मान लीजिए हमारे पास nums नामक संख्याओं की एक सूची है और nums में तत्व आरोही क्रम में सॉर्ट हैं। हमारे पास एक और मान k भी है, हमें जांचना है कि सूची से लिए गए किन्हीं दो तत्वों का योग k तक है या नहीं। संख्याएं ऋणात्मक या 0 भी हो सकती हैं। हमें इस समस्या को स्थिर मात्रा में स्पेस उपयोग में हल करना है।

मान लीजिए हमारे पास दो लोअरकेस स्ट्रिंग्स s और t हैं, वे समान लंबाई की हैं। हम s से एक वर्ण और t से दूसरे को चुन सकते हैं और उन्हें स्वैप कर सकते हैं। हम यह ऑपरेशन जितनी बार चाहें कर सकते हैं। अंत में, हमें जांचना है कि क्या दोनों स्ट्रिंग्स को समान बनाना संभव है या नहीं। इसलिए, यदि इनपुट है s = abc