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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

मान लीजिए हमारे पास एक 2D मैट्रिक्स है जहां प्रत्येक सेल matrix[r, c] उस सेल में मौजूद सिक्कों की संख्या दर्शाता है। जब हम matrix[r, c] से सिक्के उठाते हैं, तो पंक्ति (r - 1) और (r + 1) पर सभी सिक्के गायब हो जाएंगे, साथ ही दो सेल matrix[r, c + 1] और matrix[r, c - 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 दी गई है जिसमें 0 और 1 हैं। हमारा कार्य दिए गए स्ट्रिंग में 1 को स्वैप करके 0 और 1 को समूहित करना है। हमें न्यूनतम संख्या में स्वैप ऑपरेशन करने हैं, और हमें वह मान लौटाना है। एक बात ध्यान रखें, हम केवल आसन्न मानों को स्वैप कर सकते हैं। इसलिए, यदि इनपुट है