मान लीजिए कि हमारे पास एक पूर्णांक n है, जो एक हवाई जहाज में सीटों की संख्या का प्रतिनिधित्व करता है। अब विचार करें कि पहले यात्री ने अपना टिकट खो दिया है, इसलिए वह एक यादृच्छिक सीट चुनता है। अब बाकी सभी के पास अपना टिकट है, लेकिन अगर उनकी सीट पहले ही ले ली गई है, तो वे एक उपलब्ध सीट का भी बेतरतीब ढ

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

मान लीजिए कि हमारे पास एक लोअरकेस वर्णमाला स्ट्रिंग है जिसे s कहा जाता है और इसमें जोड़े की एक सूची भी है जिसे जोड़े कहा जाता है। जोड़े में प्रत्येक तत्व में दो तार होते हैं [ए, बी] जहां वर्ण ए और बी को समान माना जाता है। यदि [ए, बी] और [बी, सी] जैसे दो जोड़े हैं, तो हम कह सकते हैं कि ए और बी समकक्ष

मान लीजिए कि हमारे पास एक सूची ग्राहक और एक अन्य सूची मूड है, ये दोनों समान लंबाई के हैं, हमारे पास एक और पूर्णांक k है। अब प्रत्येक मिनट पर, ग्राहक [i] स्टोर पर लोगों की संख्या आती है और जब मूड [i] =1 होता है, तो यह इंगित करता है कि ग्राहक खुश हैं और जब मूड [i] =0, तो वे दुखी होते हैं। हम k मूड के

मान लीजिए हमारे पास संख्याओं की एक सूची है जिसे अंक कहा जाता है और प्रश्नों की सूची भी है। जहां प्रत्येक क्वेरी तत्व में [i, j] होता है। तो यह प्रश्न पूछ रहा है कि [i, j] (दोनों समावेशी) से अंकों की सबलिस्ट अंकगणितीय अनुक्रम है या नहीं। तो अंत में हमें उन प्रश्नों की संख्या का पता लगाना होगा जो सत्य

मान लीजिए कि हमारे पास क्रमशः उत्तर, दक्षिण, पश्चिम और पूर्व के लिए चार दिशाओं एन, एस, डब्ल्यू और ई के साथ एक स्ट्रिंग है। हमें सबसे छोटे सबस्ट्रिंग का आकार खोजना होगा जिसे हम इस तरह अपडेट कर सकते हैं कि चार दिशाओं में से प्रत्येक n/4 बार आए, जहां n स्ट्रिंग s का आकार है। इसलिए, यदि इनपुट s =NNSWWE

मान लीजिए कि हमारे पास एक बाइनरी सूची है जिसे nums कहा जाता है जिसमें केवल 0s और 1s होते हैं जहां 0 खाली सेल को इंगित करता है और 1 इंगित करता है कि सेल एक गेंद से भरा हुआ है। हमें मान L की एक नई सूची ढूंढनी है, जिसका आकार भी अंकों के आकार के समान है, जहां L[i] सभी गेंदों को L[i] पर ले जाने के लिए आव

मान लीजिए कि हमारे पास 0s या 1s के साथ एक बाइनरी सूची है। हमारे पास k नामक एक अन्य इनपुट भी है, हमें उन सबलिस्ट्स की संख्या ज्ञात करनी है जिनका योग k के समान है। इसलिए, यदि इनपुट संख्या =[1, 0, 0, 1, 1, 1, 0, 1] k =3 की तरह है, तो आउटपुट 8 होगा क्योंकि सबलिस्ट [1,0,0,1,1] हैं ], [0,0,1,1,1], [0,0,1

मान लीजिए कि हमारे पास दो मान प्रारंभ और अंत हैं, हमें बिटवाइज़ और श्रेणी में सभी संख्याओं का पता लगाना है [प्रारंभ, अंत] (दोनों समावेशी)। तो, अगर इनपुट स्टार्ट =8 एंड =12 जैसा है, तो आउटपुट 8 होगा 1000 बाइनरी में और 12 बाइनरी में 1100 है, इसलिए 1000 और 1001 और 1010 और 1011 और 1100 1000 है जो 8 है।

मान लीजिए कि हमारे पास एक स्ट्रिंग है, जो रोबोट की चाल का प्रतिनिधित्व करती है। रोबोट वर्तमान में (0, 0) स्थिति में है और इसका मुख उत्तर की ओर है। मूव स्ट्रिंग s में ये वर्ण हो सकते हैं F दिशा आगे बढ़ने के लिए, एक इकाई L 90 डिग्री बाएं घुमाने के लिए R 90 डिग्री दाएं घुमाने के लिए इसलिए यदि रोबोट

मान लीजिए हमारे पास nums1 और nums2 संख्याओं की दो सूची है। और दो नंबर लोअर और अपर भी होते हैं। हमें जोड़े की संख्या ज्ञात करनी है (i, j) जैसे कि कम ≤ nums1[i]^2 + nums2[j]^2 ≤ ऊपर। इसलिए, यदि इनपुट nums1 =[5, 3, 2] nums2 =[8, 12, 6] निचला =10 ऊपरी =50 जैसा है, तो आउटपुट 2 होगा क्योंकि जोड़े (1, 2)

मान लीजिए कि हमारे पास ईंटों नामक संख्याओं की एक सूची है और दो अन्य मान चौड़ाई और ऊंचाई हैं। ईंटों में प्रत्येक तत्व [i] एक ईंट का प्रतिनिधित्व करता है जिसकी लंबाई ईंटें [i] इकाइयाँ और चौड़ाई 1 इकाई है। हमें ईंटों को बिछाने के तरीकों की संख्या का पता लगाना है ताकि हमें दी गई चौड़ाई और ऊंचाई के साथ ई

मान लीजिए कि हमारे पास एक लोअरकेस स्ट्रिंग s है और पूर्णांकों की एक और सूची है जिसे शिफ्ट कहा जाता है जिसकी लंबाई s की लंबाई के समान है। यहां पाली में प्रत्येक तत्व [i] यह इंगित करता है कि यह पहले i + 1 अक्षरों को पाली [i] पदों से स्थानांतरित करता है। यदि स्थानांतरण z को पार करता है तो इसे a तक लपेट

मान लीजिए कि हमारे पास एक स्ट्रिंग है जिसमें केवल तीन वर्ण X, (, और ) हैं। स्ट्रिंग में संतुलित कोष्ठक होते हैं और कुछ X के बीच में संभावित रूप से नेस्टेड कोष्ठक भी पुनरावर्ती रूप से हो सकते हैं। हमें s में कोष्ठक की प्रत्येक गहराई पर X की संख्या ज्ञात करनी है, जो सबसे कम गहराई से शुरू होकर सबसे गहर

मान लीजिए हमारे पास एक वृत्ताकार सूची है जिसे अंक कहते हैं। तो पहला और आखिरी तत्व पड़ोसी हैं। तो किसी भी सूचकांक से शुरू करते हुए कहते हैं कि, हम अंक [i] कदमों की संख्या आगे बढ़ा सकते हैं यदि अंक [i] एक सकारात्मक मान है, अन्यथा पीछे की तरफ अगर यह नकारात्मक मान है। हमें यह जांचना होगा कि क्या कोई चक्

मान लीजिए कि हमारे पास दो सूचियां हैं, वे कोर और कार्य हैं। कोर [i] ith सर्वर में उपलब्ध कोर की संख्या को इंगित करता है। और कार्य [i] उस कार्य को निष्पादित करने के लिए आवश्यक कोर की संख्या को इंगित करता है। प्रत्येक कार्य केवल एक सर्वर में चलाया जाना चाहिए। और एक सर्वर को चलाने के लिए कई कार्य हो सक

मान लीजिए कि हमारे पास एक 2डी मैट्रिक्स है जहां प्रत्येक सेल मैट्रिक्स [आर, सी] उस सेल में मौजूद सिक्कों की संख्या का प्रतिनिधित्व करता है। जब हम मैट्रिक्स [आर, सी] से सिक्के उठाते हैं, तो पंक्ति (आर -1) और (आर + 1) के सभी सिक्के गायब हो जाएंगे, साथ ही दो कोशिकाओं मैट्रिक्स [आर, सी + 1] और के सिक्के

मान लीजिए कि हमारे पास एक निर्देशित ग्राफ की एक बढ़त सूची है, n नोड्स हैं और नोड नाम 0 से n-1 हैं। हमारे पास दो पूर्णांक मान a और b भी हैं। हमें यह जांचना होगा कि क्या कोई नोड c ऐसा है कि हम c से a और c से b तक भी जा सकते हैं। तो, अगर इनपुट पसंद है और a =2, b =3, तो आउटपुट ट्रू होगा, क्योंकि यहा

मान लीजिए कि हमारे पास दो सूचियाँ nums1 और nums2 हैं। इन दो सूचियों में से प्रत्येक रन-लेंथ एन्कोडेड रूप में एक वेक्टर का प्रतिनिधित्व कर रही है। तो एक उदाहरण के रूप में, एक वेक्टर [1, 1, 1, 2, 2, 2, 2] को [3, 1, 4, 2] के रूप में दर्शाया गया है। (क्योंकि 3 वाले और 4 दो हैं)। तो हमें इन दो वैक्टरों क

मान लीजिए कि हमें एक बाइनरी स्ट्रिंग input_str दिया गया है जिसमें 0s और 1s हैं। हमारा काम दिए गए स्ट्रिंग में 1s को स्वैप करके 0s और 1 को समूहित करना है। हमें न्यूनतम संख्या में स्वैप ऑपरेशन करने होंगे, और हमें वह मान वापस करना होगा। एक बात का ध्यान रखें, हम केवल आसन्न मूल्यों को स्वैप कर सकते हैं।