हमें nवें सुपर अगली नंबर को ढूंढने के लिए एक फंक्शन बनाना है। सुपर अगली नंबर वे पॉजिटिव नंबर हैं जिनके सभी प्राइम फैक्टर दिए गए प्राइम लिस्ट primes में हैं जिसका आकार k है। यदि n 12 है और primes [2, 7, 13, 19] हैं, तो आउटपुट 32 होगा, ऐसा इसलिए क्योंकि [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32] 12 स

मान लीजिए एक चोर ने अपनी चोरी के लिए एक नई जगह ढूंढ ली है। इस क्षेत्र में केवल एक प्रवेश द्वार है, प्रवेश द्वार को रूट कहा जाता है। रूट के अलावा, प्रत्येक घर का एक और केवल एक पैरेंट घर होता है। एक दौरे के बाद, स्मार्ट चोर को लगा कि इस जगह के सभी घर एक बाइनरी ट्री बनाते हैं। और यदि दो सीधे-लिंक्ड घरो

मान लीजिए हमारे पास एक स्ट्रिंग s और एक नॉन-खाली स्ट्रिंग p है, हमें s में p के सभी एनाग्राम के स्टार्ट इंडेक्स ढूंढने हैं। स्ट्रिंग्स में केवल लोअरकेस लेटर्स होते हैं और दोनों स्ट्रिंग्स s और p की लंबाई 20 और 100 से अधिक नहीं होगी। उदाहरण के लिए, यदि s: cbaebabacd p: abc, तो आउटपुट [0, 6] होगा, इंड

मान लीजिए हमारे पास एक कैरेक्टर ऐरे है जो उन टास्क्स को दर्शाता है जिन्हें CPU को करने की आवश्यकता है। इसमें अपरकेस लेटर्स A से Z होते हैं जहां अलग-अलग लेटर्स अलग-अलग टास्क्स को दर्शाते हैं। टास्क्स को मूल क्रम के बिना किया जा सकता है। प्रत्येक टास्क को एक इंटरवल में किया जा सकता है। प्रत्येक इंटरवल

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

मान लीजिए एक फुल बाइनरी ट्री एक बाइनरी ट्री है जहां प्रत्येक नोड के ठीक 0 या 2 बच्चे होते हैं। इसलिए हमें N नोड्स वाले सभी संभावित फुल बाइनरी ट्रीज़ की सूची ढूंढनी है। उत्तर में प्रत्येक ट्री के प्रत्येक नोड का node.val = 0 होना चाहिए। लौटाए गए ट्री किसी भी क्रम में हो सकते हैं। यदि इनपुट 7 है, तो ट

मान लीजिए हमारे पास इंटीजर्स का एक ऐरे A है। हमें min(B) का योग ढूंढना है, जहां B, A के हर (सन्निहित) सबएरे पर रेंज करता है। चूंकि उत्तर बहुत बड़ा हो सकता है, इसलिए उत्तर को मॉड्यूलो 10^9 + 7 में लौटाएं। यदि इनपुट [3,1,2,4] है, तो आउटपुट 17 होगा, क्योंकि सबएरे हैं [3], [1], [2], [4], [3,1], [1,2], [

जैसा कि हम जानते हैं, एक कंप्लीट बाइनरी ट्री एक बाइनरी ट्री है जिसमें हर लेवल, संभवतः अंतिम को छोड़कर, पूरी तरह से भरा होता है, और सभी नोड्स जितना संभव हो उतना बाईं ओर होते हैं। हमें एक डेटा स्ट्रक्चर CBTInserter लिखना है जिसे एक कंप्लीट बाइनरी ट्री के साथ इनिशियलाइज़ किया जाता है और यह निम्नलिखित ऑ

मान लीजिए हमारे पास एक बाइनरी ट्री की रूट है, इसके रूट का लेवल 1 है, इसके बच्चों का लेवल 2 है, और इसी तरह। हमें सबसे छोटा लेवल X लौटाना है जैसे कि लेवल X पर सभी नोड्स के मानों का योग अधिकतम हो। यदि ट्री इस प्रकार है -तो आउटपुट 2 होगा, लेवल 1 का योग = 1, लेवल 2 का योग 7 + 0 = 7 है, लेवल 3 का योग 7 +

मान लीजिए हमारे पास कुछ स्टिक्स हैं जिनकी लंबाई पॉजिटिव इंटीजर है। हम किन्हीं दो स्टिक्स को लंबाई X और Y की एक स्टिक में कनेक्ट कर सकते हैं, जिसकी लागत X + Y है। यह तब तक किया जाएगा जब तक एक स्टिक शेष न रह जाए। हमें इस तरह दिए गए सभी स्टिक्स को एक स्टिक में कनेक्ट करने की न्यूनतम लागत ढूंढनी है। यदि

मान लीजिए हमारे पास इंटीजर्स का एक ऐरे है; हमें अधिकतम एक एलिमेंट डिलीशन के साथ नॉन-खाली सबएरे (सन्निहित एलिमेंट्स) के लिए अधिकतम सम ढूंढना है। दूसरे शब्दों में, हम कह सकते हैं कि हम एक सबएरे चुनना चाहते हैं और वैकल्पिक रूप से उससे एक एलिमेंट डिलीट करना चाहते हैं ताकि कम से कम एक एलिमेंट बचा रहे और

मान लीजिए हमारे पास दो बाइनरी सर्च ट्रीज़ हैं, हमें True लौटाना है यदि और केवल यदि पहले ट्री में एक नोड और दूसरे ट्री में एक नोड है और इन नोड्स का योग एक दिए गए इंटीजर टार्गेट के बराबर है। यदि ट्री इस प्रकार है -और टार्गेट 5 है, तो परिणाम true होगा।इसे हल करने के लिए, हम निम्नलिखित चरणों का पालन करे

मान लीजिए हमारे पास एक इंटीजर ऐरे arr और एक इंटीजर difference है, हमें arr में सबसे लंबे सबसीक्वेंस की लंबाई ढूंढनी है जो एक अंकगणितीय अनुक्रम है जैसे कि सबसीक्वेंस में आसन्न एलिमेंट्स के बीच का अंतर difference के समान है। यदि इनपुट [1,5,7,8,5,3,4,2,1] है और difference -2 है, तो आउटपुट 4 होगा, क्यों

मान लीजिए हमें एक लीडरबोर्ड क्लास डिज़ाइन करनी है, इसमें तीन अलग-अलग फंक्शन्स हैं -addScore(playerId, score) - यह दिए गए प्लेयर के स्कोर में स्कोर जोड़कर लीडरबोर्ड को अपडेट करेगा। जब दिए गए आईडी वाला कोई प्लेयर लीडरबोर्ड में नहीं है, तो उसे दिए गए स्कोर के साथ लीडरबोर्ड में जोड़ें।top(K) - यह टॉप K

मान लीजिए हमारे पास एक अनडायरेक्टेड ट्री है; हमें इसका डायमीटर ढूंढना है - उस ट्री में सबसे लंबे पथ में एज की संख्या उस ट्री का डायमीटर है। यहां ट्री को एज लिस्ट के रूप में दिया गया है जहां edges[i] = [u, v] नोड्स u और v के बीच एक बायडायरेक्शनल एज है। प्रत्येक नोड के लेबल सेट {0, 1, ..., edges.lengt

मान लीजिए हमारे पास समान लंबाई के दो स्ट्रिंग्स s1 और s2 हैं जिनमें केवल x और y अक्षर हैं। हमारा कार्य इन दो स्ट्रिंग्स को एक-दूसरे के बराबर बनाना है। हम किन्हीं दो वर्णों को स्वैप कर सकते हैं जो अलग-अलग स्ट्रिंग्स से संबंधित हैं, जिसका अर्थ है - swap s1[i] और s2[j]। हमें s1 और s2 को बराबर बनाने के

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

मान लीजिए हमारे पास डिस्जॉइंट इंटरवल्स की एक सॉर्टेड सूची है, प्रत्येक इंटरवल intervals[i] = [a, b] उन संख्याओं x के सेट को दर्शाता है जैसे कि a <= x < b। हमें intervals में किसी भी इंटरवल और toBeRemoved इंटरवल के बीच के इंटरसेक्शन को हटाना है। अंत में, हमें ऐसे सभी हटाने के बाद इंटरवल्स की सॉर्टेड

मान लीजिए हमारे पास एक ट्री है, यह ट्री नोड 0 पर रूटेड है, यह निम्नानुसार दिया गया है -नोड्स की संख्या nodes हैi-वें नोड का मान value[i] हैi-वें नोड का पैरेंट parent[i] हैहमें हर उस सबट्री को हटाना है जिसके नोड्स के मानों का योग 0 है, ऐसा करने के बाद ट्री में शेष नोड्स की संख्या लौटाएं। यदि ट्री इस

मान लीजिए हमें एक इटरेटर क्लास डिज़ाइन करनी है, जिसमें कुछ ऑपरेशन्स हों -एक कंस्ट्रक्टर परिभाषित करें जो सॉर्टेड डिस्टिंक्ट लोअरकेस इंग्लिश लेटर्स की एक स्ट्रिंग characters और एक नंबर combinationLength को पैरामीटर के रूप में लेता है।next() नामक एक फंक्शन परिभाषित करें जो अल्फाबेटिक क्रम में combinat